import { OnDestroy, OnInit } from '@angular/core';
import { FormControl } from '@angular/forms';
import { ToggleInputMetadata } from '../../molecules/toggle-input/types';
import { ButtonMetadata } from '../../types';
import { NotificationPermissionState } from '../../../services/auth/types';
import { PreferencesService } from '../../../services/preferences/preferences.service';
import { NotificationPreferencesViewConfig } from './types';
import * as i0 from "@angular/core";
/**
 * Estados de la vista de preferencias push:
 *  - `idle`:          toggle off, sin operación en curso, sin errores
 *  - `enabling`:      secuencia de activación en curso (toggle spinner)
 *  - `enabled`:       todo OK (master=true + permission=granted + token registrado)
 *  - `disabling`:     desactivación en curso
 *  - `error`:         último intento falló → mensaje + botón "Reintentar"
 *  - `blocked`:       navegador denegó permisos → mensaje + cómo arreglar
 *  - `unsupported`:   navegador no soporta FCM → mensaje
 *  - `needs-install`: iOS sin standalone → instrucciones de instalación PWA
 */
type UiState = 'idle' | 'enabling' | 'enabled' | 'disabling' | 'error' | 'blocked' | 'unsupported' | 'needs-install';
/**
 * `val-notification-preferences-view` — **preferencias de notificaciones push**
 * (FCM) full-feature autocontenida (organism). Promovida desde `showcase` bajo el
 * proceso de ADR-021.
 *
 * Separada de `val-notifications-view` (el inbox / feed). Aquí el user **activa o
 * desactiva** las notificaciones push en este dispositivo.
 *
 * UX simplificado: UN solo toggle que ejecuta toda la secuencia (pedir permiso →
 * SW ready → getToken → registrar en backend → set master pref) vía
 * `MessagingService.enable()`. El registro del device en el backend va como
 * callback (la lib no depende de `AuthService` para evitar ciclos). Mensajes
 * contextuales y botón "Reintentar" aparecen solo cuando aplican.
 *
 * NO renderiza ion-content — vive dentro de val-page-wrapper. `ActivatedRoute` se
 * inyecta `{ optional: true }` → funciona sin router (embebida / Storybook).
 */
