/**
 * Niveles de severidad de registro estructurado disponibles.
 */
type LogLevel = 'info' | 'warn' | 'error' | 'debug';
/**
 * Niveles de seguridad dinámica (Security Tiers) del sistema operativo Decido OS.
 * Define la severidad de las políticas de auditoría, encriptación y redacción de PII.
 * - 0: Open
 * - 1: Standard
 * - 2: Hardened
 * - 3: Certified
 */
type SecurityTier = 0 | 1 | 2 | 3;
/**
 * Clasificación de la acción o tipo de operación que se está registrando.
 * Ayuda en el modelado de amenazas y cumplimiento de auditorías.
 */
type ActionClass = 'read' | 'write' | 'destructive' | 'auth' | 'config';
/**
 * Contexto de seguridad adjunto a cada registro de telemetría y sensores.
 */
interface SecurityContext {
    /** Nivel o Tier de seguridad activo en el momento del registro. */
    tier: SecurityTier;
    /** Identificador de riesgo según la matriz de seguridad de Decido OS (R01-R12). */
    riskId?: string;
    /** Puntuación de riesgo calculada (Probabilidad × Impacto). */
    riskScore?: number;
    /** Flag que indica si el payload del registro contiene información de identificación personal (PII). */
    piiPresent?: boolean;
    /** Categoría de la acción del flujo de ejecución del registro. */
    actionClass?: ActionClass;
}
/**
 * Contexto operativo y de localización para el rastreo y telemetría de eventos.
 */
interface OperationalContext {
    /** Paquete o módulo emisor (ej: 'intent-engine', 'nerve-map', 'logger'). */
    module: string;
    /** Subcomponente específico que emite el evento (ej: 'registry', 'voice', 'ai'). */
    component: string;
    /** Ámbito de la aplicación de alto nivel (ej: 'nerve-flow', 'multi-device'). */
    scope?: string;
    /** Identificador único de correlación (UUID) útil para el rastreo y tracing distribuido. */
    correlationId?: string;
    /** Identificador del usuario que originó la acción (Requerido en Tier 2+). */
    userId?: string;
}
/**
 * Contexto de telemetría de rendimiento y consumo de recursos.
 */
interface PerfContext {
    /** Tiempo de duración o ejecución en milisegundos. */
    durationMs?: number;
    /** Cantidad de memoria heap utilizada en bytes. */
    heapUsed?: number;
}
/**
 * Representación estructurada unificada de una entrada de registro en Decido OS.
 */
interface CoreLogEntry {
    /** Severidad del evento registrado. */
    level: LogLevel;
    /** Timestamp formateado con milisegundos (HH:MM:SS.mmm). */
    timestamp: string;
    /** Categorías lógicas del evento (extraídas del mensaje entre corchetes). */
    categories: string[];
    /** Mensaje de texto principal del log, limpio de categorías. */
    message: string;
    /** Payload de metadatos o detalles opcionales del evento. */
    data?: unknown;
    /** Información física del archivo y línea que emitió la llamada. */
    source?: {
        fileName: string;
        line: string;
    };
    /** Enlace o URI para abrir el archivo directamente en el editor del IDE. */
    sourceLink?: string;
    /** Contexto y políticas de seguridad aplicadas. */
    security?: SecurityContext;
    /** Metadatos operativos de localización y correlation ID. */
    context?: OperationalContext;
    /** Datos de rendimiento de la operación. */
    perf?: PerfContext;
}
/**
 * Configuración estructural y visual del formateador de consola del Logger.
 */
