valtech-components 2.0.821 → 2.0.823

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

@@ -0,0 +1,106 @@
+/**
+ * Ads Types
+ *
+ * Tipos e interfaces para el servicio de Google AdSense.
+ * Simplificado para usar AdSense en lugar de GPT (Ad Manager).
+ */
+/**
+ * Configuracion del servicio de Ads.
+ * Pasada a provideValtechAds() en el bootstrap de la aplicacion.
+ */
+export interface ValtechAdsConfig {
+    /** Publisher ID de AdSense (formato: ca-pub-XXXXXXXXXXXXXXXX) */
+    adClient: string;
+    /** Habilitar modo debug (muestra info de ads en consola) */
+    debugMode?: boolean;
+    /** Test mode - usa ads de prueba durante desarrollo */
+    testMode?: boolean;
+    /** Habilitar Auto Ads (Google decide ubicacion automaticamente) */
+    autoAds?: boolean;
+    /** Callback cuando se carga un ad */
+    onAdLoaded?: (slotId: string, isEmpty: boolean) => void;
+    /** Callback cuando falla un ad */
+    onAdError?: (slotId: string, error: Error) => void;
+    /** Rutas donde NO mostrar ads (regex patterns) */
+    excludeRoutes?: string[];
+}
+/**
+ * Formato de ad para AdSense.
+ */
+export type AdFormat = 'auto' | 'fluid' | 'rectangle' | 'horizontal' | 'vertical';
+/**
+ * Configuracion de un ad slot individual.
+ */
+export interface AdSlotConfig {
+    /** ID unico del slot (usado para el div container) */
+    slotId: string;
+    /** Ad Slot ID de AdSense (numero de unidad de anuncio) */
+    adSlot?: string;
+    /** Formato del ad */
+    format?: AdFormat;
+    /** Responsive - ocupa todo el ancho disponible */
+    fullWidth?: boolean;
+    /** CSS class adicional */
+    cssClass?: string;
+    /** Altura minima mientras carga */
+    minHeight?: string;
+    /** Mostrar skeleton mientras carga */
+    showSkeleton?: boolean;
+}
+/**
+ * Estado de un ad slot.
+ */
+export type AdSlotState = 'idle' | 'loading' | 'rendered' | 'empty' | 'hidden' | 'error';
+/**
+ * Evento emitido por el servicio de ads.
+ */
+export interface AdEvent {
+    type: 'loaded' | 'empty' | 'error' | 'viewable' | 'clicked';
+    slotId: string;
+    timestamp: Date;
+    isEmpty?: boolean;
+    error?: Error;
+}
+/**
+ * Estado de consent para ads (mapeado desde AnalyticsService).
+ */
+export interface AdsConsentState {
+    /** Permite almacenamiento de ads */
+    adStorage: boolean;
+    /** Permite personalizacion de ads */
+    adPersonalization: boolean;
+    /** Permite datos de usuario para ads */
+    adUserData: boolean;
+}
+/** AdSense global array */
+export type AdSenseCommand = Record<string, unknown>;
+declare global {
+    interface Window {
+        adsbygoogle?: AdSenseCommand[];
+        googletag?: GoogleTag;
+    }
+}
+/** Google Publisher Tags (GPT) interface */
+export interface GoogleTag {
+    cmd: Array<() => void>;
+    pubads(): GoogleTagPubAds;
+}
+/** GPT PubAds service */
+export interface GoogleTagPubAds {
+    setRequestNonPersonalizedAds(value: 0 | 1): void;
+}
+/**
+ * @deprecated Use AdFormat instead
+ */
+export type AdSlotSize = 'leaderboard' | 'billboard' | 'medium-rectangle' | 'large-rectangle' | 'half-page' | 'skyscraper' | 'mobile-banner' | 'mobile-leaderboard' | 'fluid' | 'native' | 'custom';
+/**
+ * @deprecated AdSense handles sizes automatically
+ */
+export declare const AD_SIZE_MAP: Record<AdSlotSize, [number, number] | 'fluid'>;
+/**
+ * @deprecated Not used with AdSense
+ */
+export interface SizeMapping {
+    viewportWidth: number;
+    sizes: ([number, number] | 'fluid')[];
+}

