valtech-components 2.0.498 → 2.0.500

package/lib/services/auth/auth.service.d.ts

@@ -6,7 +6,8 @@ import { AuthStateService } from './auth-state.service';
 import { TokenService } from './token.service';
 import { AuthStorageService } from './storage.service';
 import { AuthSyncService } from './sync.service';
-import { SigninRequest, SigninResponse, SignupRequest, SignupResponse, VerifyEmailRequest, VerifyEmailResponse, ResendCodeRequest, ResendCodeResponse, MFAVerifyResponse, RefreshResponse, GetPermissionsResponse, GetProfileResponse, UpdateProfileRequest, UpdateProfileResponse, MFASetupResponse, MFAConfirmResponse, MFADisableResponse, ForgotPasswordRequest, ForgotPasswordResponse, ResetPasswordRequest, ResetPasswordResponse, SwitchOrgResponse, MFAMethod, AuthError, ValtechAuthConfig, EnableNotificationsResult, NotificationPermissionState, RegisterDeviceResult, TOTPSetupResponse, TOTPVerifySetupResponse, TOTPDisableResponse, RegenerateBackupCodesResponse, BackupCodesCountResponse } from './types';
+import { SigninRequest, SigninResponse, SignupRequest, SignupResponse, VerifyEmailRequest, VerifyEmailResponse, ResendCodeRequest, ResendCodeResponse, MFAVerifyResponse, RefreshResponse, GetPermissionsResponse, GetProfileResponse, UpdateProfileRequest, UpdateProfileResponse, MFASetupResponse, MFAConfirmResponse, MFADisableResponse, ForgotPasswordRequest, ForgotPasswordResponse, ResetPasswordRequest, ResetPasswordResponse, SwitchOrgResponse, MFAMethod, AuthError, ValtechAuthConfig, EnableNotificationsResult, NotificationPermissionState, RegisterDeviceResult, TOTPSetupResponse, TOTPVerifySetupResponse, TOTPDisableResponse, RegenerateBackupCodesResponse, BackupCodesCountResponse, OAuthProvider, LinkedProvider, HasPasswordResponse } from './types';
+import { OAuthService } from './oauth.service';
 import { FirebaseService, MessagingService } from '../firebase';
 import { I18nService } from '../i18n';
 import * as i0 from "@angular/core";