interface CoreLogConfig {
    /** Mapa de colores asignados a categorías específicas para la salida en consola. */
    categoryColors: Record<string, string>;
    /** Estilos CSS para cada uno de los niveles de log en el navegador. */
    levelColors: Record<string, string>;
    /** Ancho máximo permitido para la sección de categorías del log en consola. */
    maxCategoryWidth: number;
    /** Símbolo indicador que acompaña logs con payload de datos. */
    dataIndicator: string;
    /** Caracteres de elipsis para recortar textos excesivamente largos. */
    ellipsis: string;
    /** Símbolo de separación previo al payload de datos. */
    dataSeparator: string;
    /** Estilo visual para el separador de datos. */
    dataSeparatorStyle: string;
    /** Flag para habilitar la visualización por defecto de payloads en el servidor. */
    defaultVerbose?: boolean;
    /** Lista de categorías configuradas con verbosidad activa. */
    verboseCategories?: string[];
    /** Categorías excluidas que no se imprimirán en consola. */
    excludedCategories?: string[];
}
/**
 * Especificación de políticas dinámicas y restricciones de seguridad aplicables por Tier.
 */
interface LoggerPolicy {
    /** Nivel mínimo de severidad requerido para emitir un log. */
    minLevel: LogLevel;
    /** Habilitar el almacenamiento local o persistencia de los registros en buffer. */
    persist: boolean;
    /** Límite máximo de registros a almacenar en el búfer circular de persistencia. */
    persistMax?: number;
    /** Habilitar la redacción profunda de información sensible (PII). */
    redactPII: boolean;
    /** Tasa de muestreo (sampling rate entre 0.0 y 1.0) para registros debug. */
    sampling: number;
    /** Tiempo mínimo en milisegundos requerido entre emisiones de un mismo sensor (throttling). */
    probeThrottleMs: number;
    /** Habilitar el cifrado simétrico en el búfer circular utilizando Web Crypto API. */
    encryptStorage?: boolean;
    /** Exigir obligatoriamente un userId en toda entrada de registro emitida. */
    requireUserId?: boolean;
    /** Impedir mutabilidad de logs e inyección de payloads ilegítimos (Compliance). */
    immutableLog?: boolean;
}
/**
 * Políticas predefinidas asociadas a cada nivel de seguridad de Decido OS.
 */
declare const TIER_POLICIES: Record<SecurityTier, LoggerPolicy>;

/**
 * Firma de función suscriptora para los callbacks del Event Mesh.
 */
type LogSubscriber = (entry: CoreLogEntry) => void;
/**
 * Suscribe un callback reactivo al flujo de todos los registros emitidos en Decido OS.
 * Útil para la instrumentación en tiempo real y dashboards de telemetría.
 *
 * @param cb - Función callback que recibe la entrada estructurada `CoreLogEntry`.
 * @returns Función de limpieza (unsubscribe) para liberar la suscripción y evitar fugas de memoria.
 *
 * @example
 * ```typescript
 * const unsubscribe = subscribeToLogs((entry) => {
 *   console.log("Log capturado reactivamente:", entry.message);
 * });
 * // Para desuscribirse:
 * unsubscribe();
 * ```
 */
declare const subscribeToLogs: (cb: LogSubscriber) => () => void;
/**
 * Vacía y limpia por completo todas las suscripciones activas del flujo de logs.
 * Esencial para el desmontaje de suites de testing unitario y recargas en caliente HMR.
 */
declare const clearAllLogsSubscribers: () => void;
/**
 * Logger estructurado centralizado isomórfico para Decido OS y sus componentes.
 */
