import { DynamicMFStore } from '../WindowBase/contexts/DynamicMFParmsContext/store';
import { WindowToolsMF } from '../WindowBase/contexts';
import { EmergeType } from '../areas/types';
import { AuthUserType, AxiosOperation, EnvironmentType, HostToolsType } from '@m4l/core';
import { Formatters, HostThemeType, LocaleType } from '@m4l/graphics';
import { Theme } from '@mui/material';
import { FrontendTelemetryContext } from '../../../../../out-tsc/libs/observability/mf/index.d.ts';
import { M4LOverridesStyleRules } from '../../@types/augmentations';
import { MF_LOADER_KEY_COMPONENT } from './constants';
import { MFLoaderSlots } from './slots/MFLoaderEnum';
declare global {
    interface Window {
        [key: string]: unknown;
    }
}
/**
 * Minimal realtime producer-tools contract forwarded into one MF instance.
 * Contrato mínimo de herramientas del productor realtime reenviado a una instancia del MF.
 *
 * Keep the shape structural so packages such as `@m4l/gclick` can provide a
 * richer domain-specific implementation without creating a hard dependency
 * from `@m4l/components` back into a feature package.
 *
 * Mantiene la forma estructural para que paquetes como `@m4l/gclick` puedan
 * ofrecer una implementación más rica y específica del dominio sin crear una
 * dependencia fuerte desde `@m4l/components` hacia un paquete de funcionalidades.
 */
export interface MFRealtimeProducerToolsContract {
    /**
     * Subscribe through one host-owned realtime engine.
     * Se suscribe a través de un motor realtime propiedad del host.
     *
     * The `never[]` rest shape is intentional: it keeps this contract structural
     * so richer domain-specific signatures remain assignable without teaching
     * `@m4l/components` the concrete parameter types of every realtime package.
     *
     * La forma rest `never[]` es intencional: mantiene este contrato estructural
     * para que firmas más ricas y específicas del dominio sigan siendo asignables
     * sin enseñarle a `@m4l/components` los tipos de parámetros concretos de cada paquete realtime.
     */
    subscribe: (...args: never[]) => void;
    /**
     * Unsubscribe through one host-owned realtime engine.
     * Cancela la suscripción a través de un motor realtime propiedad del host.
     *
     * The `never[]` rest shape is intentional for the same reason as `subscribe`.
     * La forma rest `never[]` es intencional por la misma razón que en `subscribe`.
     */
    unsubscribe: (...args: never[]) => void;
    /**
     * Publish one synthetic realtime batch through the shared producer pipeline.
     *
     * The `never[]` rest shape is intentional for the same reason as
     * `subscribe`.
     */
    publishMessages: (...args: never[]) => void;
    /**
     * Read one lightweight runtime-metadata snapshot for a resource type.
     *
     * The `never[]` rest shape is intentional for the same reason as
     * `subscribe`.
     */
    getResourceRuntimeMeta: (...args: never[]) => unknown;
}
/**
 * Known realtime capabilities forwarded from the host into one MF instance.
 * Capacidades realtime conocidas reenviadas desde el host a una instancia del MF.
 */
export interface MFHostRealtimeCapabilities {
    producerTools?: MFRealtimeProducerToolsContract;
}
/**
 * Minimal MF-facing tools projected from one richer shell-owned runtime.
 * Herramientas mínimas orientadas al MF proyectadas desde un runtime más rico propiedad del shell.
 */
export interface MFHostRuntimeTools {
    /**
     * Known realtime capabilities shared by the host or mini-host.
     * Capacidades realtime conocidas compartidas por el host o mini-host.
     */
    realtime?: MFHostRealtimeCapabilities;
}
/**
 * Host-owned runtime capabilities forwarded into one MF instance.
 * Capacidades de runtime propiedad del host reenviadas a una instancia del MF.
 *
 * Keep this bag intentionally small and host-owned. MFs should consume it
 * through dedicated hooks/contexts instead of reaching into the loader contract.
 *
 * Mantiene este contenedor intencionalmente pequeño y propiedad del host. Los
 * MFs deben consumirlo mediante hooks o contextos dedicados en lugar de acceder
 * directamente al contrato del loader.
 */
export type MFHostRuntime = MFHostRuntimeTools;
/**
 * Base props shared by MF runtime helpers.
 * Props base compartidas por los helpers de runtime del MF.
 */
export interface MFBaseProps {
    /**
     * Debug port used to load the MF in localhost-style environments.
     * Puerto de depuración usado para cargar el MF en entornos estilo localhost.
     */
    debugPort: number;
    /**
     * Whether the MF bundle should stay cached for future mounts.
     * Indica si el bundle del MF debe permanecer en caché para montajes futuros.
     */
    cache?: boolean;
    /**
     * Prefix used to namespace MF globals such as `render_v2_*` and `unmount_*`.
     * Prefijo usado para dar namespace a globales del MF como `render_v2_*` y `unmount_*`.
     */
    prefix: string;
    /**
     * Optional host-owned runtime capabilities forwarded into the MF instance.
     * Capacidades opcionales de runtime propiedad del host reenviadas a la instancia del MF.
     */
    hostRuntime?: MFHostRuntime;
}
/**
 * Props accepted by MFLoader.
 * Props aceptadas por MFLoader.
 */
