import { Logger } from "./Logger";
import { LogLevel, LogSettings } from "./LogSettings";
/**
 * @class
 * Singleton manager for all logger instances in the application.
 * Provides methods to register, retrieve, and configure loggers.
 */
export declare class LogManager {
    /** The singleton instance of LogManager */
    private static _instance;
    /** Map of logger names to logger instances */
    private _loggers;
    private _allLoggers;
    private _logLevel;
    private _logSettings;
    private _logConfiguration;
    /**
     * Private constructor to prevent direct instantiation.
     * Use getInstance() instead.
     */
    private constructor();
    get logSettings(): LogSettings;
    get logLevel(): LogLevel;
    set logSettings(value: LogSettings);
    /**
     * Gets the singleton instance of LogManager.
     * Creates the instance if it doesn't exist yet.
     *
     * @returns {LogManager} The singleton LogManager instance
     *
     * @example
     * const logManager = LogManager.getInstance();
     */
    static getInstance(): LogManager;
    /**
     * Registers a logger with the manager.
     *
     * @param {string} name - The name to identify the logger
     * @param {Logger} logger - The logger instance to register
     *
     * @example
     * const userLogger = new Logger({ source: 'UserService' });
     * LogManager.getInstance().registerLogger('UserService', userLogger);
     */
    registerLogger(name: string, logger: Logger): void;
    /**
     * Retrieves a logger by name.
     *
     * @param {string} name - The name of the logger to retrieve
     * @returns {Logger | undefined} The logger instance if found, undefined otherwise
     *
     * @example
     * const userLogger = LogManager.getInstance().getLogger('UserService');
     * if (userLogger) {
     *     userLogger.info('User service initialized');
     * }
     */
    getLogger(name: string): Logger | undefined;
    /**
     * Checks if a logger with the given name exists.
     *
     * @param {string} name - The name of the logger to check
     * @returns {boolean} True if the logger exists, false otherwise
     *
     * @example
     * if (LogManager.getInstance().hasLogger('UserService')) {
     *     // Use existing logger
     * } else {
     *     // Create new logger
     * }
     */
    hasLogger(name: string): boolean;
    /**
     * Sets the log level for all registered loggers.
     *
     * @param {LogLevel} logLevel - The log level to set
     *
     * @example
     * // Set all loggers to only show errors in production
     * if (process.env.NODE_ENV === 'production') {
     *     LogManager.getInstance().setGeneralLogLevel(LogLevel.ERROR);
     * }
     */
    setGeneralLogLevel(logLevel: LogLevel): void;
    /**
     * Sets the log level for any logger that holds a source that starts with the given name
     *
     * @param {string} name - The name of the logger
     * @param {LogLevel} logLevel - The log level to set
     *
     * @example
     * // Enable debug logs for a specific component
     * LogManager.getInstance().setLogLevel('AuthService', LogLevel.DEBUG);
     */
    setLogLevel(name: string, logLevel: LogLevel): void;
    /**
     * Setting the log level for any logger that its name contains the given name parameter
     * @param name
     * @param logLevel
     */
    setLogLevelContaining(name: string, logLevel: LogLevel): void;
    setLogLevelByRegex(regex: RegExp, logLevel: LogLevel): void;
    getLoggersByRegex(regex: RegExp): Logger[];
    /**
     * Returns all registered loggers.
     *
     * @returns {Logger[]} Array of all registered logger instances
     *
     * @example
     * const allLoggers = LogManager.getInstance().getAllLoggers();
     * console.log(`Total loggers: ${allLoggers.length}`);
     */
    getAllLoggers(): Logger[];
    clearLoggers(): void;
    clearConfiguration(): void;
    clearAll(): void;
}