declare const logger: {
    /**
     * Permite suscribir escuchas reactivas al flujo global de registros.
     */
    subscribe: (cb: LogSubscriber) => () => void;
    /**
     * Limpia y remueve todos los suscriptores activos para liberar memoria.
     */
    clearAllSubscribers: () => void;
    /**
     * Configura y actualiza dinámicamente la lista de categorías silenciadas o excluidas.
     *
     * @param categories - Colección de nombres de categorías que no deben emitirse en consola.
     */
    setExcludedCategories: (categories: string[]) => void;
    /**
     * Emite un registro estructurado con el nivel de severidad y mensaje especificado.
     * Realiza extracción de categorías del mensaje, inyecta el origen (caller stack trace),
     * notifica a los suscriptores y formatea de manera isomorfa según el entorno (Navegador o Node.js).
     *
     * @param level - Nivel de severidad de registro estructurado.
     * @param message - Mensaje descriptivo (puede incluir prefijos de categoría como `[UI]`).
     * @param data - Payload opcional de metadatos o variables a registrar.
     */
    log: (level: LogLevel, message: string, data?: unknown) => void;
    /**
     * Emite un registro estructurado con nivel de severidad 'debug'.
     */
    debug: (message: string, data?: unknown) => void;
    /**
     * Emite un registro estructurado con nivel de severidad 'info'.
     */
    info: (message: string, data?: unknown) => void;
    /**
     * Emite un registro estructurado con nivel de severidad 'warn'.
     */
    warn: (message: string, data?: unknown) => void;
    /**
     * Emite un registro estructurado con nivel de severidad 'error'.
     */
    error: (message: string, data?: unknown) => void;
};

/**
 * Extrae categorías del mensaje formateado en el formato: `[Category1] [Category2] Message`.
 *
 * @param message - El mensaje de texto crudo provisto por el usuario.
 * @returns Un objeto que contiene un arreglo con las categorías extraídas y el mensaje limpio.
 *
 * @example
 * ```typescript
 * extractCategories("[UI] [Event] Clicked button");
 * // Devuelve: { categories: ["UI", "Event"], cleanMessage: "Clicked button" }
 * ```
 */
declare const extractCategories: (message: string) => {
    categories: string[];
    cleanMessage: string;
};
/**
 * Obtiene el color visual en formato hexadecimal para una categoría específica.
 * Si no está registrada en el archivo de configuración, devuelve el color predeterminado.
 *
 * @param category - Nombre de la categoría de log.
 * @param config - Objeto de configuración de colores visuales.
 * @returns Código de color CSS hexadecimal.
 */
declare const getCategoryColor: (category: string, config: CoreLogConfig) => string;
/**
 * Obtiene el timestamp local del sistema formateado con precisión de milisegundos (HH:MM:SS.mmm).
 *
 * @returns String que representa la hora local formateada.
 */
declare const getTimestamp: () => string;
/**
 * Recorta un texto dado a una longitud máxima permitida, agregando puntos suspensivos al final.
 *
 * @param text - Texto original a truncar.
 * @param maxLength - Longitud máxima permitida de caracteres.
 * @param ellipsis - Caracteres de elipsis a usar (por defecto: '...').
 * @returns El texto recortado o el original si mide menos que la longitud máxima.
 */
declare const truncateText: (text: string, maxLength: number, ellipsis?: string) => string;
/**
 * Analiza el stack trace de forma dinámica para obtener la localización física (archivo y línea)
 * que originó la llamada de registro, omitiendo de forma inteligente la infraestructura interna del logger.
 *
 * @returns Objeto con fileName (nombre de archivo), filePath (ruta del archivo) y line (número de línea).
 */
declare const getCallerInfo: () => {
    fileName: string;
    filePath: string;
    line: string;
};
/**
 * Formatea una entrada estructurada de registro para su salida visual estilizada en la consola del navegador.
 *
 * @param entry - Entrada de registro estructurada (`CoreLogEntry`).
 * @param config - Configuración visual y estructural (`CoreLogConfig`).
 * @returns Una tupla con dos arreglos de argumentos: [argumentos_cabecera_grupo, argumentos_contenido_grupo].
 */
declare const formatLogForBrowserConsole: (entry: CoreLogEntry, config: CoreLogConfig) => [unknown[], unknown[]];
/**
 * Formatea una entrada estructurada de registro para su salida de texto plano en la terminal de Node.js o servidores.
 *
 * @param entry - Entrada de registro estructurada (`CoreLogEntry`).
 * @param config - Configuración visual y de verbosidad (`CoreLogConfig`).
 * @returns Arreglo con el mensaje de texto formateado y el payload de datos opcional para pasar a `console.log`.
 */