export declare class NotificationPreferencesViewComponent implements OnInit, OnDestroy {
    private nav;
    private i18n;
    private toast;
    private auth;
    private messaging;
    private pageRefresh;
    readonly prefs: PreferencesService;
    private route;
    /**
     * Config vía @Input (object-first). Si no se pasa, se cae al route data
     * `notificationPreferencesConfig` (poblado por
     * `provideValtechNotificationPreferencesRoutes`). `resolvedConfig` mergea con
     * los defaults — `@Input` gana sobre route data.
     */
    config?: NotificationPreferencesViewConfig;
    readonly resolvedConfig: import("@angular/core").Signal<Required<Omit<NotificationPreferencesViewConfig, "onPushEnabled" | "onPushDisabled">> & Pick<NotificationPreferencesViewConfig, "onPushEnabled" | "onPushDisabled">>;
    /** Namespace i18n resuelto (capturado para llamadas no-reactivas). */
    private get ns();
    /** Operación en curso (gobierna spinner del toggle + label "Activando…"). */
    private readonly _busy;
    /** True si el último intento falló — gobierna estado `error` + retry button. */
    private readonly _lastFailed;
    /** True mientras se re-obtiene el token FCM en background (no afecta la UI). */
    private _repairingToken;
    /** Toggle del expand de detalles técnicos. */
    readonly showDetails: import("@angular/core").WritableSignal<boolean>;
    readonly permission: import("@angular/core").WritableSignal<NotificationPermissionState>;
    readonly isSupported: import("@angular/core").WritableSignal<boolean>;
    readonly currentToken: import("@angular/core").WritableSignal<string>;
    readonly needsIOSInstall: import("@angular/core").WritableSignal<boolean>;
    /** FormControl del toggle (sync-eado con `isEnabled` via effect). */
    readonly toggleControl: FormControl<boolean>;
    /** Handler del listener `focus` — referencia guardada para poder removerlo. */
    private readonly onWindowFocus;
    /** Timer del debounce del refresh disparado por `focus`. */
    private focusDebounceTimer;
    /** Ventana de debounce (ms) para el refresh disparado por `focus`. */
    private readonly FOCUS_DEBOUNCE_MS;
    readonly pageTitle: import("@angular/core").Signal<string>;
    readonly pageDescription: import("@angular/core").Signal<string>;
    /**
     * Estado efectivo del toggle: "el usuario tiene push activo".
     *
     * Se deriva SOLO de la decisión del usuario (`master`) y del permiso del SO
     * (`permission`). El token FCM NO forma parte del estado de UI: vive en
     * memoria, se pierde en cada recarga/suspensión de la PWA y produciría flicker.
     * Si falta token con `master && granted`, es un detalle reparable en
     * background (ver `repairTokenIfNeeded`), no un cambio del toggle.
     */
    readonly isEnabled: import("@angular/core").Signal<boolean>;
    readonly state: import("@angular/core").Signal<UiState>;
    readonly busyLabel: import("@angular/core").Signal<string>;
    readonly contextMessage: import("@angular/core").Signal<string>;
    readonly alertVariant: import("@angular/core").Signal<"warning" | "danger" | "info">;
    readonly alertIcon: import("@angular/core").Signal<"alert-circle-outline" | "close-circle-outline">;
    readonly toggleProps: import("@angular/core").Signal<ToggleInputMetadata>;
    readonly retryButtonProps: import("@angular/core").Signal<Partial<ButtonMetadata>>;
    readonly tokenPreview: import("@angular/core").Signal<string>;
    constructor();
    /**
     * Registra el pull-to-refresh estándar. Aunque esta vista no muestra una
     * lista remota, sí refleja estado mutable del browser (permiso, token,
     * soporte FCM) que puede cambiar fuera de la app — el refresh re-evalúa todo.
     *
     * Se usa `ngOnInit`/`ngOnDestroy` (NO `ionViewWillEnter`) porque
     * `val-page-wrapper` usa `<router-outlet>` plano — los hooks `ionView*` solo
     * disparan dentro de `<ion-router-outlet>`.
     */
    ngOnInit(): void;
    ngOnDestroy(): void;
    /** Refresca el estado del browser con debounce — evita ráfagas de `focus`. */
    private scheduleBrowserRefresh;
    /**
     * Secuencia completa de activación.
     *
     * Toda la mecánica (permission → SW ready → getToken con retry → watchdog de
     * auto-reload) vive en `MessagingService.enable()` de la lib. El paso de
     * registro del device en el backend se pasa como callback (`registerDevice`)
     * porque la lib no puede depender de `AuthService` sin crear un ciclo.
     *
     * `enable()` no hace throw: resuelve con un `EnablePushResult` descriptivo.
     */
    onEnable(): Promise<void>;
    onDisable(): Promise<void>;
    /** Reintentar la secuencia completa de activación, sin importar el estado actual. */
    onRetry(): Promise<void>;
    toggleDetails(): void;
    private refreshBrowserState;
    /**
     * Repara el token FCM en background.
     *
     * Si el usuario tiene push activo (`master && granted`) pero no hay token en
     * memoria — caso típico tras un cold start de la PWA — re-obtenemos el token
     * y re-registramos el device sin tocar el toggle ni mostrar un error
     * alarmista. El token es un detalle de implementación reparable, no parte del
     * estado de UI (ver `isEnabled`).
     */
    private repairTokenIfNeeded;
    /**
     * iOS browser sin estar instalado como PWA — push web no disponible.
     * Aplica a Safari y a Edge/Chrome/Firefox en iOS (todos WebKit por mandato Apple).
     */
    private detectNeedsIOSInstall;
    protected tt(key: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationPreferencesViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationPreferencesViewComponent, "val-notification-preferences-view", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
}
export {};