import * as i0 from "@angular/core";
/**
 * Handler de refresh que registra una página. Puede ser sync o async —
 * `val-page-wrapper` espera (`await`) a que termine antes de cerrar el spinner.
 */
export type PageRefreshHandler = () => Promise<void> | void;
/**
 * PageRefreshService — bus del pull-to-refresh estándar del factory.
 *
 * **Por qué existe:** `val-page-wrapper` posee un único `<ion-content>` y todas
 * las páginas se renderizan dentro vía `<router-outlet>`. Un `<ion-refresher>`
 * tiene que vivir dentro de ese `ion-content`, así que el refresher NO puede
 * declararse en el template de cada página — vive una sola vez en
 * `val-page-wrapper`. Este servicio es el puente: la página activa registra
 * *qué hacer* al refrescar; el page-wrapper dispara el gesto y cierra el spinner.
 *
 * **Uso en una página** (ver `frontend/CLAUDE.md` — es el patrón estándar):
 *
 * ```ts
 * export class MiPage implements ViewWillEnter, ViewWillLeave {
 *   private pageRefresh = inject(PageRefreshService);
 *
 *   ionViewWillEnter(): void {
 *     this.pageRefresh.register(() => this.reload());
 *   }
 *   ionViewWillLeave(): void {
 *     this.pageRefresh.unregister();
 *   }
 *
 *   private async reload(): Promise<void> {
 *     // re-fetch / re-suscribir streams / etc.
 *   }
 * }
 * ```
 *
 * Páginas que no llaman `register()` simplemente no muestran refresher —
 * opt-in, sin impacto.
 */
export declare class PageRefreshService {
    private handler;
    /**
     * `true` cuando hay una página con handler registrado. `val-page-wrapper`
     * renderiza el `<val-refresher>` sólo cuando esto es `true`.
     */
    readonly hasHandler: import("@angular/core").WritableSignal<boolean>;
    /**
     * Registra el handler de refresh de la página activa. Llamar en
     * `ionViewWillEnter`. Si ya había uno, lo reemplaza (sólo hay una página
     * activa a la vez en el router-outlet de Ionic).
     */
    register(handler: PageRefreshHandler): void;
    /**
     * Quita el handler. Llamar en `ionViewWillLeave` para que el refresher
     * desaparezca al salir de la vista.
     */
    unregister(): void;
    /**
     * Duración mínima (ms) que el spinner permanece visible, aunque el handler
     * termine antes. Sin esto, un reload rápido (data cacheada) cierra el spinner
     * al instante → se percibe como "no hubo refresh". Con el mínimo, el gesto se
     * siente smooth y CONSISTENTE en todas las vistas que usan el page-wrapper.
     */
    private static readonly MIN_SPINNER_MS;
    /**
     * Ejecuta el handler registrado y espera a que termine, garantizando una
     * duración mínima de spinner. Lo invoca `val-page-wrapper` al detectar el
     * gesto de pull. No-op si no hay handler.
     */
    run(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageRefreshService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PageRefreshService>;
}
/**
 * Conecta una página al pull-to-refresh estándar en UNA línea, sin lifecycle
 * hooks manuales: registra el handler y lo desregistra al destruir la página
 * (vía `DestroyRef`).
 *
 * DEBE llamarse en un injection context (constructor o field initializer).
 *
 * @example
 * ```ts
 * export class MiPage {
 *   private data = createRefreshableStream(() => this.svc.getX());
 *   readonly items = this.data.data;
 *
 *   constructor() {
 *     connectPageRefresh(() => this.data.reload());
 *   }
 * }
 * ```
 *
 * Reemplaza el patrón `ngOnInit`→`register` / `ngOnDestroy`→`unregister`.
 */
export declare function connectPageRefresh(handler: PageRefreshHandler): void;