declare const formatLogForServerConsole: (entry: CoreLogEntry, config: CoreLogConfig) => ({} | null)[];
declare const formatData: (data: unknown) => unknown;

/**
 * Niveles de severidad de registro disponibles para telemetría.
 */
type ProbeLevel = 'info' | 'warn' | 'error' | 'debug';
/**
 * Opciones de enriquecimiento para sensores de telemetría.
 */
interface ProbeOptions {
    /** Nivel de severidad del registro (por defecto: 'info'). */
    level?: ProbeLevel;
    /** Duración en milisegundos del proceso medido. */
    durationMs?: number;
    /** Parámetros específicos del contexto de seguridad. */
    security?: Partial<SecurityContext>;
    /** Metadatos específicos del contexto operativo. */
    context?: Partial<OperationalContext>;
}
/**
 * Actualiza dinámicamente el Tier de seguridad de Decido OS y aplica las políticas de log asociadas.
 *
 * @param tier - Nivel de seguridad a activar (0 | 1 | 2 | 3).
 */
declare function setSecurityTier(tier: SecurityTier): void;
/**
 * Obtiene el Tier de seguridad actualmente activo.
 *
 * @returns El nivel activo (0 a 3).
 */
declare function getSecurityTier(): SecurityTier;
/**
 * Obtiene la política de registro estructurado activa en el sistema.
 *
 * @returns Política activa (`LoggerPolicy`).
 */
declare function getActivePolicy(): LoggerPolicy;
/**
 * Genera y establece un nuevo identificador único de correlación (Correlation ID).
 *
 * @returns El nuevo ID generado.
 */
declare function resetCorrelationId(): string;
/**
 * Obtiene el identificador de correlación activo para trazabilidad.
 *
 * @returns El identificador actual.
 */
declare function getCorrelationId(): string;
/**
 * Emite una lectura o medición estructurada de telemetría a través del sistema de sensores (Probes).
 * Respeta de forma rígida el Tier de seguridad, límites de throttling, muestreos y saneamiento de PII.
 *
 * @param sensorId - Identificador descriptivo del sensor bajo prueba.
 * @param data - Payload de metadatos o estado a emitir.
 * @param opts - Opciones de contexto operativo y de rendimiento.
 */
declare function probe(sensorId: string, data?: unknown, opts?: ProbeOptions): void;
/**
 * Inicia una medición temporal de telemetría.
 *
 * @param sensorId - Identificador del sensor.
 * @param opts - Opciones de enriquecimiento operativo y de seguridad.
 * @returns Una función callback que debe invocarse al finalizar la operación a medir.
 *
 * @example
 * ```typescript
 * const end = probeStart("proceso_pesado");
 * // ... hacer procesamiento ...
 * end({ status: "success" }); // Emite automáticamente el registro con durationMs
 * ```
 */
declare function probeStart(sensorId: string, opts?: Omit<ProbeOptions, 'durationMs'>): (data?: unknown) => void;

/**
 * Determina si una entrada estructurada de registro pertenece a una medición de telemetría de sensor.
 */
declare function isSensorEntry(entry: CoreLogEntry): boolean;
/**
 * Obtiene el identificador del sensor (`sensorId`) a partir de un registro estructurado.
 */
declare function getSensorId(entry: CoreLogEntry): string | null;

export { type ActionClass, type CoreLogConfig, type CoreLogEntry, type LogLevel, type LoggerPolicy, type OperationalContext, type PerfContext, type ProbeLevel, type ProbeOptions, type SecurityContext, type SecurityTier, TIER_POLICIES, clearAllLogsSubscribers, extractCategories, formatData, formatLogForBrowserConsole, formatLogForServerConsole, getActivePolicy, getCallerInfo, getCategoryColor, getCorrelationId, getSecurityTier, getSensorId, getTimestamp, isSensorEntry, logger, probe, probeStart, resetCorrelationId, setSecurityTier, subscribeToLogs, truncateText };