@@ -41,11 +42,12 @@ export declare class AuthService implements OnDestroy {
     private storageService;
     private syncService;
     private firebaseService;
+    private oauthService;
     private messagingService;
     private i18nService;
     private refreshTimerId;
     private syncSubscription;
-    constructor(config: ValtechAuthConfig, http: HttpClient, router: Router, stateService: AuthStateService, tokenService: TokenService, storageService: AuthStorageService, syncService: AuthSyncService, firebaseService: FirebaseService, messagingService: MessagingService | null, i18nService: I18nService | null);
+    constructor(config: ValtechAuthConfig, http: HttpClient, router: Router, stateService: AuthStateService, tokenService: TokenService, storageService: AuthStorageService, syncService: AuthSyncService, firebaseService: FirebaseService, oauthService: OAuthService, messagingService: MessagingService | null, i18nService: I18nService | null);
     /** Estado completo de autenticación */
     readonly state: import("@angular/core").Signal<import("./types").AuthState>;
     /** Usuario está autenticado */
@@ -77,6 +79,57 @@ export declare class AuthService implements OnDestroy {
      * Detecta automáticamente la plataforma para identificar dispositivos nuevos.
      */
     signin(request: SigninRequest): Observable<SigninResponse>;
+    /**
+     * Inicia sesión con OAuth (Google, Apple, Microsoft).
+     * Abre un popup para el flujo de autenticación.
+     *
+     * @param provider - Proveedor OAuth ('google', 'apple', 'microsoft')
+     * @returns Observable que emite SigninResponse cuando se completa
+     *
+     * @example
+     * ```typescript
+     * this.auth.signinWithOAuth('google').subscribe({
+     *   next: () => this.router.navigate(['/']),
+     *   error: (err) => console.error('OAuth failed:', err)
+     * });
+     * ```
+     */
+    signinWithOAuth(provider: OAuthProvider): Observable<SigninResponse>;
+    /**
+     * Vincula un proveedor OAuth adicional a la cuenta actual.
+     * Requiere que el usuario esté autenticado.
+     *
+     * @param provider - Proveedor OAuth a vincular
+     */
+    linkOAuthProvider(provider: OAuthProvider): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Obtiene los proveedores OAuth vinculados al usuario.
+     */
+    getLinkedProviders(): Observable<LinkedProvider[]>;
+    /**
+     * Desvincula un proveedor OAuth de la cuenta.
+     *
+     * @param provider - Proveedor a desvincular
+     */
+    unlinkOAuthProvider(provider: OAuthProvider): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Establece contraseña para usuarios que solo tienen OAuth.
+     * Permite que usuarios OAuth-only puedan también usar email/password.
+     *
+     * @param password - Nueva contraseña
+     */
+    setPasswordForOAuthUser(password: string): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Verifica si el usuario tiene contraseña establecida.
+     * Útil para mostrar/ocultar opciones de cambio de contraseña.
+     */
+    checkHasPassword(): Observable<HasPasswordResponse>;
     /**
      * Registra un nuevo usuario.
      * El usuario queda en estado PENDING hasta verificar su email.
@@ -277,6 +330,6 @@ export declare class AuthService implements OnDestroy {
      * Detecta información de la plataforma del dispositivo.
      */
     private detectPlatformInfo;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, [null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, [null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
 }

package/lib/services/auth/index.d.ts

@@ -79,3 +79,5 @@ export { AuthStorageService } from './storage.service';
 export { AuthSyncService } from './sync.service';
 export { DeviceService } from './device.service';
 export { SessionService } from './session.service';
+export { OAuthService } from './oauth.service';
+export { OAuthCallbackComponent } from './oauth-callback.component';

package/lib/services/auth/oauth-callback.component.d.ts

@@ -0,0 +1,34 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Componente de callback para OAuth.
+ *
+ * Este componente procesa la respuesta del servidor OAuth y envía
+ * los tokens a la ventana padre via postMessage.
+ *
+ * Debe agregarse a las rutas de la aplicación:
+ * ```typescript
+ * // app.routes.ts
+ * import { OAuthCallbackComponent } from 'valtech-components';
+ *
+ * export const routes: Routes = [
+ *   { path: 'auth/oauth/callback', component: OAuthCallbackComponent },
+ *   // ... otras rutas
+ * ];
+ * ```
+ *
+ * El backend redirige a esta ruta con los tokens en query params:
+ * `/auth/oauth/callback?access_token=xxx&refresh_token=xxx&expires_in=900`
+ *
+ * O con error:
+ * `/auth/oauth/callback?error=INVALID_CODE&error_description=...`
+ */
+export declare class OAuthCallbackComponent implements OnInit {
+    message: string;
+    ngOnInit(): void;
+    private processCallback;
+    private sendToParent;
+    private closeAfterDelay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthCallbackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OAuthCallbackComponent, "val-oauth-callback", never, {}, {}, never, never, true, never>;
+}

package/lib/services/auth/oauth.service.d.ts

@@ -0,0 +1,90 @@
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ValtechAuthConfig, OAuthProvider, OAuthResult, LinkedProvider, HasPasswordResponse } from './types';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+/**
+ * Servicio de OAuth para login social.
+ *
+ * Implementa flujo OAuth server-side con popup:
+ * 1. Frontend abre popup hacia backend
+ * 2. Backend redirige a provider (Google, Apple, Microsoft)
+ * 3. Usuario autoriza
+ * 4. Backend intercambia code, genera JWT, redirige con tokens
+ * 5. Popup envía tokens a ventana padre via postMessage
+ *
+ * @example
+ * ```typescript
+ * import { OAuthService, AuthService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class LoginComponent {
+ *   private oauth = inject(OAuthService);
+ *   private auth = inject(AuthService);
+ *
+ *   async loginWithGoogle() {
+ *     this.oauth.startFlow('google').subscribe({
+ *       next: (result) => {
+ *         // Tokens recibidos, guardar en auth state
+ *         this.auth.handleOAuthSuccess(result);
+ *         this.router.navigate(['/']);
+ *       },
+ *       error: (error) => {
+ *         console.error('OAuth failed:', error);
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare class OAuthService {
+    private config;
+    private http;
+    private ngZone;
+    private popup;
+    private messageHandler;
+    private checkClosedInterval;
+    constructor(config: ValtechAuthConfig, http: HttpClient, ngZone: NgZone);
+    /**
+     * Inicia flujo OAuth en popup.
+     * Retorna Observable que emite cuando el usuario completa el flujo.
+     *
+     * @param provider - Proveedor OAuth ('google', 'apple', 'microsoft')
+     * @returns Observable que emite OAuthResult o error
+     */
+    startFlow(provider: OAuthProvider): Observable<OAuthResult>;
+    /**
+     * Inicia flujo de linking para vincular un proveedor adicional.
+     * Requiere que el usuario esté autenticado.
+     *
+     * @param provider - Proveedor OAuth a vincular
+     * @returns Observable que emite cuando se completa el linking
+     */
+    startLinkFlow(provider: OAuthProvider): Observable<OAuthResult>;
+    /**
+     * Obtiene los proveedores OAuth vinculados al usuario.
+     */
+    getLinkedProviders(): Observable<LinkedProvider[]>;
+    /**
+     * Desvincula un proveedor OAuth.
+     */
+    unlinkProvider(provider: OAuthProvider): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Establece contraseña para usuarios que solo tienen OAuth.
+     */
+    setPassword(password: string): Observable<{
+        success: boolean;
+    }>;
+    /**
+     * Verifica si el usuario tiene contraseña establecida.
+     */
+    hasPassword(): Observable<HasPasswordResponse>;
+    /**
+     * Limpia recursos del popup.
+     */
+    private cleanup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OAuthService>;
+}

package/lib/services/auth/types.d.ts

@@ -664,3 +664,72 @@ export interface ValidateActionResponse {
     /** Mensaje de error (si valid=false) */
     message?: string;
 }
+/**
+ * Proveedores OAuth soportados.
+ */
+export type OAuthProvider = 'google' | 'apple' | 'microsoft';
+/**
+ * Resultado exitoso de flujo OAuth.
+ */
+export interface OAuthResult {
+    /** Token de acceso JWT */
+    accessToken: string;
+    /** Token de refresco */
+    refreshToken: string;
+    /** Token de Firebase (si está habilitado) */
+    firebaseToken?: string;
+    /** Tiempo de expiración en segundos */
+    expiresIn: number;
+    /** Roles del usuario */
+    roles?: string[];
+    /** Permisos del usuario */
+    permissions?: string[];
+    /** Indica si es un usuario nuevo (recién creado) */
+    isNewUser?: boolean;
+    /** Indica si la cuenta fue vinculada a usuario existente */
+    linked?: boolean;
+}
+/**
+ * Error de OAuth.
+ */
+export interface OAuthError {
+    /** Código de error */
+    code: string;
+    /** Mensaje descriptivo */
+    message: string;
+}
+/**
+ * Datos enviados desde popup callback via postMessage.
+ */
+export interface OAuthCallbackData {
+    /** Tipo de mensaje */
+    type: 'oauth-callback';
+    /** Tokens (si éxito) */
+    tokens?: OAuthResult;
+    /** Error (si falló) */
+    error?: OAuthError;
+}
+/**
+ * Proveedor OAuth vinculado al usuario.
+ */
+export interface LinkedProvider {
+    /** Nombre del proveedor */
+    provider: OAuthProvider;
+    /** Email asociado al proveedor */
+    email: string;
+    /** Nombre del usuario en el proveedor */
+    name?: string;
+    /** URL de imagen de perfil */
+    picture?: string;
+    /** Fecha de vinculación */
+    linkedAt: string;
+    /** Última vez que se usó para login */
+    lastUsedAt?: string;
+}
+/**
+ * Response de verificar si tiene contraseña.
+ */
+export interface HasPasswordResponse {
+    operationId: string;
+    hasPassword: boolean;
+}

package/lib/services/firebase/analytics-error-handler.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Analytics Error Handler
+ *
+ * ErrorHandler personalizado que envía errores no capturados a Firebase Analytics.
+ * Se activa si enableErrorTracking=true en analyticsConfig.
+ */
+import { ErrorHandler } from '@angular/core';
+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 declare class AnalyticsErrorHandler implements ErrorHandler {
+    private readonly analytics;
+    private readonly defaultHandler;
+    /**
+     * Maneja un error no capturado.
+     * Envía el error a Analytics y luego al handler default.
+     */
+    handleError(error: unknown): void;
+    /**
+     * Trackea el error en Analytics
+     */
+    private trackError;
+    /**
+     * Extrae información útil del error
+     */
+    private extractErrorInfo;
+    /**
+     * Verifica si es un PromiseRejectionEvent
+     */
+    private isPromiseRejection;
+    /**
+     * Obtiene la URL actual de forma segura
+     */
+    private getCurrentUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsErrorHandler>;
+}

package/lib/services/firebase/analytics-router-tracker.d.ts

@@ -0,0 +1,51 @@
+import { ValtechFirebaseConfig } from './types';
+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 declare class AnalyticsRouterTracker {
+    private config;
+    private readonly analytics;
+    private readonly router;
+    private readonly destroyRef;
+    private readonly excludePatterns;
+    private readonly enabled;
+    constructor(config: ValtechFirebaseConfig);
+    /**
+     * Inicia el tracking de navegación
+     */
+    private startTracking;
+    /**
+     * Compila patrones de exclusión a RegExp
+     */
+    private compileExcludePatterns;
+    /**
+     * Verifica si una URL debe ser excluida del tracking
+     */
+    private isExcluded;
+    /**
+     * Registra un page view manualmente.
+     * Útil para casos donde necesitas trackear manualmente.
+     */
+    trackPageView(path: string, title?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsRouterTracker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsRouterTracker>;
+}

package/lib/services/firebase/analytics.service.d.ts

@@ -0,0 +1,256 @@
+/**
+ * Analytics Service (Firebase GA4)
+ *
+ * Servicio para tracking de eventos, page views y errores con Firebase Analytics.
+ * Integra con el sistema de auth para user properties y respeta consent mode GDPR.
+ */
+import { Injector } from '@angular/core';
+import { ValtechFirebaseConfig } from './types';
+import { AnalyticsDebugEvent, AnalyticsEventName, AnalyticsEventParams, AnalyticsItem, ConsentSettings, ConsentState, UserProperties } from './analytics-types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio de Firebase Analytics (GA4).
+ *
+ * Proporciona tracking de eventos, page views, errores y métricas de performance.
+ * Soporta GDPR Consent Mode y modo debug para desarrollo.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class ProductComponent {
+ *   private analytics = inject(AnalyticsService);
+ *
+ *   onPurchase(product: Product) {
+ *     this.analytics.logEvent('purchase', {
+ *       transaction_id: order.id,
+ *       value: order.total,
+ *       currency: 'EUR'
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare class AnalyticsService {
+    private injector;
+    private config;
+    private platformId;
+    private readonly _consentState;
+    private readonly _isDebugMode;
+    private readonly _debugHistory;
+    /** Estado de consentimiento actual (readonly) */
+    readonly consentState: import("@angular/core").Signal<ConsentState>;
+    /** Indica si está en modo debug */
+    readonly isDebugMode: import("@angular/core").Signal<boolean>;
+    /** Indica si analytics está habilitado y funcionando */
+    readonly isEnabled: import("@angular/core").Signal<boolean>;
+    private readonly analyticsConfig;
+    private readonly consentStorageKey;
+    private readonly eventPrefix;
+    private readonly samplingRate;
+    constructor(injector: Injector, config: ValtechFirebaseConfig, platformId: Object);
+    /**
+     * Inicializa el servicio de analytics
+     */
+    private initializeAnalytics;
+    /**
+     * Obtiene la instancia de Analytics de forma perezosa.
+     * Esto evita el error de APP_INITIALIZER de AngularFire.
+     */
+    private getAnalyticsInstance;
+    /**
+     * Verifica si Analytics está soportado
+     */
+    private isAnalyticsSupported;
+    /**
+     * Verifica si debe enviar el evento (sampling)
+     */
+    private shouldSample;
+    /**
+     * Registra un page view.
+     * Normalmente se usa automáticamente via AnalyticsRouterTracker.
+     *
+     * @param pagePath - Ruta de la página (ej: '/products/123')
+     * @param pageTitle - Título de la página (opcional)
+     */
+    logPageView(pagePath: string, pageTitle?: string): void;
+    /**
+     * Registra un screen view (para apps tipo SPA).
+     *
+     * @param screenName - Nombre del screen
+     * @param screenClass - Clase del screen (opcional)
+     */
+    logScreenView(screenName: string, screenClass?: string): void;
+    /**
+     * Registra un evento tipado GA4.
+     *
+     * @param eventName - Nombre del evento (tipado)
+     * @param params - Parámetros del evento (tipados según el nombre)
+     *
+     * @example
+     * ```typescript
+     * // Evento tipado con autocompletado
+     * analytics.logEvent('add_to_cart', {
+     *   item_id: '123',
+     *   item_name: 'Producto',
+     *   value: 99.99,
+     *   currency: 'EUR'
+     * });
+     * ```
+     */
+    logEvent<T extends AnalyticsEventName>(eventName: T, params?: AnalyticsEventParams[T]): void;
+    /**
+     * Registra un evento custom con parámetros libres.
+     * Usar cuando el evento no está en el catálogo tipado.
+     *
+     * @param eventName - Nombre del evento custom
+     * @param params - Parámetros libres
+     */
+    logCustomEvent(eventName: string, params?: Record<string, unknown>): void;
+    /**
+     * Lógica común para enviar eventos
+     */
+    private trackEvent;
+    /**
+     * Registra vista de item
+     */
+    logViewItem(item: AnalyticsItem): void;
+    /**
+     * Registra agregar al carrito
+     */
+    logAddToCart(item: AnalyticsItem, quantity?: number): void;
+    /**
+     * Registra inicio de checkout
+     */
+    logBeginCheckout(items: AnalyticsItem[], value: number, currency?: string): void;
+    /**
+     * Registra compra completada
+     */
+    logPurchase(transactionId: string, items: AnalyticsItem[], value: number, currency?: string): void;
+    /**
+     * Setea el userId para asociar eventos con el usuario.
+     * Llamado automáticamente si enableAuthIntegration=true.
+     *
+     * @param userId - ID del usuario o null para limpiar
+     */
+    setUserId(userId: string | null): void;
+    /**
+     * Setea propiedades del usuario para segmentación.
+     *
+     * @param properties - Propiedades key-value
+     *
+     * @example
+     * ```typescript
+     * analytics.setUserProperties({
+     *   subscription_tier: 'premium',
+     *   preferred_language: 'es'
+     * });
+     * ```
+     */
+    setUserProperties(properties: UserProperties | Record<string, string | number | boolean>): void;
+    /**
+     * Setea la organización activa (multi-tenant).
+     * Llamado automáticamente si enableAuthIntegration=true.
+     *
+     * @param orgId - ID de la organización o null
+     */
+    setActiveOrganization(orgId: string | null): void;
+    /**
+     * Registra un error para tracking.
+     * Integra automáticamente con Angular ErrorHandler si enableErrorTracking=true.
+     *
+     * @param error - Error o mensaje de error
+     * @param context - Contexto adicional
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await riskyOperation();
+     * } catch (error) {
+     *   analytics.logError(error, { context: 'checkout_flow' });
+     * }
+     * ```
+     */
+    logError(error: Error | string, context?: Record<string, string>): void;
+    /**
+     * Registra un error fatal (crash-level).
+     */
+    logFatalError(error: Error, context?: Record<string, string>): void;
+    /**
+     * Actualiza el estado de consentimiento del usuario.
+     * Afecta qué datos se recolectan y envían.
+     *
+     * @param consent - Settings de consentimiento
+     *
+     * @example
+     * ```typescript
+     * // Usuario acepta todo
+     * analytics.updateConsent({ analytics: true, advertising: true });
+     *
+     * // Usuario rechaza publicidad
+     * analytics.updateConsent({ analytics: true, advertising: false });
+     * ```
+     */
+    updateConsent(consent: ConsentSettings): void;
+    /**
+     * Deniega todo consentimiento.
+     */
+    denyAllConsent(): void;
+    /**
+     * Acepta todo consentimiento.
+     */
+    grantAllConsent(): void;
+    /**
+     * Obtiene el estado actual de consentimiento.
+     */
+    getConsentState(): ConsentState;
+    /**
+     * Aplica consent settings a gtag (GA4 Consent Mode v2)
+     */
+    private applyConsentToGtag;
+    /**
+     * Carga consent desde localStorage
+     */
+    private loadConsentFromStorage;
+    /**
+     * Guarda consent en localStorage
+     */
+    private saveConsentToStorage;
+    /**
+     * Registra una métrica de timing/performance.
+     *
+     * @param name - Nombre de la métrica
+     * @param valueMs - Valor en milisegundos
+     * @param params - Parámetros adicionales
+     *
+     * @example
+     * ```typescript
+     * const start = performance.now();
+     * await loadData();
+     * analytics.logTiming('data_load', performance.now() - start, {
+     *   category: 'api',
+     *   endpoint: '/products'
+     * });
+     * ```
+     */
+    logTiming(name: string, valueMs: number, params?: Record<string, string>): void;
+    /**
+     * Habilita/deshabilita modo debug.
+     * En debug: logea a consola, no envía a Firebase.
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Obtiene historial de eventos (solo en debug mode).
+     * Útil para testing y desarrollo.
+     */
+    getDebugHistory(): AnalyticsDebugEvent[];
+    /**
+     * Limpia historial de debug.
+     */
+    clearDebugHistory(): void;
+    /**
+     * Agrega evento al historial de debug
+     */
+    private addToDebugHistory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsService>;
+}

package/lib/services/firebase/index.d.ts

@@ -38,3 +38,7 @@ export { buildPath, extractPathParams, getCollectionPath, getDocumentId, isColle
 export { StorageService } from './storage.service';
 export { MessagingService } from './messaging.service';
 export { NotificationDocument, NotificationsService } from './notifications.service';
+export { AnalyticsService } from './analytics.service';
+export { AnalyticsRouterTracker } from './analytics-router-tracker';
+export { AnalyticsErrorHandler } from './analytics-error-handler';
+export * from './analytics-types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valtech-components",
-  "version": "2.0.498",
+  "version": "2.0.500",
   "private": false,
   "bin": {
     "valtech-firebase-config": "./src/lib/services/firebase/scripts/generate-sw-config.js"