/**
* LogLevel - Standard log level type
*
* Defines the severity levels for logging.
* Uses string literal types for better readability and type safety.
*/
type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
/**
* Logging context metadata
*/
type LogContext = Record<string, unknown>;
/**
* Logger interface
*
* All logger implementations must follow this interface.
*
* @example
* ```typescript
* class PinoLogger implements Logger {
*   private pino: Pino.Logger;
*
*   constructor(name: string) {
*     this.pino = pino({ name });
*   }
*
*   get name() { return this.pino.name; }
*   get level() { return LogLevel.DEBUG; }
*
*   debug(message: string, context?: LogContext) {
*     this.pino.debug(context, message);
*   }
*   // ... other methods
* }
* ```
*/
interface Logger {
	/**
	* Logger name (typically class name or module path)
	*/
	readonly name: string;
	/**
	* Current log level
	*/
	readonly level: LogLevel;
	/**
	* Log debug message
	*/
	debug(message: string, context?: LogContext): void;
	/**
	* Log info message
	*/
	info(message: string, context?: LogContext): void;
	/**
	* Log warning message
	*/
	warn(message: string, context?: LogContext): void;
	/**
	* Log error message or Error object
	*/
	error(message: string | Error, context?: LogContext): void;
	/**
	* Check if debug level is enabled
	*/
	isDebugEnabled(): boolean;
	/**
	* Check if info level is enabled
	*/
	isInfoEnabled(): boolean;
	/**
	* Check if warn level is enabled
	*/
	isWarnEnabled(): boolean;
	/**
	* Check if error level is enabled
	*/
	isErrorEnabled(): boolean;
}
/**
* LoggerFactory interface
*
* Factory for creating named Logger instances.
*/
interface LoggerFactory {
	/**
	* Get or create a logger with the specified name
	*
	* @param name - Logger name (typically class name or module path)
	* @returns Logger instance
	*/
	getLogger(name: string): Logger;
}
/**
* createLogger - Factory function for creating Logger instances
*
* This is the authoritative API definition.
* The agentx-common package must implement this function exactly.
*
* Uses lazy initialization: safe to call at module level before
* Runtime is configured. The actual logger implementation is
* resolved on first use.
*
* @param name - Logger name (hierarchical, e.g., "engine/AgentEngine")
* @returns Logger instance (lazy proxy)
*
* @example
* ```typescript
* // Safe at module level (before Runtime configured)
* const logger = createLogger("engine/AgentEngine");
*
* // Later, at runtime
* logger.debug("Processing event", { agentId, eventType });
* ```
*/
declare function createLogger(name: string): Logger;
export { createLogger, LoggerFactory, Logger, LogLevel, LogContext };
