import { MutableRefObject } from 'react';
import { ModuleLoadFailureReason } from '../../../../../../../out-tsc/libs/observability/mf/index.d.ts';
import { BuildWebTelemetryContext, MFType } from '../../types';
/**
 * Track one active module-swap telemetry attempt while a requested MF is loading.
 * Sigue un intento activo de telemetría de intercambio de módulo mientras se carga un MF solicitado.
 */
export type ActiveSwapState = {
    /**
     * Module id that remains visible until the requested MF takes over.
     * Id del módulo que permanece visible hasta que el MF solicitado toma el control.
     */
    fromModuleId: string;
    /**
     * High-resolution timestamp captured when the current swap attempt started.
     * Marca de tiempo de alta resolución capturada cuando comenzó el intento de intercambio actual.
     */
    startedAt: number;
    /**
     * Module id that should replace the currently visible MF.
     * Id del módulo que debe reemplazar al MF actualmente visible.
     */
    toModuleId: string;
};
/**
 * Inputs required to coordinate stale-while-revalidate MF swaps.
 * Entradas necesarias para coordinar intercambios de MF con estrategia stale-while-revalidate.
 */
export type UseMFSwapArgs = {
    /**
     * Ref to the currently active swap telemetry attempt, if one exists.
     * Ref al intento de telemetría de intercambio actualmente activo, si existe.
     */
    activeSwapRef: MutableRefObject<ActiveSwapState | null>;
    /**
     * Whether runtime globals should remain cached after stale cleanup.
     * Indica si los globales de runtime deben permanecer en caché después de la limpieza obsoleta.
     */
    cache: boolean;
    /**
     * Builder for the shared web telemetry context attached to swap events.
     * Constructor del contexto compartido de telemetría web adjunto a los eventos de intercambio.
     */
    createTelemetryContext: BuildWebTelemetryContext;
    /**
     * Close pending module-load telemetry when a requested MF is abandoned.
     * Cierra la telemetría pendiente de carga de módulo cuando se abandona un MF solicitado.
     */
    emitAbandonedLoadTelemetry: (instance: MFType, failureReason: ModuleLoadFailureReason) => void;
    /**
     * Close the current swap attempt when the requested MF never takes over.
     * Cierra el intento de intercambio actual cuando el MF solicitado nunca toma el control.
     */
    emitSwapFailedTelemetry: (failureReason: ModuleLoadFailureReason, failureDetail?: string) => void;
    /**
     * Start telemetry for a new swap from the visible MF to the requested MF.
     * Inicia la telemetría de un nuevo intercambio desde el MF visible hacia el MF solicitado.
     */
    emitSwapStartedTelemetry: (fromModuleId: string, toModuleId: string, moduleNamespace: string) => void;
    /**
     * Module id currently requested by the host caller.
     * Id del módulo solicitado actualmente por el caller del host.
     */
    moduleId: string;
    /**
     * Runtime namespace used to separate MF globals by host or shell.
     * Namespace de runtime usado para separar los globales del MF por host o shell.
     */
    prefix: string;
    /**
     * Surface stale-instance cleanup failures through the shared loader error path.
     * Expone fallos de limpieza de instancias obsoletas mediante la ruta compartida de error del loader.
     */
    reportLoaderError: (message: string, error?: unknown) => void;
};
/**
 * Public state and commands exposed by the MF swap coordinator.
 * Estado público y comandos expuestos por el coordinador de intercambio del MF.
 */
export type UseMFSwapResult = {
    /**
     * MF instance that is currently visible to the user.
     * Instancia del MF que actualmente es visible para el usuario.
     */
    mountedScript: MFType;
    /**
     * MF instance that should become visible after a successful render.
     * Instancia del MF que debe volverse visible después de un render exitoso.
     */
    requestedScript: MFType;
    /**
     * Whether the host is in the middle of a transition between two MF instances.
     * Indica si el host está en medio de una transición entre dos instancias de MF.
     */
    isSwappingModule: boolean;
    /**
     * Ref to the latest visible MF instance.
     * Ref a la última instancia visible del MF.
     */
    mountedScriptRef: MutableRefObject<MFType>;
    /**
     * Ref to the latest requested MF instance, even if it is still hidden.
     * Ref a la última instancia solicitada del MF, incluso si sigue oculta.
     */
    requestedScriptRef: MutableRefObject<MFType>;
    /**
     * Promote the already-rendered requested MF so it becomes the visible instance.
     * Promueve el MF solicitado ya renderizado para que se convierta en la instancia visible.
     */
    promoteRequestedScript: () => void;
};
//# sourceMappingURL=types.d.ts.map