import { FrontendTelemetryContext, ModuleLoadFailureReason, ModuleLoadSource } from '../../../../../../../out-tsc/libs/observability/mf/index.d.ts';
import { EventType, NetworkOperation, ObservableHandler } from '../mfRuntimeUtils/index.js';
/**
 * Describe the telemetry payload attached to one observable loader instance.
 * Describe el payload de telemetría adjunto a una instancia del loader observable.
 */
export type ObservableLoaderTelemetryConfig = {
    /**
     * Shared frontend telemetry context for all load events emitted by this helper.
     * Contexto compartido de telemetría frontend para todos los eventos de carga emitidos por este helper.
     */
    context: FrontendTelemetryContext & {
        /**
         * Module id associated with the current MF load attempt.
         * Id del módulo asociado al intento actual de carga del MF.
         */
        moduleId: string;
    };
    /**
     * Runtime source used to classify the load path in telemetry.
     * Fuente de runtime usada para clasificar la ruta de carga en telemetría.
     */
    loadSource: ModuleLoadSource;
};
/**
 * Store the final load timings that MFLoader consumes after render succeeds.
 * Almacena los tiempos finales de carga que MFLoader consume después de que el render se completa correctamente.
 */
export type ResolvedModuleLoadTelemetry = {
    /**
     * Sequential attempt number for the current observable loader instance.
     * Número secuencial de intento para la instancia actual del loader observable.
     */
    attempt: number;
    /**
     * Time spent downloading the bundle payload after resolution.
     * Tiempo dedicado a descargar el payload del bundle después de la resolución.
     */
    loadDurationMs: number;
    /**
     * High-resolution timestamp captured when the bundle became executable.
     * Marca de tiempo de alta resolución capturada cuando el bundle pasó a ser ejecutable.
     */
    loadReadyAt: number;
    /**
     * Runtime source used for the successful load.
     * Fuente de runtime usada para la carga exitosa.
     */
    loadSource: ModuleLoadSource;
    /**
     * High-resolution timestamp captured when the attempt started.
     * Marca de tiempo de alta resolución capturada cuando comenzó el intento.
     */
    loadStartedAt: number;
    /**
     * Time spent resolving the manifest or direct entry before bundle download.
     * Tiempo dedicado a resolver el manifiesto o la entrada directa antes de descargar el bundle.
     */
    resolveDurationMs: number;
};
/**
 * Store the in-flight load metadata that may later be abandoned by MFLoader.
 * Almacena los metadatos de carga en curso que luego pueden ser abandonados por MFLoader.
 */
export type PendingModuleLoadTelemetry = {
    /**
     * Sequential attempt number for the current observable loader instance.
     * Número secuencial de intento para la instancia actual del loader observable.
     */
    attempt: number;
    /**
     * Runtime source used for the pending load.
     * Fuente de runtime usada para la carga pendiente.
     */
    loadSource: ModuleLoadSource;
    /**
     * High-resolution timestamp captured when the pending attempt started.
     * Marca de tiempo de alta resolución capturada cuando comenzó el intento pendiente.
     */
    loadStartedAt: number;
};
/**
 * Store the latest terminal failure metadata emitted by the loader.
 * Almacena los últimos metadatos terminales de fallo emitidos por el loader.
 */
export type FailedModuleLoadTelemetry = {
    /**
     * Optional stable detail string captured from the failure cause.
     * Cadena opcional y estable de detalle capturada desde la causa del fallo.
     */
    failureDetail?: string;
    /**
     * Shared failure reason emitted for the current attempt.
     * Motivo de fallo compartido emitido para el intento actual.
     */
    failureReason: ModuleLoadFailureReason;
};
/**
 * Describe the observable loader handle cached in the runtime window registry.
 * Describe el handle del loader observable almacenado en caché en el registro runtime de `window`.
 */
export interface ObservableLoaderMFInstance {
    /**
     * Consume the latest terminal failure details for one completed attempt.
     * Consume los últimos detalles terminales de fallo para un intento completado.
     */
    consumeLastFailureTelemetry: () => FailedModuleLoadTelemetry | undefined;
    /**
     * Consume the current pending load metadata when MFLoader abandons the attempt.
     * Consume los metadatos pendientes de carga actuales cuando MFLoader abandona el intento.
     */
    consumePendingLoadTelemetry: () => PendingModuleLoadTelemetry | undefined;
    /**
     * Consume the final resolved timings after MFLoader renders successfully.
     * Consume los tiempos finales resueltos después de que MFLoader renderiza correctamente.
     */
    consumeResolvedLoadTelemetry: () => ResolvedModuleLoadTelemetry | undefined;
    /**
     * Notify all current subscribers of the latest lifecycle state and progress.
     * Notifica a todos los suscriptores actuales sobre el último estado y progreso del ciclo de vida.
     */
    notify: (newEvent: EventType, progress: number) => void;
    /**
     * Start one new manifest and bundle download attempt.
     * Inicia un nuevo intento de descarga de manifiesto y bundle.
     */
    start: () => Promise<void>;
    /**
     * Register one observable lifecycle subscriber.
     * Registra un suscriptor del ciclo de vida observable.
     */
    subscribe: (subscriber: ObservableHandler) => void;
    /**
     * Retry the failed attempt when the loader is currently idle.
     * Reintenta el intento fallido cuando el loader está actualmente inactivo.
     */
    tryAgain: () => void;
    /**
     * Remove one previously registered lifecycle subscriber.
     * Elimina un suscriptor del ciclo de vida previamente registrado.
     */
    unsubscribe: (subscriber: ObservableHandler) => void;
}
/**
 * Expose the runtime cached observable loader handle as the public helper type.
 * Expone el handle del loader observable almacenado en caché por el runtime como tipo helper público.
 */
export type ObservableLoaderMF = ObservableLoaderMFInstance;
/**
 * Describe the compatibility constructor maintained for tests and legacy callers.
 * Describe el constructor de compatibilidad mantenido para tests y callers legados.
 */
export interface ObservableLoaderMFConstructor {
    new (host: string, scriptId: string, networkOperation: NetworkOperation, isRemote: boolean, telemetryConfig?: ObservableLoaderTelemetryConfig): ObservableLoaderMFInstance;
}
//# sourceMappingURL=types.d.ts.map