import { LoggingConfig } from './configs';
export declare enum LogLevel {
    TRACE = "trace",
    DEBUG = "debug",
    INFO = "info",
    WARN = "warn",
    ERROR = "error",
    FATAL = "fatal"
}
export interface LogContext {
    module: string;
    component?: string;
    tags?: string[];
    [key: string]: any;
}
export declare function withTags<T extends object = {}>(tags: string[], data?: T): T & {
    tags: string[];
};
export declare class Logger {
    private static instance;
    private static patterns;
    private static contextLoggers;
    private logger;
    private currentOptions;
    private currentLevel;
    private runtime;
    private bindings?;
    private constructor();
    private parseDebugPatterns;
    private getEffectiveLevel;
    /**
     * Create a logger with additional context that will be included in all log messages
     * @param bindings Contextual information like module name, component, tags
     * @returns A new Logger instance with the specified context
     * @example
     * const memoryLogger = logger.withContext({ module: 'memory' });
     * const authLogger = logger.withContext({ module: 'auth', tags: ['security'] });
     */
    withContext(bindings: LogContext): Logger;
    private createLogger;
    static getInstance(): Logger;
    setDestination(config?: LoggingConfig): void;
    setLevel(level: LogLevel): void;
    getLevel(): LogLevel;
    private formatArgs;
    private formatMessage;
    private parseLogLevel;
    static parseLogLevel(level: string): LogLevel;
    private formatErrorMessage;
    private log;
    debug(message: string, ...args: any[]): void;
    info(message: string, ...args: any[]): void;
    warning(message: string, ...args: any[]): void;
    warn(message: string, ...args: any[]): void;
    error(message: string, ...args: any[]): void;
    trace(message: string, ...args: any[]): void;
    fatal(message: string, ...args: any[]): void;
}
export declare class LoggerFactory {
    private static loggers;
    static getLogger(context: LogContext): Logger;
    private static getLoggerKey;
}
export declare const logger: Logger;
export declare function trace(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;