package/lib/services/app-config/app-config.service.d.ts

@@ -0,0 +1,115 @@
+import { AppConfig } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio de configuración remota de la aplicación.
+ *
+ * Lee la configuración desde Firestore (apps/{appId}/config/app) y provee:
+ * - Feature flags reactivos
+ * - Variables dinámicas de configuración
+ * - Detección de nuevas versiones
+ * - Modo mantenimiento
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class MyComponent {
+ *   private appConfig = inject(AppConfigService);
+ *
+ *   // Verificar feature flag
+ *   showNewFeature = computed(() =>
+ *     this.appConfig.isFeatureEnabled('newDashboard')
+ *   );
+ *
+ *   // Obtener variable
+ *   maxSize = this.appConfig.getVariable('maxUploadSize', 5242880);
+ * }
+ * ```
+ */
+export declare class AppConfigService {
+    private firestore;
+    private serviceConfig;
+    private subscription;
+    /**
+     * Configuración actual de la aplicación.
+     * null si no se ha cargado o no está configurado.
+     */
+    readonly appConfig: import("@angular/core").WritableSignal<AppConfig>;
+    /**
+     * Indica si la configuración está cargando.
+     */
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Error de carga, si existe.
+     */
+    readonly error: import("@angular/core").WritableSignal<string>;
+    /**
+     * Indica si hay una nueva versión disponible.
+     */
+    readonly hasUpdate: import("@angular/core").Signal<boolean>;
+    /**
+     * Indica si la aplicación está en modo mantenimiento.
+     */
+    readonly isMaintenanceMode: import("@angular/core").Signal<boolean>;
+    /**
+     * Versión remota de la aplicación.
+     */
+    readonly remoteVersion: import("@angular/core").Signal<string>;
+    /**
+     * Versión actual de la aplicación (local).
+     */
+    readonly currentVersion: import("@angular/core").Signal<string>;
+    /**
+     * Inicializa el servicio y comienza a escuchar cambios en la configuración.
+     * Se llama automáticamente via APP_INITIALIZER si se usa provideValtechAppConfig().
+     */
+    initialize(): Promise<void>;
+    /**
+     * Verifica si un feature flag está habilitado.
+     *
+     * @param feature - Nombre del feature flag
+     * @param defaultValue - Valor por defecto si no existe (default: false)
+     * @returns true si el feature está habilitado
+     *
+     * @example
+     * ```typescript
+     * if (appConfig.isFeatureEnabled('darkMode')) {
+     *   // Mostrar toggle de dark mode
+     * }
+     * ```
+     */
+    isFeatureEnabled(feature: string, defaultValue?: boolean): boolean;
+    /**
+     * Obtiene una variable de configuración.
+     *
+     * @param key - Clave de la variable
+     * @param defaultValue - Valor por defecto si no existe
+     * @returns Valor de la variable o el valor por defecto
+     *
+     * @example
+     * ```typescript
+     * const maxSize = appConfig.getVariable('maxUploadSize', 5242880);
+     * const supportEmail = appConfig.getVariable('supportEmail', 'support@example.com');
+     * ```
+     */
+    getVariable<T>(key: string, defaultValue: T): T;
+    /**
+     * Recarga la configuración manualmente (one-time read).
+     * Útil si necesitas forzar una actualización.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Desuscribe del listener de Firestore.
+     * Se llama automáticamente cuando el servicio se destruye.
+     */
+    destroy(): void;
+    /**
+     * Compara dos versiones semver y retorna true si remote > current.
+     *
+     * @param remote - Versión remota (ej: "1.2.3")
+     * @param current - Versión actual (ej: "1.2.0")
+     * @returns true si remote es mayor que current
+     */
+    private isNewerVersion;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppConfigService>;
+}

package/lib/services/app-config/config.d.ts

@@ -0,0 +1,31 @@
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { AppConfigServiceConfig } from './types';
+/**
+ * Token de inyección para la configuración de AppConfig.
+ */
+export declare const VALTECH_APP_CONFIG: InjectionToken<AppConfigServiceConfig>;
+/**
+ * Provee el servicio de configuración remota a la aplicación Angular.
+ *
+ * @param config - Configuración del servicio
+ * @returns EnvironmentProviders para usar en bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechAppConfig } from 'valtech-components';
+ * import { version } from '../package.json';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechFirebase(environment.valtechFirebase),
+ *     provideValtechAppConfig({
+ *       currentVersion: version,
+ *       showUpdateBanner: true,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function provideValtechAppConfig(config: AppConfigServiceConfig): EnvironmentProviders;

package/lib/services/app-config/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * AppConfig Service Module
+ *
+ * Servicio de configuración remota para aplicaciones Angular.
+ * Lee configuración desde Firestore y provee feature flags, variables dinámicas,
+ * y detección de actualizaciones.
+ *
+ * Soporta detección de versión cross-platform (web y mobile con Capacitor).
+ *
+ * @example
+ * ```typescript
+ * // main.ts - Con soporte cross-platform
+ * import { provideValtechAppConfig, getAppVersion } from 'valtech-components';
+ * import { version } from '../package.json';
+ *
+ * async function bootstrap() {
+ *   const appVersion = await getAppVersion(version);
+ *
+ *   bootstrapApplication(AppComponent, {
+ *     providers: [
+ *       provideValtechFirebase(environment.valtechFirebase),
+ *       provideValtechAppConfig({
+ *         currentVersion: appVersion,
+ *         showUpdateBanner: true,
+ *       }),
+ *     ],
+ *   });
+ * }
+ * bootstrap();
+ *
+ * // component.ts
+ * import { AppConfigService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private appConfig = inject(AppConfigService);
+ *
+ *   showFeature = computed(() =>
+ *     this.appConfig.isFeatureEnabled('newDashboard')
+ *   );
+ * }
+ * ```
+ */
+export * from './types';
+export { VALTECH_APP_CONFIG, provideValtechAppConfig } from './config';
+export { AppConfigService } from './app-config.service';
+export { getAppVersion, getAppInfo, type AppVersionInfo } from './version';

package/lib/services/app-config/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * AppConfig Types
+ *
+ * Tipos para el servicio de configuración remota de la aplicación.
+ */
+import { FirestoreDocument } from '../firebase/types';
+/**
+ * Configuración de la aplicación almacenada en Firestore.
+ *
+ * @property version - Versión más reciente de la app
+ * @property minVersion - Versión mínima soportada (opcional)
+ * @property maintenance - Modo mantenimiento global
+ * @property features - Feature flags (key-value boolean)
+ * @property variables - Variables dinámicas de configuración
+ * @property announcements - Anuncios opcionales para mostrar
+ */
+export interface AppConfig extends FirestoreDocument {
+    version: string;
+    minVersion?: string;
+    maintenance?: boolean;
+    features: Record<string, boolean>;
+    variables: Record<string, unknown>;
+    announcements?: Announcement[];
+}
+/**
+ * Anuncio para mostrar en la aplicación.
+ *
+ * @property id - Identificador único del anuncio
+ * @property type - Tipo de anuncio (info, warning, promo)
+ * @property message - Mensaje en múltiples idiomas
+ * @property active - Si el anuncio está activo
+ * @property link - URL opcional para redirección
+ */
+export interface Announcement {
+    id: string;
+    type: 'info' | 'warning' | 'promo';
+    message: Record<string, string>;
+    active: boolean;
+    link?: string;
+}
+/**
+ * Configuración para el proveedor de AppConfigService.
+ *
+ * @property currentVersion - Versión actual de la aplicación
+ * @property showUpdateBanner - Mostrar banner de actualización automáticamente
+ */
+export interface AppConfigServiceConfig {
+    currentVersion: string;
+    showUpdateBanner?: boolean;
+}
+/**
+ * Configuración por defecto del servicio.
+ */
+export declare const DEFAULT_APP_CONFIG_SERVICE_CONFIG: AppConfigServiceConfig;

package/lib/services/app-config/version.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Cross-Platform Version Helpers
+ *
+ * Funciones para obtener la versión de la aplicación de forma
+ * cross-platform (web y mobile con Capacitor).
+ */
+/**
+ * Info completa de la app en plataformas nativas.
+ */
+export interface AppVersionInfo {
+    /** Versión semver (ej: "1.2.3") */
+    version: string;
+    /** Número de build (ej: "123") */
+    build: string;
+    /** Nombre de la app */
+    name: string;
+    /** Bundle ID / Package name */
+    id: string;
+}
+/**
+ * Obtiene la versión de la aplicación de forma cross-platform.
+ *
+ * - En web: retorna la versión de package.json (pasada como parámetro)
+ * - En mobile: usa @capacitor/app para obtener la versión nativa
+ *
+ * @param webVersion - Versión de package.json para fallback en web
+ * @returns Promise<string> - La versión actual de la app
+ *
+ * @example
+ * ```typescript
+ * import { getAppVersion } from 'valtech-components';
+ * import { version } from '../package.json';
+ *
+ * const appVersion = await getAppVersion(version);
+ *
+ * // Uso en main.ts
+ * async function bootstrap() {
+ *   const appVersion = await getAppVersion(version);
+ *   bootstrapApplication(AppComponent, {
+ *     providers: [
+ *       provideValtechAppConfig({ currentVersion: appVersion }),
+ *     ],
+ *   });
+ * }
+ * bootstrap();
+ * ```
+ */
+export declare function getAppVersion(webVersion: string): Promise<string>;
+/**
+ * Obtiene información completa de la app (solo en nativo).
+ * En web retorna null.
+ *
+ * @returns Promise<AppVersionInfo | null> - Info completa o null en web
+ *
+ * @example
+ * ```typescript
+ * const info = await getAppInfo();
+ * if (info) {
+ *   console.log(`App: ${info.name} v${info.version} (build ${info.build})`);
+ *   console.log(`Bundle ID: ${info.id}`);
+ * }
+ * ```
+ */
+export declare function getAppInfo(): Promise<AppVersionInfo | null>;

package/lib/services/app-version/app-version.service.d.ts

@@ -0,0 +1,64 @@
+import { Signal } from '@angular/core';
+import { AppVersionStatus } from './types';
+import * as i0 from "@angular/core";
+export declare class AppVersionService {
+    /** SwUpdate solo existe si el SW está registrado (prod build). */
+    private readonly swUpdate;
+    /** AppConfigService es opcional: la app puede no wirearlo. */
+    private readonly appConfig;
+    private readonly serviceConfig;
+    private readonly document;
+    private readonly destroyRef;
+    /** True cuando el SW reportó un bundle nuevo listo (`VERSION_READY`). */
+    private readonly swUpdateReady;
+    /**
+     * True cuando el usuario descartó el banner de actualización opcional.
+     * El banner obligatorio (`update-required`) ignora este flag.
+     */
+    private readonly _dismissed;
+    readonly dismissed: Signal<boolean>;
+    /**
+     * Versión local del build actual de la app.
+     * Proviene del provider `provideValtechAppVersion({ currentVersion })`.
+     */
+    readonly currentVersion: Signal<string>;
+    /**
+     * Última versión publicada según el config remoto.
+     * `null` si `AppConfigService` no está disponible o aún no cargó.
+     */
+    readonly latestVersion: Signal<string | null>;
+    /**
+     * Estado de la versión:
+     * - `update-required` — la versión local quedó por debajo de `minVersion`
+     *   del config remoto. Hard gate. Solo si `AppConfigService` tiene datos.
+     * - `update-available` — el SW descargó un bundle nuevo (`VERSION_READY`)
+     *   o `AppConfigService.hasUpdate` es true.
+     * - `up-to-date` — en cualquier otro caso.
+     */
+    readonly status: Signal<AppVersionStatus>;
+    constructor();
+    /**
+     * Aplica la actualización pendiente.
+     *
+     * Si el SW está habilitado, activa la versión descargada y recarga; si no,
+     * solo recarga la página (la web obtiene el bundle nuevo del servidor).
+     */
+    applyUpdate(): Promise<void>;
+    /**
+     * Descarta el banner de actualización opcional.
+     * No tiene efecto sobre el estado `update-required` (hard gate).
+     */
+    dismiss(): void;
+    /**
+     * Fuerza un chequeo de actualización del service worker.
+     * No-op si el SW no está habilitado.
+     */
+    checkNow(): Promise<void>;
+    /**
+     * Suscribe `versionUpdates`, programa chequeos periódicos y reacciona al
+     * volver la app a foreground. Solo actúa si el SW está habilitado.
+     */
+    private wireServiceWorker;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppVersionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppVersionService>;
+}

package/lib/services/app-version/config.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AppVersion Provider
+ *
+ * Provider e injection token para el servicio de verificación de versión.
+ */
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { AppVersionServiceConfig } from './types';
+/**
+ * Token de inyección para la configuración de AppVersionService.
+ */
+export declare const VALTECH_APP_VERSION: InjectionToken<Required<AppVersionServiceConfig>>;
+/**
+ * Provee el servicio de verificación de versión a la aplicación Angular.
+ *
+ * Detecta cuándo hay una versión nueva de la app combinando dos señales:
+ * - `SwUpdate` (PWA service worker) — bundle nuevo descargado y listo.
+ * - `AppConfigService` (config remoto en Firestore) — `version` / `minVersion`.
+ *
+ * @param config - Configuración del servicio. `currentVersion` es obligatorio.
+ * @returns EnvironmentProviders para usar en bootstrapApplication.
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { provideValtechAppVersion } from 'valtech-components';
+ * import pkg from '../package.json';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechAppVersion({ currentVersion: pkg.version }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function provideValtechAppVersion(config: AppVersionServiceConfig): EnvironmentProviders;

package/lib/services/app-version/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AppVersion Service Module
+ *
+ * Verificación de versión de la app para PWA / web. Detecta cuándo hay una
+ * versión nueva combinando el service worker (`SwUpdate`) y el config remoto
+ * (`AppConfigService`), con soporte para actualización obligatoria (hard gate).
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { provideValtechAppVersion } from 'valtech-components';
+ * import pkg from '../package.json';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechAppVersion({ currentVersion: pkg.version }),
+ *   ],
+ * });
+ * ```
+ */
+export * from './types';
+export { VALTECH_APP_VERSION, provideValtechAppVersion } from './config';
+export { AppVersionService } from './app-version.service';

