/**
 * Notifications Service
 *
 * Servicio para leer notificaciones desde Firestore.
 * El backend escribe las notificaciones, el frontend solo las lee y actualiza estado.
 *
 * Se auto-inicializa cuando AuthService tiene un usuario autenticado.
 * También puede inicializarse manualmente con `initialize(userId)`.
 */
import { Injector } from '@angular/core';
import { Observable } from 'rxjs';
import { FirestoreCollectionFactory } from './firestore-collection';
import { FirestoreDocument } from './types';
import * as i0 from "@angular/core";
/**
 * Documento de notificación en Firestore.
 * Estructura escrita por el backend.
 */
export interface NotificationDocument extends FirestoreDocument {
    /** Título de la notificación */
    title?: string;
    /** Cuerpo del mensaje */
    body?: string;
    /** Datos personalizados (ej: route, actionType). Legacy — preferir actionRoute + payload */
    data?: Record<string, string>;
    /** Tipo de notificación */
    type?: 'fcm' | 'system' | 'reminder' | string;
    /** Si la notificación fue leída */
    isRead: boolean;
    /** AppID origen (ej: 'showcase', 'sigify'). Permite cross-app routing */
    appId?: string;
    /** OrgID asociado (si la notif es org-scoped). Habilita switch-org al abrir */
    orgId?: string;
    /** Route destino al click (ej: '/app/docs/123') */
    actionRoute?: string;
    /** Payload estructurado para acciones (reemplazo tipado de `data`) */
    payload?: Record<string, unknown>;
}
/**
 * Servicio para leer notificaciones desde Firestore.
 *
 * Se auto-inicializa cuando AuthService tiene un usuario autenticado.
 * No requiere llamar a `initialize()` manualmente si AuthService está configurado.
 *
 * @example
 * ```typescript
 * // Con AuthService configurado: auto-inicialización
 * // Solo inyectar y usar directamente
 * private notifications = inject(NotificationsService);
 *
 * notifications$ = this.notifications.getAll();
 * unreadCount$ = this.notifications.getUnreadCount();
 *
 * // Sin AuthService: inicialización manual
 * this.notifications.initialize(userId);
 * ```
 */
export declare class NotificationsService {
    private injector;
    private collectionFactory;
    private collection;
    private currentUserId;
    private collectionReady$;
    private authService;
    private firebaseService;
    constructor(injector: Injector, collectionFactory: FirestoreCollectionFactory);
    /**
     * Gate de Firebase Auth: emite la colección lista SOLO cuando la sesión de
     * Firebase Auth está confirmada. Sin FirebaseService disponible, no gatea
     * (degrada al comportamiento previo). Espera a que `firebaseAuthReady$`
     * emita antes de propagar la colección — así el listener Firestore nunca se
     * adjunta antes de que `request.auth` esté disponible.
     */
    private collectionWhenAuthReady$;
    /**
     * Configura auto-inicialización observando el estado de AuthService.
     * Se ejecuta en el contexto del injector para poder usar effect().
     */
    private setupAutoInitialization;
    /**
     * Inicializa el servicio para un usuario específico.
     *
     * NOTA: Se llama automáticamente si AuthService está configurado.
     * Solo usar manualmente si AuthService no está disponible o se necesita
     * un userId diferente al del usuario autenticado.
     */
    initialize(userId: string): void;
    /**
     * Verifica si el servicio está inicializado.
     */
    get isReady(): boolean;
    /**
     * Obtiene el ID del usuario actual.
     */
    get userId(): string | null;
    /**
     * Obtiene notificaciones ordenadas por fecha descendente (real-time).
     * Se actualiza automáticamente cuando cambian los datos.
     *
     * El listener Firestore NO se adjunta hasta que la sesión de Firebase Auth
     * esté confirmada (`FirebaseService.firebaseAuthReady`). Esto cierra la
     * ventana de `permission-denied` en cold start de PWA, donde el JWT del
     * backend puede estar listo antes que la sesión de Firebase Auth.
     *
     * @param limit - Máximo de notificaciones a cargar (default: 50)
     */
    getAll(limit?: number): Observable<NotificationDocument[]>;
    /**
     * Obtiene notificaciones (one-time fetch sin listener).
     * Útil para cargas iniciales sin necesidad de updates en tiempo real.
     *
     * @param limit - Máximo de notificaciones a cargar (default: 50)
     */
    getAllOnce(limit?: number): Promise<NotificationDocument[]>;
    /**
     * Obtiene solo notificaciones no leídas (real-time, filtrado server-side).
     *
     * @param limit - Máximo de notificaciones (default: 50)
     */
    getUnread(limit?: number): Observable<NotificationDocument[]>;
    /**
     * Cuenta notificaciones no leídas usando server-side aggregation query.
     * No descarga documentos — eficiente para badges en UI.
     *
     * Gateado por `firebaseAuthReady` — la aggregation query no se ejecuta hasta
     * que la sesión de Firebase Auth esté lista.
     */
    getUnreadCount(): Observable<number>;
    /**
     * Obtiene una notificación por ID.
     */
    getById(notificationId: string): Promise<NotificationDocument | null>;
    /**
     * Marca una notificación como leída.
     */
    markAsRead(notificationId: string): Promise<void>;
    /**
     * Marca todas las notificaciones no leídas como leídas (batch write).
     */
    markAllAsRead(): Promise<void>;
    /**
     * Elimina una notificación.
     */
    delete(notificationId: string): Promise<void>;
    /**
     * Elimina todas las notificaciones del usuario (batch delete).
     */
    deleteAll(): Promise<void>;
    /**
     * Limpia el estado del servicio.
     * Útil para logout.
     */
    reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsService, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationsService>;
}