export interface MFLoaderProps extends MFBaseProps {
    /**
     * Unique MF module identifier.
     * Identificador único del módulo MF.
     */
    moduleId: string;
    /**
     * Dynamic store forwarded into the mounted MF instance.
     * Store dinámico reenviado a la instancia montada del MF.
     */
    dynamicMFStore?: DynamicMFStore;
    /**
     * Window tools exposed to the MF instance.
     * Herramientas de ventana expuestas a la instancia del MF.
     */
    windowTools: WindowToolsMF;
    /**
     * Window launch mode such as layout, popup, or modal.
     * Modo de apertura de ventana, como layout, popup o modal.
     */
    emergeType?: EmergeType;
    /**
     * Logged user forwarded to MFs that need user context.
     * Usuario autenticado reenviado a los MFs que necesitan contexto de usuario.
     */
    loggedUser?: AuthUserType;
}
/**
 * Slot names exposed by MFLoader for theme overrides and local styling.
 * Nombres de slots expuestos por MFLoader para overrides de tema y estilos locales.
 */
export type MFLoaderSlotsType = keyof typeof MFLoaderSlots;
/**
 * Dynamic styling state for the MF mount containers.
 * Estado dinámico de estilos para los contenedores de montaje del MF.
 */
export interface MFLoaderMountContainerOwnerState {
    isVisible: boolean;
    [key: string]: unknown;
}
/**
 * Local MFLoader slot-style contract used by `MFLoader.styles.ts`.
 * Contrato local de estilos por slot de MFLoader usado por `MFLoader.styles.ts`.
 */
export type MFLoaderStyles = M4LOverridesStyleRules<MFLoaderSlotsType, typeof MF_LOADER_KEY_COMPONENT, Theme>;
/**
 * Generated DOM identifiers for one MF mount instance.
 * Identificadores DOM generados para una instancia de montaje del MF.
 */
export interface MFType {
    /**
     * DOM id for the host container where the MF renders.
     * Id DOM del contenedor del host donde renderiza el MF.
     */
    divContainerId: string;
    /**
     * DOM id for the injected MF script element.
     * Id DOM del elemento script del MF inyectado.
     */
    scriptId: string;
    /**
     * MF module id associated with the generated identifiers.
     * Id del módulo MF asociado a los identificadores generados.
     */
    moduleId: string;
}
/**
 * Vite manifest entry used by the current MF runtime contract.
 * Entrada del manifiesto de Vite usada por el contrato actual de runtime del MF.
 */
export interface MFManifestEntry {
    file: string;
}
/**
 * Manifest shape required by MFLoader to resolve the MF entry chunk.
 * Forma del manifiesto requerida por MFLoader para resolver el chunk de entrada del MF.
 */
export interface MFManifest {
    'src/index.tsx': MFManifestEntry;
}
/**
 * Environment payload forwarded into the MF runtime contract.
 * Payload de entorno reenviado al contrato de runtime del MF.
 */
export interface MFRenderEnvironment extends EnvironmentType {
    isMicroFrontend: true;
    mfProps: {
        moduleId: string;
        debugPort: number;
    };
}
/**
 * Named-object MF render contract used by the preferred `render_v2_*` global.
 * Contrato de render del MF basado en objeto nombrado usado por el global preferido `render_v2_*`.
 */
export interface MFRenderContract {
    containerId: string;
    environment: MFRenderEnvironment;
    hostTools: HostToolsType;
    currentLocale: LocaleType;
    hostTheme: HostThemeType;
    axiosOperation: AxiosOperation;
    formatter: Formatters;
    dynamicMFStore: DynamicMFStore;
    windowTools: WindowToolsMF;
    hostRuntime?: MFHostRuntime;
    emergeType?: EmergeType;
    loggedUser?: AuthUserType;
}
/**
 * MF render function signature for the preferred named-object render contract.
 * Firma de la función de render del MF para el contrato preferido de render basado en objeto nombrado.
 */
export type MFRenderV2Function = (contract: MFRenderContract) => void;
/**
 * Legacy positional render options kept for transitional host/MF compatibility.
 * Opciones legadas de render posicional conservadas para la compatibilidad transicional host/MF.
 */
export interface MFLegacyRenderOptions {
    emergeType?: EmergeType;
    hostRuntime?: MFHostRuntime;
    loggedUser?: AuthUserType;
}
/**
 * Legacy MF render function signature still supported by the host fallback path.
 * Firma legada de función de render del MF que todavía es soportada por la ruta fallback del host.
 */
export type MFRenderV1Function = (containerId: string, environment: MFRenderEnvironment, hostTools: HostToolsType, currentLocale: LocaleType, hostTheme: HostThemeType, axiosOperation: AxiosOperation, formatter: Formatters, dynamicMFStore: DynamicMFStore, windowTools: WindowToolsMF, options: MFLegacyRenderOptions) => void;
/**
 * MF unmount function signature for the host cleanup contract.
 * Firma de la función de desmontaje del MF para el contrato de limpieza del host.
 */
export type MFUnmountFunction = (containerId: string) => void;
/**
 * Build the shared host-side web telemetry context for one MF runtime event.
 * Construye el contexto compartido de telemetría web del lado del host para un evento de runtime del MF.
 */
export type BuildWebTelemetryContext = (moduleId: string, moduleNamespace: string) => FrontendTelemetryContext & {
    moduleId: string;
    moduleNamespace: string;
    runtimeKind: 'web';
    surface: 'host';
};
//# sourceMappingURL=types.d.ts.map