package/lib/services/app-version/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AppVersion Types
+ *
+ * Tipos para el servicio de verificación de versión de la aplicación.
+ */
+/**
+ * Estado de la versión de la aplicación respecto a la versión publicada.
+ *
+ * - `up-to-date`   — la app está al día, no hay nada que hacer.
+ * - `update-available` — hay una versión nueva (bundle del SW listo o config
+ *   remoto más nuevo). El usuario puede actualizar pero NO está obligado.
+ * - `update-required` — la versión local quedó por debajo de `minVersion`
+ *   del config remoto (hard gate). El usuario DEBE actualizar para continuar.
+ */
+export type AppVersionStatus = 'up-to-date' | 'update-available' | 'update-required';
+/**
+ * Configuración para el proveedor de AppVersionService.
+ *
+ * @property currentVersion - Versión del build actual de la app (semver string).
+ *   Normalmente proviene del `version` de `package.json`.
+ * @property checkIntervalMs - Intervalo (ms) entre llamadas a
+ *   `SwUpdate.checkForUpdate()`. Default: 30 minutos.
+ */
+export interface AppVersionServiceConfig {
+    currentVersion: string;
+    checkIntervalMs?: number;
+}
+/**
+ * Intervalo por defecto de chequeo de actualizaciones: 30 minutos.
+ */
+export declare const DEFAULT_CHECK_INTERVAL_MS: number;
+/**
+ * Configuración por defecto del servicio.
+ */
+export declare const DEFAULT_APP_VERSION_SERVICE_CONFIG: Required<AppVersionServiceConfig>;

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

