@mks2508/better-logger 2.0.1 → 3.0.0

package/dist/Logger.d.ts

@@ -0,0 +1,851 @@
+import { LogLevel, Verbosity, ThemeVariant, BannerType, LoggerConfig, ILogHandler, StyleOptions, Bindings, SerializerFn, HookEvent, HookCallback, MiddlewareFn, TransportTarget } from './types/index.js';
+import { SerializerRegistry } from './serializers/index.js';
+import { HookManager } from './hooks/index.js';
+import { TransportManager } from './transports/index.js';
+import { ScopedLogger, APILogger, ComponentLogger } from './ScopedLogger.js';
+import { ExportLogHandler } from './handlers/index.js';
+/**
+ * Clase principal Logger con capacidades avanzadas de logging
+ *
+ * @class Logger
+ * @description Sistema completo de logging con temas, badges, contextos y exportación.
+ *              Detecta automáticamente el tema claro/oscuro del navegador.
+ *
+ * @example
+ * // Uso básico sin configuración
+ * import logger from '@mks2508/better-logger';
+ * logger.info('Aplicación iniciada');
+ * logger.success('Conexión establecida');
+ *
+ * @example
+ * // Aplicar un preset temático
+ * logger.preset('cyberpunk');
+ * logger.warn('Advertencia con estilo neón');
+ *
+ * @example
+ * // Logger con scope para componentes
+ * const auth = logger.component('Autenticación');
+ * auth.info('Usuario intentando login');
+ * auth.success('Login exitoso');
+ *
+ * @since 0.3.0
+ */
+export declare class Logger {
+    private config;
+    private scopedPrefix?;
+    private handlers;
+    private timers;
+    private groupDepth;
+    private exportHandler?;
+    private cliProcessor?;
+    private themeChangeListener?;
+    private badgeList;
+    private displaySettings;
+    private serializerRegistry;
+    private hookManager;
+    private transportManager?;
+    /**
+     * Crea una nueva instancia del Logger
+     *
+     * @param {Partial<LoggerConfig>} config - Configuración opcional del logger
+     *
+     * @example
+     * // Logger con configuración personalizada
+     * const logger = new Logger({
+     *   theme: 'neon',
+     *   globalPrefix: 'MiApp',
+     *   verbosity: 'debug',
+     *   bufferSize: 1000
+     * });
+     */
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Configura la detección automática de tema con listener de cambios
+     * @private
+     * @description Detecta automáticamente si el navegador está en modo claro u oscuro
+     */
+    private setupAutoThemeDetection;
+    /**
+     * Obtiene la configuración actual del logger
+     *
+     * @returns {LoggerConfig} Configuración completa actual
+     *
+     * @example
+     * const config = logger.getConfig();
+     * console.log('Verbosidad actual:', config.verbosity);
+     * console.log('Tema actual:', config.theme);
+     *
+     * @since 0.3.0
+     */
+    getConfig(): LoggerConfig;
+    /**
+     * Actualiza la configuración del logger
+     *
+     * @param {Partial<LoggerConfig>} updates - Propiedades a actualizar
+     *
+     * @example
+     * logger.updateConfig({
+     *   verbosity: 'debug',
+     *   enableTimestamps: false,
+     *   theme: 'cyberpunk'
+     * });
+     *
+     * @since 0.3.0
+     */
+    updateConfig(updates: Partial<LoggerConfig>): void;
+    /**
+     * Establece el prefijo global para todos los mensajes de log
+     *
+     * @param {string} prefix - Prefijo a usar
+     *
+     * @example
+     * logger.setGlobalPrefix('MiApp');
+     * logger.info('Iniciado'); // [MiApp] Iniciado
+     *
+     * @since 0.3.0
+     */
+    setGlobalPrefix(prefix: string): void;
+    /**
+     * Establece el nivel de verbosidad para filtrar la salida de logs
+     *
+     * @param {Verbosity} level - Nivel mínimo a mostrar ('debug' | 'info' | 'warn' | 'error' | 'critical' | 'silent')
+     *
+     * @example
+     * logger.setVerbosity('warn');  // Solo muestra warn, error y critical
+     * logger.setVerbosity('debug'); // Muestra todos los niveles
+     * logger.setVerbosity('silent'); // No muestra nada
+     *
+     * @since 0.3.0
+     */
+    setVerbosity(level: Verbosity): void;
+    /**
+     * Establece el tema del logger
+     *
+     * @param {ThemeVariant} theme - Tema a aplicar ('default' | 'dark' | 'light' | 'neon' | 'minimal' | 'cyberpunk')
+     *
+     * @example
+     * logger.setTheme('neon');      // Tema con colores neón
+     * logger.setTheme('minimal');   // Tema minimalista
+     * logger.setTheme('cyberpunk'); // Tema cyberpunk con efectos
+     *
+     * @since 0.3.0
+     */
+    setTheme(theme: ThemeVariant): void;
+    /**
+     * Establece el tipo de banner para mostrar en la inicialización
+     *
+     * @param {BannerType} bannerType - Tipo de banner ('simple' | 'ascii' | 'unicode' | 'svg' | 'animated')
+     *
+     * @example
+     * logger.setBannerType('ascii');    // Banner con arte ASCII
+     * logger.setBannerType('unicode');  // Banner con caracteres Unicode
+     * logger.setBannerType('animated'); // Banner con animación
+     *
+     * @since 0.3.0
+     */
+    setBannerType(bannerType: BannerType): void;
+    /**
+     * Reinicia el logger a la configuración por defecto
+     *
+     * @example
+     * logger.resetConfig();
+     * // Todo vuelve a la configuración inicial
+     *
+     * @since 0.3.0
+     */
+    resetConfig(): void;
+    /**
+     * Método de limpieza para eliminar listeners y liberar recursos
+     *
+     * @example
+     * // Antes de cerrar la aplicación
+     * logger.cleanup();
+     *
+     * @since 0.3.0
+     */
+    cleanup(): void;
+    /**
+     * Aplica un preset inteligente - funciona perfectamente sin configuración
+     *
+     * @param {string} name - Nombre del preset a aplicar
+     *
+     * @example
+     * // Presets disponibles
+     * logger.preset('default');       // Limpio y adaptativo
+     * logger.preset('cyberpunk');     // Colores neón, efectos brillantes
+     * logger.preset('glassmorphism'); // Efectos de blur modernos
+     * logger.preset('minimal');       // Minimalista y elegante
+     * logger.preset('debug');         // Modo desarrollo detallado
+     * logger.preset('production');    // Optimizado para producción
+     *
+     * @since 0.3.0
+     */
+    preset(name: string): void;
+    /**
+     * Lista todos los presets disponibles
+     *
+     * @returns {string[]} Array con nombres de presets disponibles
+     *
+     * @example
+     * const disponibles = logger.presets();
+     * console.log(disponibles); // ['default', 'cyberpunk', 'glassmorphism', ...]
+     *
+     * @since 0.3.0
+     */
+    presets(): string[];
+    /**
+     * Oculta el timestamp en los logs
+     *
+     * @example
+     * logger.hideTimestamp();
+     * logger.info('Sin marca de tiempo'); // Sin timestamp visible
+     *
+     * @since 0.3.0
+     */
+    hideTimestamp(): void;
+    /**
+     * Muestra el timestamp en los logs
+     *
+     * @example
+     * logger.showTimestamp();
+     * logger.info('Con marca de tiempo'); // [2024-01-15 10:30:45] Con marca de tiempo
+     *
+     * @since 0.3.0
+     */
+    showTimestamp(): void;
+    /**
+     * Oculta la información de ubicación (archivo:línea) en los logs
+     *
+     * @example
+     * logger.hideLocation();
+     * logger.debug('Sin ubicación'); // Sin mostrar archivo:línea
+     *
+     * @since 0.3.0
+     */
+    hideLocation(): void;
+    /**
+     * Muestra la información de ubicación (archivo:línea) en los logs
+     *
+     * @example
+     * logger.showLocation();
+     * logger.debug('Con ubicación'); // app.js:42 Con ubicación
+     *
+     * @since 0.3.0
+     */
+    showLocation(): void;
+    /**
+     * Oculta los badges en los logs
+     *
+     * @example
+     * logger.hideBadges();
+     * const api = logger.api('REST');
+     * api.info('Sin badges'); // Sin mostrar [API] [REST]
+     *
+     * @since 0.3.0
+     */
+    hideBadges(): void;
+    /**
+     * Muestra los badges en los logs
+     *
+     * @example
+     * logger.showBadges();
+     * const api = logger.api('GraphQL');
+     * api.info('Con badges'); // [API] [GraphQL] Con badges
+     *
+     * @since 0.3.0
+     */
+    showBadges(): void;
+    /**
+     * Establece múltiples badges para los logs
+     *
+     * @param {string[]} badges - Array de badges a mostrar
+     * @returns {this} Logger instance para encadenamiento
+     *
+     * @example
+     * logger.badges(['v3', 'stable']).info('Release publicado');
+     * logger.badges(['API', 'v2']).warn('Endpoint deprecado');
+     *
+     * @since 3.0.0
+     */
+    badges(badges: string[]): this;
+    /**
+     * Añade un badge individual a la lista
+     *
+     * @param {string} badge - Badge a añadir
+     * @returns {this} Logger instance para encadenamiento
+     *
+     * @example
+     * logger.badge('DEBUG').badge('AUTH').info('Token validado');
+     *
+     * @since 3.0.0
+     */
+    badge(badge: string): this;
+    /**
+     * Limpia todos los badges activos
+     *
+     * @returns {this} Logger instance para encadenamiento
+     *
+     * @example
+     * logger.clearBadges().info('Sin badges');
+     *
+     * @since 3.0.0
+     */
+    clearBadges(): this;
+    component(name: string): ComponentLogger;
+    api(name: string): APILogger;
+    scope(name: string): ScopedLogger;
+    /**
+     * Personalización simple con configuración mínima
+     *
+     * @param {Object} overrides - Opciones de personalización
+     * @param {Object} overrides.message - Configuración del mensaje
+     * @param {Object} overrides.timestamp - Configuración del timestamp
+     * @param {Object} overrides.location - Configuración de ubicación
+     * @param {Object} overrides.level - Configuración del nivel
+     * @param {Object} overrides.prefix - Configuración del prefijo
+     * @param {string} overrides.spacing - Espaciado: 'compact' | 'normal' | 'spacious'
+     *
+     * @example
+     * logger.customize({
+     *   message: { color: '#00ff00', size: '16px' },
+     *   timestamp: { show: false },
+     *   spacing: 'compact'
+     * });
+     *
+     * @since 0.3.0
+     */
+    customize(overrides: {
+        message?: {
+            color?: string;
+            font?: string;
+            size?: string;
+        };
+        timestamp?: {
+            show?: boolean;
+            color?: string;
+        };
+        location?: {
+            show?: boolean;
+            color?: string;
+        };
+        level?: {
+            uppercase?: boolean;
+            style?: string;
+        };
+        prefix?: {
+            show?: boolean;
+            style?: string;
+        };
+        spacing?: 'compact' | 'normal' | 'spacious';
+    }): void;
+    /**
+     * Access advanced styling API (for power users)
+     */
+    styles(): any;
+    /**
+     * Añade un handler personalizado para extender funcionalidad
+     *
+     * @param {ILogHandler} handler - Handler que implementa ILogHandler
+     *
+     * @example
+     * // Handler personalizado para enviar logs a servidor
+     * const remoteHandler = new RemoteLogHandler('https://api.ejemplo.com/logs');
+     * logger.addHandler(remoteHandler);
+     *
+     * @example
+     * // Handler para guardar en archivo
+     * const fileHandler = new FileLogHandler('./app.log');
+     * logger.addHandler(fileHandler);
+     *
+     * @since 0.3.0
+     */
+    addHandler(handler: ILogHandler): void;
+    /**
+     * Obtiene todos los handlers registrados
+     *
+     * @returns {ILogHandler[]} Array de handlers activos
+     * @since 0.3.0
+     */
+    getHandlers(): ILogHandler[];
+    /**
+     * Obtiene el handler de exportación si está disponible
+     *
+     * @returns {ExportLogHandler | undefined} Handler de exportación o undefined
+     * @since 0.3.0
+     */
+    getExportHandler(): ExportLogHandler | undefined;
+    /**
+     * Añade un serializador personalizado para un tipo específico
+     *
+     * @param type - Constructor del tipo a serializar
+     * @param serializer - Función de serialización
+     * @param priority - Prioridad (mayor = primero)
+     *
+     * @example
+     * logger.addSerializer(Error, (err) => ({
+     *   name: err.name,
+     *   message: err.message,
+     *   stack: err.stack?.split('\n').slice(0, 5)
+     * }));
+     *
+     * @since 3.0.0
+     */
+    addSerializer<T>(type: new (...args: any[]) => T, serializer: SerializerFn<T>, priority?: number): void;
+    /**
+     * Elimina un serializador registrado
+     *
+     * @param type - Constructor del tipo a remover
+     * @returns true si se eliminó
+     *
+     * @since 3.0.0
+     */
+    removeSerializer<T>(type: new (...args: any[]) => T): boolean;
+    /**
+     * Obtiene el registry de serializadores
+     *
+     * @returns SerializerRegistry
+     * @since 3.0.0
+     */
+    getSerializerRegistry(): SerializerRegistry;
+    /**
+     * Registra un hook para un evento
+     *
+     * @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+     * @param callback - Función a ejecutar
+     * @param priority - Prioridad (mayor = primero)
+     * @returns Función para desregistrar
+     *
+     * @example
+     * const unsubscribe = logger.on('beforeLog', (entry) => {
+     *   entry.correlationId = getCorrelationId();
+     *   return entry;
+     * });
+     *
+     * @since 3.0.0
+     */
+    on(event: HookEvent, callback: HookCallback, priority?: number): () => void;
+    /**
+     * Registra un hook que se ejecuta solo una vez
+     *
+     * @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+     * @param callback - Función a ejecutar
+     * @param priority - Prioridad (mayor = primero)
+     * @returns Función para desregistrar
+     *
+     * @since 3.0.0
+     */
+    once(event: HookEvent, callback: HookCallback, priority?: number): () => void;
+    /**
+     * Elimina un hook registrado
+     *
+     * @param event - Evento del hook
+     * @param callback - Callback a remover
+     * @returns true si se eliminó
+     *
+     * @since 3.0.0
+     */
+    off(event: HookEvent, callback: HookCallback): boolean;
+    /**
+     * Añade un middleware al pipeline
+     *
+     * @param middleware - Función middleware
+     * @param priority - Prioridad (mayor = primero)
+     * @returns Función para desregistrar
+     *
+     * @example
+     * logger.use((entry, next) => {
+     *   entry.requestId = asyncLocalStorage.getStore()?.requestId;
+     *   next();
+     * });
+     *
+     * @since 3.0.0
+     */
+    use(middleware: MiddlewareFn, priority?: number): () => void;
+    /**
+     * Obtiene el HookManager
+     *
+     * @returns HookManager
+     * @since 3.0.0
+     */
+    getHookManager(): HookManager;
+    /**
+     * Añade un transport para envío de logs
+     *
+     * @param target - Configuración del transport
+     * @returns ID único del transport
+     *
+     * @example
+     * // File transport
+     * logger.addTransport({
+     *   target: 'file',
+     *   options: { destination: '/var/log/app.log' }
+     * });
+     *
+     * @example
+     * // HTTP transport con batching
+     * logger.addTransport({
+     *   target: 'http',
+     *   options: {
+     *     url: 'https://logs.example.com',
+     *     batchSize: 100,
+     *     flushInterval: 5000
+     *   },
+     *   level: 'warn'
+     * });
+     *
+     * @since 3.0.0
+     */
+    addTransport(target: TransportTarget): string;
+    /**
+     * Elimina un transport
+     *
+     * @param id - ID del transport a remover
+     * @returns true si se eliminó
+     *
+     * @since 3.0.0
+     */
+    removeTransport(id: string): boolean;
+    /**
+     * Fuerza el flush de todos los transports
+     *
+     * @returns Promise que resuelve cuando todos los buffers están vaciados
+     *
+     * @since 3.0.0
+     */
+    flushTransports(): Promise<void>;
+    /**
+     * Cierra todos los transports
+     *
+     * @returns Promise que resuelve cuando todos están cerrados
+     *
+     * @since 3.0.0
+     */
+    closeTransports(): Promise<void>;
+    /**
+     * Obtiene el TransportManager
+     *
+     * @returns TransportManager o undefined si no hay transports
+     * @since 3.0.0
+     */
+    getTransportManager(): TransportManager | undefined;
+    /**
+     * Verifica si un nivel de log debe mostrarse según la verbosidad actual
+     * @private
+     * @param {LogLevel} level - Nivel de log a verificar
+     * @returns {boolean} True si debe mostrarse, false si no
+     */
+    private shouldLog;
+    /**
+     * Obtiene el prefijo efectivo (global + scope)
+     * @private
+     * @returns {string | undefined} Prefijo combinado o undefined
+     */
+    private getEffectivePrefix;
+    /**
+     * Método central de logging que maneja estilos y formato
+     * @protected
+     * @param {LogLevel} level - Nivel del log
+     * @param {...any} args - Argumentos a loggear
+     */
+    protected log(level: LogLevel, ...args: any[]): void;
+    logWithBindings(bindings: Bindings, level: LogLevel, ...args: any[]): void;
+    debug(...args: any[]): void;
+    /**
+     * Registra mensajes informativos
+     *
+     * @param {...any} args - Mensajes y datos informativos
+     *
+     * @example
+     * logger.info('Servidor iniciado en puerto 3000');
+     * logger.info('Usuario conectado:', userId);
+     * logger.info('Procesando', totalItems, 'elementos');
+     *
+     * @since 0.3.0
+     */
+    info(...args: any[]): void;
+    /**
+     * Registra mensajes de advertencia
+     *
+     * @param {...any} args - Mensajes de advertencia
+     *
+     * @example
+     * logger.warn('Memoria al 85% de capacidad');
+     * logger.warn('API deprecada, usar v2');
+     * logger.warn('Reintentos agotados:', maxRetries);
+     *
+     * @since 0.3.0
+     */
+    warn(...args: any[]): void;
+    /**
+     * Registra mensajes de error
+     *
+     * @param {...any} args - Mensajes de error y stack traces
+     *
+     * @example
+     * logger.error('Fallo en conexión a base de datos');
+     * logger.error('Error al procesar:', error.message, error.stack);
+     * logger.error('Código de error:', errorCode);
+     *
+     * @since 0.3.0
+     */
+    error(...args: any[]): void;
+    /**
+     * Registra mensajes de éxito (nivel info especial)
+     *
+     * @param {...any} args - Mensajes de operaciones exitosas
+     *
+     * @example
+     * logger.success('Base de datos conectada');
+     * logger.success('Usuario creado con ID:', userId);
+     * logger.success('✓ Tests pasados: 42/42');
+     *
+     * @since 0.3.0
+     */
+    success(...args: any[]): void;
+    /**
+     * Registra información de trace (debugging detallado)
+     *
+     * @param {...any} args - Datos detallados para debugging
+     *
+     * @example
+     * logger.trace('Entrando en función processData');
+     * logger.trace('Stack completo:', new Error().stack);
+     *
+     * @since 0.3.0
+     */
+    trace(...args: any[]): void;
+    /**
+     * Registra errores críticos (prioridad más alta)
+     *
+     * @param {...any} args - Errores críticos del sistema
+     *
+     * @example
+     * logger.critical('Sistema caído - reinicio inmediato requerido');
+     * logger.critical('Pérdida de datos detectada');
+     * logger.critical('Brecha de seguridad:', securityError);
+     *
+     * @since 0.3.0
+     */
+    critical(...args: any[]): void;
+    /**
+     * Muestra datos en formato de tabla
+     *
+     * @param {any} data - Datos a mostrar (array de objetos o matriz)
+     * @param {string[]} columns - Columnas específicas a mostrar (opcional)
+     *
+     * @example
+     * const usuarios = [
+     *   { id: 1, nombre: 'Juan', edad: 30 },
+     *   { id: 2, nombre: 'María', edad: 25 }
+     * ];
+     * logger.table(usuarios);
+     * logger.table(usuarios, ['nombre', 'edad']); // Solo estas columnas
+     *
+     * @since 0.3.0
+     */
+    table(data: any, columns?: string[]): void;
+    /**
+     * Inicia un grupo colapsable en la consola
+     *
+     * @param {string} label - Etiqueta del grupo
+     * @param {boolean} collapsed - Si el grupo inicia colapsado (default: false)
+     *
+     * @example
+     * logger.group('Procesando usuarios');
+     * logger.info('Usuario 1 procesado');
+     * logger.info('Usuario 2 procesado');
+     * logger.groupEnd();
+     *
+     * @example
+     * // Grupo colapsado por defecto
+     * logger.group('Detalles adicionales', true);
+     * logger.debug('Información detallada aquí');
+     * logger.groupEnd();
+     *
+     * @since 0.3.0
+     */
+    group(label: string, collapsed?: boolean): void;
+    /**
+     * Finaliza el grupo actual de la consola
+     *
+     * @example
+     * logger.group('Operaciones');
+     * logger.info('Operación 1');
+     * logger.info('Operación 2');
+     * logger.groupEnd(); // Cierra el grupo
+     *
+     * @since 0.3.0
+     */
+    groupEnd(): void;
+    /**
+     * Inicia un temporizador con la etiqueta dada
+     *
+     * @param {string} label - Etiqueta identificadora del temporizador
+     *
+     * @example
+     * logger.time('proceso-datos');
+     * // ... operación costosa ...
+     * logger.timeEnd('proceso-datos'); // ⏱️ Timer ended: proceso-datos - 1523.45ms
+     *
+     * @since 0.3.0
+     */
+    time(label: string): void;
+    /**
+     * Finaliza un temporizador y muestra el tiempo transcurrido
+     *
+     * @param {string} label - Etiqueta del temporizador a finalizar
+     *
+     * @example
+     * logger.time('consulta-db');
+     * await consultarBaseDatos();
+     * logger.timeEnd('consulta-db'); // ⏱️ Timer ended: consulta-db - 234.56ms
+     *
+     * @since 0.3.0
+     */
+    timeEnd(label: string): void;
+    /**
+     * Muestra un banner con el tipo especificado o configurado
+     *
+     * @param {BannerType} bannerType - Tipo de banner (opcional)
+     *
+     * @example
+     * logger.showBanner('ascii');    // Banner ASCII art
+     * logger.showBanner('unicode');  // Banner con caracteres Unicode
+     * logger.showBanner('svg');      // Banner con gráfico SVG
+     * logger.showBanner();           // Usa el tipo configurado
+     *
+     * @since 0.3.0
+     */
+    showBanner(bannerType?: BannerType): void;
+    /**
+     * Registra mensaje con imagen SVG de fondo
+     *
+     * @param {string} message - Mensaje a mostrar
+     * @param {string} svgContent - Contenido SVG personalizado (opcional)
+     * @param {StyleOptions} options - Opciones de estilo (ancho, alto, padding)
+     *
+     * @example
+     * // SVG automático con gradiente
+     * logger.logWithSVG('🎆 Bienvenido a Better Logger');
+     *
+     * @example
+     * // SVG personalizado
+     * const customSVG = '<svg>...</svg>';
+     * logger.logWithSVG('Logo', customSVG, { width: 400, height: 100 });
+     *
+     * @since 0.3.0
+     */
+    logWithSVG(message: string, svgContent?: string, options?: StyleOptions): void;
+    /**
+     * Registra mensaje con gradiente animado de fondo
+     *
+     * @param {string} message - Mensaje a animar
+     * @param {number} duration - Duración de la animación en segundos (default: 3)
+     *
+     * @example
+     * logger.logAnimated('🌈 Animación en progreso');
+     * logger.logAnimated('Cargando...', 5); // Animación de 5 segundos
+     *
+     * @since 0.3.0
+     */
+    logAnimated(message: string, duration?: number): void;
+    /**
+     * Agrupa logs por una propiedad específica usando Object.groupBy (cuando esté disponible)
+     *
+     * @param {T[]} items - Array de elementos a agrupar
+     * @param {Function} groupBy - Función que retorna la clave de agrupación
+     *
+     * @example
+     * const ventas = [
+     *   { producto: 'Laptop', categoria: 'Electrónica', precio: 1200 },
+     *   { producto: 'Mouse', categoria: 'Electrónica', precio: 25 },
+     *   { producto: 'Libro', categoria: 'Literatura', precio: 15 }
+     * ];
+     * logger.logGrouped(ventas, item => item.categoria);
+     *
+     * @since 0.3.0
+     */
+    logGrouped<T>(items: T[], groupBy: (item: T) => string): void;
+    /**
+     * Procesador de comandos CLI para configuración y exportación del logger
+     *
+     * @param {string} command - Comando CLI a ejecutar
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Comandos disponibles
+     * await logger.cli('export json');      // Exporta logs en JSON
+     * await logger.cli('export csv');       // Exporta logs en CSV
+     * await logger.cli('theme list');       // Lista temas disponibles
+     * await logger.cli('theme set neon');   // Cambia al tema neon
+     * await logger.cli('config show');      // Muestra configuración actual
+     * await logger.cli('history clear');    // Limpia historial de logs
+     * await logger.cli('status');           // Muestra estado del logger
+     * await logger.cli('help');             // Muestra ayuda de comandos
+     *
+     * @since 0.3.0
+     */
+    cli(command: string): Promise<void>;
+}
+declare const _default: Logger;
+export default _default;
+/**
+ * Métodos individuales exportados para conveniencia
+ * @description Todos los métodos están correctamente enlazados al singleton lazy
+ * @since 0.3.0
+ */
+export declare const debug: (...args: any[]) => void;
+export declare const info: (...args: any[]) => void;
+export declare const warn: (...args: any[]) => void;
+export declare const error: (...args: any[]) => void;
+export declare const success: (...args: any[]) => void;
+export declare const trace: (...args: any[]) => void;
+export declare const critical: (...args: any[]) => void;
+export declare const table: (data: any, columns?: string[]) => void;
+export declare const group: (label: string, collapsed?: boolean) => void;
+export declare const groupEnd: () => void;
+export declare const time: (label: string) => void;
+export declare const timeEnd: (label: string) => void;
+export declare const setGlobalPrefix: (prefix: string) => void;
+export declare const setVerbosity: (level: Verbosity) => void;
+export declare const addHandler: (handler: ILogHandler) => void;
+export declare const setTheme: (theme: ThemeVariant) => void;
+export declare const setBannerType: (bannerType: BannerType) => void;
+export declare const showBanner: (bannerType?: BannerType) => void;
+export declare const logWithSVG: (message: string, svgContent?: string, options?: StyleOptions) => void;
+export declare const logAnimated: (message: string, duration?: number) => void;
+export declare const cli: (command: string) => Promise<void>;
+export declare const cleanup: () => void;
+export declare const preset: (name: string) => void;
+export declare const presets: () => string[];
+export declare const hideTimestamp: () => void;
+export declare const showTimestamp: () => void;
+export declare const hideLocation: () => void;
+export declare const showLocation: () => void;
+export declare const hideBadges: () => void;
+export declare const showBadges: () => void;
+export declare const badges: (badgeList: string[]) => Logger;
+export declare const badge: (badgeName: string) => Logger;
+export declare const clearBadges: () => Logger;
+export declare const component: (name: string) => ComponentLogger;
+export declare const api: (name: string) => APILogger;
+export declare const scope: (name: string) => ScopedLogger;
+export declare const customize: (overrides: any) => void;
+export declare const styles: () => any;
+export declare const addSerializer: <T>(type: new (...args: any[]) => T, serializer: SerializerFn<T>, priority?: number) => void;
+export declare const removeSerializer: <T>(type: new (...args: any[]) => T) => boolean;
+export declare const on: (event: HookEvent, callback: HookCallback, priority?: number) => () => void;
+export declare const once: (event: HookEvent, callback: HookCallback, priority?: number) => () => void;
+export declare const off: (event: HookEvent, callback: HookCallback) => boolean;
+export declare const use: (middleware: MiddlewareFn, priority?: number) => () => void;
+export declare const addTransport: (target: TransportTarget) => string;
+export declare const removeTransport: (id: string) => boolean;
+export declare const flushTransports: () => Promise<void>;
+export declare const closeTransports: () => Promise<void>;
+export { FileLogHandler, RemoteLogHandler, AnalyticsLogHandler, ExportLogHandler } from './handlers/index.js';
+export { StyleBuilder, StylePresets as Styles } from './styling/index.js';
+export { SerializerRegistry } from './serializers/index.js';
+export { HookManager } from './hooks/index.js';
+export { TransportManager, ConsoleTransport, FileTransport, HttpTransport } from './transports/index.js';
+export { StyleCache, getStyleCache } from './styling/StyleCache.js';
+//# sourceMappingURL=Logger.d.ts.map