/**
 * Configurable Debug Logger
 *
 * Provides environment-aware logging that can be disabled in production.
 * Supports log levels, tagged output, and performance timing.
 */
export type LogLevel = "debug" | "info" | "warn" | "error" | "none";
export interface LoggerConfig {
    /** Minimum log level (default: "debug" in dev, "error" in prod) */
    level: LogLevel;
    /** Enable colored output (default: true) */
    colors: boolean;
    /** Include timestamps (default: false) */
    timestamps: boolean;
    /** Custom log handler (default: console) */
    handler?: LogHandler;
}
export interface LogHandler {
    debug(tag: string, ...args: unknown[]): void;
    info(tag: string, ...args: unknown[]): void;
    warn(tag: string, ...args: unknown[]): void;
    error(tag: string, ...args: unknown[]): void;
}
/**
 * Set the global log level
 */
export declare function setLogLevel(level: LogLevel): void;
/**
 * Get the current log level
 */
export declare function getLogLevel(): LogLevel;
/**
 * Configure the logger
 */
export declare function configureLogger(options: Partial<LoggerConfig>): void;
/**
 * Enable all logging (sets level to "debug")
 */
export declare function enableLogging(): void;
/**
 * Disable all logging (sets level to "none")
 */
export declare function disableLogging(): void;
/**
 * Enable debug mode - alias for enableLogging()
 * Call this at app startup to see all debug logs
 *
 * @example
 * ```typescript
 * import { setDebugMode } from "@hypen-space/core";
 * setDebugMode(true);
 * ```
 */
export declare function setDebugMode(enabled: boolean): void;
/**
 * Check if debug mode is enabled
 */
export declare function isDebugMode(): boolean;
/**
 * Tagged logger instance
 *
 * @example
 * ```typescript
 * const log = createLogger("MyComponent");
 * log.debug("initialized with", { props });
 * log.error("failed to load", error);
 * ```
 */
export declare class Logger {
    private readonly tag;
    constructor(tag: string);
    debug(...args: unknown[]): void;
    info(...args: unknown[]): void;
    warn(...args: unknown[]): void;
    error(...args: unknown[]): void;
    /**
     * Time a function execution
     */
    time<T>(label: string, fn: () => T): T;
    /**
     * Time an async function execution
     */
    timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
    /**
     * Create a child logger with additional context
     */
    child(subTag: string): Logger;
    /**
     * Conditionally log based on a condition
     */
    debugIf(condition: boolean, ...args: unknown[]): void;
    warnIf(condition: boolean, ...args: unknown[]): void;
    errorIf(condition: boolean, ...args: unknown[]): void;
    /**
     * Log once (useful for deprecation warnings)
     */
    private loggedOnce;
    warnOnce(key: string, ...args: unknown[]): void;
    debugOnce(key: string, ...args: unknown[]): void;
}
/**
 * Create a tagged logger
 *
 * @example
 * ```typescript
 * const log = createLogger("Router");
 * log.info("navigating to", path);
 * ```
 */
export declare function createLogger(tag: string): Logger;
/**
 * Default logger for general use
 */
export declare const logger: Logger;
/**
 * Shorthand logging functions for quick use
 * Prefer createLogger() for component-specific logging
 */
export declare const log: {
    debug: (tag: string, ...args: unknown[]) => void;
    info: (tag: string, ...args: unknown[]) => void;
    warn: (tag: string, ...args: unknown[]) => void;
    error: (tag: string, ...args: unknown[]) => void;
};
export declare const frameworkLoggers: {
    hypen: Logger;
    engine: Logger;
    router: Logger;
    state: Logger;
    events: Logger;
    remote: Logger;
    renderer: Logger;
    module: Logger;
    lifecycle: Logger;
    loader: Logger;
    context: Logger;
    discovery: Logger;
    plugin: Logger;
    canvas: Logger;
    debug: Logger;
};