@@ -0,0 +1,106 @@
+import { AuthState, AuthUser, AuthError, MFAPendingState, StoredAuthState } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para manejo de estado de autenticación con Angular Signals.
+ * Proporciona estado reactivo inmutable.
+ */
+export declare class AuthStateService {
+    private _state;
+    private _mfaPending;
+    /** Estado completo de autenticación */
+    readonly state: import("@angular/core").Signal<AuthState>;
+    /** Estado de MFA pendiente */
+    readonly mfaPending: import("@angular/core").Signal<MFAPendingState>;
+    /** Usuario está autenticado */
+    readonly isAuthenticated: import("@angular/core").Signal<boolean>;
+    /** Estado de carga */
+    readonly isLoading: import("@angular/core").Signal<boolean>;
+    /** Token de acceso */
+    readonly accessToken: import("@angular/core").Signal<string>;
+    /** Roles del usuario */
+    readonly roles: import("@angular/core").Signal<string[]>;
+    /** Permisos del usuario */
+    readonly permissions: import("@angular/core").Signal<string[]>;
+    /** Usuario es super admin */
+    readonly isSuperAdmin: import("@angular/core").Signal<boolean>;
+    /** Usuario tiene suscripción premium activa (no ve ads) */
+    readonly isPremium: import("@angular/core").Signal<boolean>;
+    /** Error actual */
+    readonly error: import("@angular/core").Signal<AuthError>;
+    /** Información del usuario */
+    readonly user: import("@angular/core").Signal<AuthUser>;
+    /**
+     * Establece el estado de carga.
+     */
+    setLoading(isLoading: boolean): void;
+    /**
+     * Establece el estado de autenticación exitosa.
+     */
+    setAuthenticated(data: {
+        accessToken: string;
+        refreshToken: string;
+        userId?: string;
+        email?: string;
+        roles: string[];
+        permissions: string[];
+        isSuperAdmin: boolean;
+        isPremium?: boolean;
+        expiresAt: number;
+    }): void;
+    /**
+     * Actualiza solo el access token (después de refresh).
+     */
+    updateAccessToken(accessToken: string, expiresIn: number): void;
+    /**
+     * Actualiza el refresh token (token rotation).
+     */
+    updateRefreshToken(refreshToken: string): void;
+    /**
+     * Actualiza los permisos.
+     */
+    updatePermissions(roles: string[], permissions: string[], isSuperAdmin: boolean): void;
+    /**
+     * Establece un error de autenticación.
+     */
+    setError(error: AuthError): void;
+    /**
+     * Limpia el error.
+     */
+    clearError(): void;
+    /**
+     * Establece estado de MFA pendiente.
+     */
+    setMFAPending(mfaState: MFAPendingState): void;
+    /**
+     * Limpia el estado de MFA pendiente.
+     */
+    clearMFAPending(): void;
+    /**
+     * Resetea todo el estado a valores iniciales.
+     */
+    reset(): void;
+    /**
+     * Restaura estado desde datos almacenados.
+     */
+    restoreFromStorage(stored: Partial<StoredAuthState>): void;
+    /**
+     * Actualiza el userId y email (después de parsear el token).
+     */
+    updateUserInfo(userId: string, email: string): void;
+    /**
+     * Hidrata el state con campos del profile (nombre, handle, avatar, phone).
+     * Invocado tras `getProfile()` o `updateProfile()` para que consumers de
+     * `auth.user()` vean los campos enriched automáticamente.
+     *
+     * Cualquier campo `undefined` se ignora (no sobrescribe con null). Campos
+     * `null` explícitos se persisten (signal de "limpiado").
+     */
+    updateProfileFields(fields: {
+        name?: string | null;
+        handle?: string | null;
+        avatarUrl?: string | null;
+        phone?: string | null;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthStateService>;
+}