valtech-components 2.0.691 → 2.0.692

package/esm2022/lib/services/feedback/types.mjs

@@ -0,0 +1,30 @@
+/**
+ * Configuración por defecto de tipos de feedback.
+ */
+export const DEFAULT_FEEDBACK_TYPE_OPTIONS = [
+    {
+        value: 'issue',
+        label: 'Reportar problema',
+        description: 'Algo no funciona correctamente',
+        icon: 'bug-outline',
+    },
+    {
+        value: 'poor-content',
+        label: 'Contenido incorrecto',
+        description: 'Información incorrecta o desactualizada',
+        icon: 'document-text-outline',
+    },
+    {
+        value: 'feedback',
+        label: 'Comentario general',
+        description: 'Tu opinión o experiencia',
+        icon: 'chatbubble-outline',
+    },
+    {
+        value: 'suggestion',
+        label: 'Sugerencia',
+        description: 'Propuesta de mejora o nueva funcionalidad',
+        icon: 'bulb-outline',
+    },
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/feedback/types.ts"],"names":[],"mappings":"AAiJA;;GAEG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAyB;IACjE;QACE,KAAK,EAAE,OAAO;QACd,KAAK,EAAE,mBAAmB;QAC1B,WAAW,EAAE,gCAAgC;QAC7C,IAAI,EAAE,aAAa;KACpB;IACD;QACE,KAAK,EAAE,cAAc;QACrB,KAAK,EAAE,sBAAsB;QAC7B,WAAW,EAAE,yCAAyC;QACtD,IAAI,EAAE,uBAAuB;KAC9B;IACD;QACE,KAAK,EAAE,UAAU;QACjB,KAAK,EAAE,oBAAoB;QAC3B,WAAW,EAAE,0BAA0B;QACvC,IAAI,EAAE,oBAAoB;KAC3B;IACD;QACE,KAAK,EAAE,YAAY;QACnB,KAAK,EAAE,YAAY;QACnB,WAAW,EAAE,2CAA2C;QACxD,IAAI,EAAE,cAAc;KACrB;CACF,CAAC","sourcesContent":["/**\n * Configuración del servicio de Feedback.\n */\nexport interface ValtechFeedbackConfig {\n  /** URL base de la API */\n  apiUrl: string;\n  /** ID de la aplicación (ej: 'my-valtech-app') */\n  appId: string;\n  /** Prefijo para endpoints (default: '/v1/feedback') */\n  feedbackPrefix?: string;\n  /** Número máximo de adjuntos (default: 5) */\n  maxAttachments?: number;\n  /** Tamaño máximo por archivo en bytes (default: 10MB) */\n  maxFileSize?: number;\n  /** Tipos de archivo permitidos (default: ['image/*', 'video/*', 'application/pdf']) */\n  allowedFileTypes?: string[];\n  /** Ruta en Firebase Storage para adjuntos (default: 'feedback') */\n  storagePath?: string;\n}\n\n/**\n * Tipos de feedback disponibles.\n */\nexport type FeedbackType =\n  | 'issue'\n  | 'poor-content'\n  | 'feedback'\n  | 'suggestion'\n  | 'reaction';\n\n/**\n * Valor de reacción (para feedback tipo emoji).\n */\nexport type ReactionValue = 'negative' | 'neutral' | 'positive';\n\n/**\n * Estado de un feedback.\n */\nexport type FeedbackStatus = 'new' | 'reviewed' | 'resolved';\n\n/**\n * Tipos de contenido para referencia.\n */\nexport type ContentType =\n  | 'article'\n  | 'faq'\n  | 'news'\n  | 'page'\n  | 'product'\n  | 'event'\n  | 'other';\n\n/**\n * Referencia a contenido específico.\n */\nexport interface ContentRef {\n  contentId: string;\n  contentType: ContentType;\n}\n\n/**\n * Referencia a entidad (para reactions y feedback de contenido).\n */\nexport interface EntityRef {\n  /** Tipo de entidad: 'article', 'docs', 'feature', 'bug', etc. */\n  entityType: string;\n  /** ID de la entidad */\n  entityId: string;\n}\n\n/**\n * Contexto del dispositivo del usuario.\n */\nexport interface DeviceContext {\n  browser: string;\n  os: string;\n  viewport: string;\n  language: string;\n  userAgent: string;\n  pageUrl: string;\n}\n\n/**\n * Entrada de feedback completa.\n */\nexport interface Feedback {\n  feedbackId: string;\n  appId: string;\n  userId: string;\n  type: FeedbackType;\n  title: string;\n  description: string;\n  attachments: string[];\n  contentRef?: ContentRef;\n  entityRef?: EntityRef;\n  reactionValue?: ReactionValue;\n  deviceContext: DeviceContext;\n  status: FeedbackStatus;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/**\n * Request para crear feedback.\n */\nexport interface CreateFeedbackRequest {\n  type: FeedbackType;\n  title?: string;\n  description?: string;\n  attachments?: string[];\n  contentRef?: ContentRef;\n  entityRef?: EntityRef;\n  reactionValue?: ReactionValue;\n  deviceContext: DeviceContext;\n  appId: string;\n}\n\n/**\n * Response al crear feedback.\n */\nexport interface CreateFeedbackResponse {\n  operationId: string;\n  feedbackId: string;\n  status: FeedbackStatus;\n  createdAt: string;\n}\n\n/**\n * Response al obtener feedback.\n */\nexport interface GetFeedbackResponse {\n  operationId: string;\n  feedback: Feedback;\n}\n\n/**\n * Opciones de tipo de feedback para UI.\n */\nexport interface FeedbackTypeOption {\n  value: FeedbackType;\n  label: string;\n  description?: string;\n  icon?: string;\n}\n\n/**\n * Configuración por defecto de tipos de feedback.\n */\nexport const DEFAULT_FEEDBACK_TYPE_OPTIONS: FeedbackTypeOption[] = [\n  {\n    value: 'issue',\n    label: 'Reportar problema',\n    description: 'Algo no funciona correctamente',\n    icon: 'bug-outline',\n  },\n  {\n    value: 'poor-content',\n    label: 'Contenido incorrecto',\n    description: 'Información incorrecta o desactualizada',\n    icon: 'document-text-outline',\n  },\n  {\n    value: 'feedback',\n    label: 'Comentario general',\n    description: 'Tu opinión o experiencia',\n    icon: 'chatbubble-outline',\n  },\n  {\n    value: 'suggestion',\n    label: 'Sugerencia',\n    description: 'Propuesta de mejora o nueva funcionalidad',\n    icon: 'bulb-outline',\n  },\n];\n\n// =============================================================================\n// Check Feedback Types\n// =============================================================================\n\n/**\n * Response al verificar si existe feedback para una entidad.\n */\nexport interface CheckFeedbackResponse {\n  operationId: string;\n  hasFeedback: boolean;\n  feedbackId?: string;\n  type?: FeedbackType;\n  reactionValue?: ReactionValue;\n  createdAt?: string;\n}\n\n// =============================================================================\n// List Feedback Types (Admin)\n// =============================================================================\n\n/**\n * Request para listar feedback (admin).\n */\nexport interface ListFeedbackRequest {\n  appId?: string;\n  type?: FeedbackType;\n  status?: FeedbackStatus;\n  entityType?: string;\n  entityId?: string;\n  userId?: string;\n  dateFrom?: string;\n  dateTo?: string;\n  limit?: number;\n  nextToken?: string;\n}\n\n/**\n * Response al listar feedback.\n */\nexport interface ListFeedbackResponse {\n  operationId: string;\n  feedbacks: Feedback[];\n  nextToken?: string;\n  count: number;\n}\n\n// =============================================================================\n// Firebase Types\n// =============================================================================\n\n/**\n * Documento de feedback en Firestore.\n * Usado para lectura rápida del estado de feedback del usuario.\n *\n * Path: apps/{appId}/feedback/{entityType}/{entityId}/{userId}\n */\nexport interface FeedbackFirestoreDoc {\n  id?: string;\n  feedbackId: string;\n  type: string;\n  reactionValue: string;\n  createdAt?: Date;\n  updatedAt?: Date;\n}\n"]}

package/esm2022/lib/services/firebase/analytics-error-handler.mjs

@@ -0,0 +1,141 @@
+/**
+ * Analytics Error Handler
+ *
+ * ErrorHandler personalizado que envía errores no capturados a Firebase Analytics.
+ * Se activa si enableErrorTracking=true en analyticsConfig.
+ */
+import { ErrorHandler, Injectable, inject } from '@angular/core';
+import { AnalyticsService } from './analytics.service';
+import * as i0 from "@angular/core";
+/**
+ * ErrorHandler que trackea errores en Firebase Analytics.
+ *
+ * Captura errores no manejados de la aplicación y los envía a GA4
+ * como eventos 'error_occurred'. También delega al ErrorHandler
+ * default para mantener el comportamiento de console.error.
+ *
+ * @example
+ * ```typescript
+ * // Se activa automáticamente si enableErrorTracking=true
+ * provideValtechFirebase({
+ *   firebase: environment.firebase,
+ *   enableAnalytics: true,
+ *   analyticsConfig: {
+ *     enableErrorTracking: true,
+ *   },
+ * });
+ * ```
+ */
+export class AnalyticsErrorHandler {
+    constructor() {
+        this.analytics = inject(AnalyticsService);
+        this.defaultHandler = new ErrorHandler();
+    }
+    /**
+     * Maneja un error no capturado.
+     * Envía el error a Analytics y luego al handler default.
+     */
+    handleError(error) {
+        // Enviar a Analytics
+        try {
+            this.trackError(error);
+        }
+        catch (trackingError) {
+            // No fallar si el tracking falla
+            console.warn('[AnalyticsErrorHandler] Error tracking failed:', trackingError);
+        }
+        // Delegar al handler default (console.error)
+        this.defaultHandler.handleError(error);
+    }
+    /**
+     * Trackea el error en Analytics
+     */
+    trackError(error) {
+        // Extraer información del error
+        const errorInfo = this.extractErrorInfo(error);
+        this.analytics.logError(errorInfo.error, {
+            source: 'uncaught',
+            url: this.getCurrentUrl(),
+            ...errorInfo.context,
+        });
+    }
+    /**
+     * Extrae información útil del error
+     */
+    extractErrorInfo(error) {
+        const context = {};
+        // Error estándar
+        if (error instanceof Error) {
+            // Detectar errores de chunk loading (lazy loading)
+            if (error.message.includes('Loading chunk')) {
+                context['error_category'] = 'chunk_loading';
+            }
+            // Detectar errores de red
+            if (error.message.includes('NetworkError') || error.message.includes('Failed to fetch')) {
+                context['error_category'] = 'network';
+            }
+            return { error, context };
+        }
+        // ErrorEvent (ej: errores de script)
+        if (typeof ErrorEvent !== 'undefined' && error instanceof ErrorEvent) {
+            return {
+                error: new Error(error.message || 'Script error'),
+                context: {
+                    filename: error.filename || 'unknown',
+                    lineno: String(error.lineno || 0),
+                    colno: String(error.colno || 0),
+                },
+            };
+        }
+        // PromiseRejection
+        if (this.isPromiseRejection(error)) {
+            const reason = error.reason;
+            if (reason instanceof Error) {
+                return {
+                    error: reason,
+                    context: { error_category: 'unhandled_promise' },
+                };
+            }
+            return {
+                error: new Error(String(reason) || 'Unhandled promise rejection'),
+                context: { error_category: 'unhandled_promise' },
+            };
+        }
+        // Objeto con message
+        if (error && typeof error === 'object' && 'message' in error) {
+            return {
+                error: new Error(String(error.message)),
+                context,
+            };
+        }
+        // Fallback: convertir a string
+        return {
+            error: new Error(String(error) || 'Unknown error'),
+            context,
+        };
+    }
+    /**
+     * Verifica si es un PromiseRejectionEvent
+     */
+    isPromiseRejection(error) {
+        return (typeof PromiseRejectionEvent !== 'undefined' &&
+            error instanceof PromiseRejectionEvent);
+    }
+    /**
+     * Obtiene la URL actual de forma segura
+     */
+    getCurrentUrl() {
+        try {
+            return window?.location?.href || 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analytics-error-handler.js","sourceRoot":"","sources":["../../../../../../src/lib/services/firebase/analytics-error-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Analytics Error Handler\n *\n * ErrorHandler personalizado que envía errores no capturados a Firebase Analytics.\n * Se activa si enableErrorTracking=true en analyticsConfig.\n */\n\nimport { ErrorHandler, Injectable, inject } from '@angular/core';\nimport { AnalyticsService } from './analytics.service';\n\n/**\n * ErrorHandler que trackea errores en Firebase Analytics.\n *\n * Captura errores no manejados de la aplicación y los envía a GA4\n * como eventos 'error_occurred'. También delega al ErrorHandler\n * default para mantener el comportamiento de console.error.\n *\n * @example\n * ```typescript\n * // Se activa automáticamente si enableErrorTracking=true\n * provideValtechFirebase({\n *   firebase: environment.firebase,\n *   enableAnalytics: true,\n *   analyticsConfig: {\n *     enableErrorTracking: true,\n *   },\n * });\n * ```\n */\n@Injectable()\nexport class AnalyticsErrorHandler implements ErrorHandler {\n  private readonly analytics = inject(AnalyticsService);\n  private readonly defaultHandler = new ErrorHandler();\n\n  /**\n   * Maneja un error no capturado.\n   * Envía el error a Analytics y luego al handler default.\n   */\n  handleError(error: unknown): void {\n    // Enviar a Analytics\n    try {\n      this.trackError(error);\n    } catch (trackingError) {\n      // No fallar si el tracking falla\n      console.warn('[AnalyticsErrorHandler] Error tracking failed:', trackingError);\n    }\n\n    // Delegar al handler default (console.error)\n    this.defaultHandler.handleError(error);\n  }\n\n  /**\n   * Trackea el error en Analytics\n   */\n  private trackError(error: unknown): void {\n    // Extraer información del error\n    const errorInfo = this.extractErrorInfo(error);\n\n    this.analytics.logError(\n      errorInfo.error,\n      {\n        source: 'uncaught',\n        url: this.getCurrentUrl(),\n        ...errorInfo.context,\n      }\n    );\n  }\n\n  /**\n   * Extrae información útil del error\n   */\n  private extractErrorInfo(error: unknown): {\n    error: Error;\n    context: Record<string, string>;\n  } {\n    const context: Record<string, string> = {};\n\n    // Error estándar\n    if (error instanceof Error) {\n      // Detectar errores de chunk loading (lazy loading)\n      if (error.message.includes('Loading chunk')) {\n        context['error_category'] = 'chunk_loading';\n      }\n\n      // Detectar errores de red\n      if (error.message.includes('NetworkError') || error.message.includes('Failed to fetch')) {\n        context['error_category'] = 'network';\n      }\n\n      return { error, context };\n    }\n\n    // ErrorEvent (ej: errores de script)\n    if (typeof ErrorEvent !== 'undefined' && error instanceof ErrorEvent) {\n      return {\n        error: new Error(error.message || 'Script error'),\n        context: {\n          filename: error.filename || 'unknown',\n          lineno: String(error.lineno || 0),\n          colno: String(error.colno || 0),\n        },\n      };\n    }\n\n    // PromiseRejection\n    if (this.isPromiseRejection(error)) {\n      const reason = (error as PromiseRejectionEvent).reason;\n      if (reason instanceof Error) {\n        return {\n          error: reason,\n          context: { error_category: 'unhandled_promise' },\n        };\n      }\n      return {\n        error: new Error(String(reason) || 'Unhandled promise rejection'),\n        context: { error_category: 'unhandled_promise' },\n      };\n    }\n\n    // Objeto con message\n    if (error && typeof error === 'object' && 'message' in error) {\n      return {\n        error: new Error(String((error as { message: unknown }).message)),\n        context,\n      };\n    }\n\n    // Fallback: convertir a string\n    return {\n      error: new Error(String(error) || 'Unknown error'),\n      context,\n    };\n  }\n\n  /**\n   * Verifica si es un PromiseRejectionEvent\n   */\n  private isPromiseRejection(error: unknown): boolean {\n    return (\n      typeof PromiseRejectionEvent !== 'undefined' &&\n      error instanceof PromiseRejectionEvent\n    );\n  }\n\n  /**\n   * Obtiene la URL actual de forma segura\n   */\n  private getCurrentUrl(): string {\n    try {\n      return window?.location?.href || 'unknown';\n    } catch {\n      return 'unknown';\n    }\n  }\n}\n"]}

package/esm2022/lib/services/firebase/analytics-router-tracker.mjs

@@ -0,0 +1,99 @@
+/**
+ * Analytics Router Tracker
+ *
+ * Servicio que trackea automáticamente page views cuando el usuario navega.
+ * Se activa automáticamente si enablePageViewTracking=true en analyticsConfig.
+ */
+import { DestroyRef, Inject, Injectable, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { NavigationEnd, Router } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import { VALTECH_FIREBASE_CONFIG } from './config';
+import { AnalyticsService } from './analytics.service';
+import * as i0 from "@angular/core";
+/**
+ * Tracker automático de page views via Router.
+ *
+ * Este servicio escucha eventos de navegación del Router y registra
+ * page views automáticamente en Firebase Analytics.
+ *
+ * Se excluyen rutas configuradas en `analyticsConfig.excludeRoutes`.
+ *
+ * @example
+ * ```typescript
+ * // Se activa automáticamente si enablePageViewTracking=true
+ * provideValtechFirebase({
+ *   firebase: environment.firebase,
+ *   enableAnalytics: true,
+ *   analyticsConfig: {
+ *     enablePageViewTracking: true,
+ *     excludeRoutes: ['/admin/*', '/debug/*'],
+ *   },
+ * });
+ * ```
+ */
+export class AnalyticsRouterTracker {
+    constructor(config) {
+        this.config = config;
+        this.analytics = inject(AnalyticsService);
+        this.router = inject(Router);
+        this.destroyRef = inject(DestroyRef);
+        const analyticsConfig = config.analyticsConfig ?? {};
+        this.enabled = analyticsConfig.enablePageViewTracking !== false;
+        this.excludePatterns = this.compileExcludePatterns(analyticsConfig.excludeRoutes ?? []);
+        if (this.enabled && config.enableAnalytics) {
+            this.startTracking();
+        }
+    }
+    /**
+     * Inicia el tracking de navegación
+     */
+    startTracking() {
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), filter((event) => !this.isExcluded(event.urlAfterRedirects)), takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            this.analytics.logPageView(event.urlAfterRedirects);
+        });
+    }
+    /**
+     * Compila patrones de exclusión a RegExp
+     */
+    compileExcludePatterns(patterns) {
+        return patterns.map((pattern) => {
+            // Convertir glob pattern a regex
+            // Ej: '/admin/*' -> /^\/admin\/.*$/
+            const regexPattern = pattern
+                .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escapar caracteres especiales
+                .replace(/\*/g, '.*'); // Convertir * a .*
+            return new RegExp(`^${regexPattern}$`);
+        });
+    }
+    /**
+     * Verifica si una URL debe ser excluida del tracking
+     */
+    isExcluded(url) {
+        // Remover query params para la comparación
+        const path = url.split('?')[0];
+        return this.excludePatterns.some((pattern) => pattern.test(path));
+    }
+    /**
+     * Registra un page view manualmente.
+     * Útil para casos donde necesitas trackear manualmente.
+     */
+    trackPageView(path, title) {
+        if (this.isExcluded(path)) {
+            return;
+        }
+        this.analytics.logPageView(path, title);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsRouterTracker, deps: [{ token: VALTECH_FIREBASE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsRouterTracker, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsRouterTracker, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_FIREBASE_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/firebase/analytics-types.mjs

@@ -0,0 +1,7 @@
+/**
+ * Analytics Types
+ *
+ * Tipos e interfaces para el servicio de Firebase Analytics (GA4).
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analytics-types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/firebase/analytics-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG","sourcesContent":["/**\n * Analytics Types\n *\n * Tipos e interfaces para el servicio de Firebase Analytics (GA4).\n */\n\n// ============================================================================\n// CONFIGURACIÓN\n// ============================================================================\n\n/**\n * Configuración de Analytics para ValtechFirebaseConfig\n */\nexport interface AnalyticsConfig {\n  /** Habilitar tracking automático de page views via Router (default: true) */\n  enablePageViewTracking?: boolean;\n\n  /** Habilitar tracking automático de errores via ErrorHandler (default: false) */\n  enableErrorTracking?: boolean;\n\n  /** Habilitar integración con auth para userId y userProperties (default: true) */\n  enableAuthIntegration?: boolean;\n\n  /** Modo debug: logea a consola además de enviar a Firebase (default: false) */\n  debugMode?: boolean;\n\n  /** Auto-grant consent para desarrollo/testing (default: false) */\n  defaultConsentGranted?: boolean;\n\n  /** Rutas a excluir del page view tracking (regex patterns) */\n  excludeRoutes?: string[];\n\n  /** Consent mode inicial (GDPR) */\n  defaultConsent?: ConsentSettings;\n\n  /** Clave de localStorage para persistir consent (default: 'analytics_consent') */\n  consentStorageKey?: string;\n\n  /** Propiedades de usuario por defecto */\n  defaultUserProperties?: Record<string, string>;\n\n  /** Prefijo para eventos custom (ej: 'myapp_') */\n  eventPrefix?: string;\n\n  /** Sampling rate (0.0 - 1.0) para reducir volumen (default: 1.0) */\n  samplingRate?: number;\n}\n\n// ============================================================================\n// CONSENT (GDPR)\n// ============================================================================\n\n/**\n * Settings de consentimiento GDPR\n */\nexport interface ConsentSettings {\n  /** Permite recolección de analytics */\n  analytics?: boolean;\n  /** Permite personalización de ads */\n  advertising?: boolean;\n  /** Permite funcionalidad */\n  functionality?: boolean;\n  /** Permite seguridad */\n  security?: boolean;\n}\n\n/**\n * Estado completo de consentimiento\n */\nexport interface ConsentState {\n  /** Settings actuales */\n  settings: ConsentSettings;\n  /** Timestamp de la última actualización */\n  updatedAt: Date | null;\n  /** Si el usuario ha tomado una decisión explícita */\n  hasDecided: boolean;\n}\n\n// ============================================================================\n// EVENTOS\n// ============================================================================\n\n/**\n * Nombres de eventos GA4 recomendados + customs\n */\nexport type AnalyticsEventName =\n  // GA4 Recommended Events - Ecommerce\n  | 'add_payment_info'\n  | 'add_shipping_info'\n  | 'add_to_cart'\n  | 'add_to_wishlist'\n  | 'begin_checkout'\n  | 'purchase'\n  | 'refund'\n  | 'remove_from_cart'\n  | 'view_cart'\n  | 'view_item'\n  | 'view_item_list'\n  // GA4 Recommended Events - Engagement\n  | 'generate_lead'\n  | 'login'\n  | 'page_view'\n  | 'screen_view'\n  | 'search'\n  | 'select_content'\n  | 'select_item'\n  | 'select_promotion'\n  | 'share'\n  | 'sign_up'\n  | 'view_promotion'\n  // Custom Events (app-specific)\n  | 'feature_used'\n  | 'preference_changed'\n  | 'onboarding_step'\n  | 'error_occurred'\n  | 'performance_metric'\n  // Allow custom events\n  | string;\n\n/**\n * Parámetros tipados por evento\n */\nexport interface AnalyticsEventParams {\n  // Ecommerce\n  add_to_cart: {\n    item_id: string;\n    item_name?: string;\n    value?: number;\n    currency?: string;\n    quantity?: number;\n  };\n  purchase: {\n    transaction_id: string;\n    value: number;\n    currency?: string;\n    items?: AnalyticsItem[];\n    tax?: number;\n    shipping?: number;\n  };\n  begin_checkout: {\n    value?: number;\n    currency?: string;\n    items?: AnalyticsItem[];\n  };\n  view_item: {\n    item_id: string;\n    item_name?: string;\n    value?: number;\n    currency?: string;\n  };\n  remove_from_cart: {\n    item_id: string;\n    item_name?: string;\n    value?: number;\n  };\n\n  // Engagement\n  login: { method?: string };\n  sign_up: { method?: string };\n  search: { search_term: string };\n  share: { content_type?: string; item_id?: string; method?: string };\n  select_content: { content_type: string; item_id?: string };\n  page_view: { page_path?: string; page_title?: string; page_location?: string };\n  screen_view: { screen_name: string; screen_class?: string };\n\n  // Custom\n  feature_used: { feature_name: string; feature_category?: string };\n  preference_changed: { preference_name: string; old_value?: string; new_value?: string };\n  onboarding_step: { step_number: number; step_name?: string };\n  error_occurred: {\n    error_type: string;\n    error_message?: string;\n    error_stack?: string;\n    context?: string;\n  };\n  performance_metric: { metric_name: string; value: number; unit?: string };\n\n  // Allow custom params\n  [key: string]: Record<string, unknown> | undefined;\n}\n\n/**\n * Item para eventos de ecommerce\n */\nexport interface AnalyticsItem {\n  /** ID único del item */\n  item_id: string;\n  /** Nombre del item */\n  item_name: string;\n  /** Categoría principal */\n  item_category?: string;\n  /** Subcategorías */\n  item_category2?: string;\n  item_category3?: string;\n  /** Marca */\n  item_brand?: string;\n  /** Variante (ej: color, talla) */\n  item_variant?: string;\n  /** Precio unitario */\n  price?: number;\n  /** Cantidad */\n  quantity?: number;\n  /** Moneda ISO 4217 */\n  currency?: string;\n  /** Posición en lista */\n  index?: number;\n  /** Cupón aplicado */\n  coupon?: string;\n}\n\n// ============================================================================\n// DEBUG\n// ============================================================================\n\n/**\n * Tipo de evento de debug\n */\nexport type DebugEventType =\n  | 'event'\n  | 'page_view'\n  | 'screen_view'\n  | 'user_property'\n  | 'error'\n  | 'consent'\n  | 'timing';\n\n/**\n * Evento de debug (solo en debug mode)\n */\nexport interface AnalyticsDebugEvent {\n  /** Timestamp del evento */\n  timestamp: Date;\n  /** Tipo de evento */\n  type: DebugEventType;\n  /** Nombre del evento */\n  name: string;\n  /** Parámetros del evento */\n  params?: Record<string, unknown>;\n  /** Si fue enviado a Firebase (false en debug mode) */\n  sent: boolean;\n}\n\n// ============================================================================\n// TIMING / PERFORMANCE\n// ============================================================================\n\n/**\n * Métrica de timing/performance\n */\nexport interface TimingMetric {\n  /** Nombre de la métrica */\n  name: string;\n  /** Valor en milisegundos */\n  valueMs: number;\n  /** Categoría (ej: 'api', 'render', 'load') */\n  category?: string;\n  /** Parámetros adicionales */\n  params?: Record<string, string>;\n}\n\n// ============================================================================\n// USER\n// ============================================================================\n\n/**\n * Propiedades de usuario para segmentación\n */\nexport interface UserProperties {\n  /** Idioma preferido */\n  preferred_language?: string;\n  /** Nivel de suscripción */\n  subscription_tier?: string;\n  /** Organización activa (multi-tenant) */\n  active_organization?: string;\n  /** Propiedades custom */\n  [key: string]: string | number | boolean | undefined;\n}\n"]}