import { Middleware } from './middleware';
import { Serializer } from './serializer';
import { Target } from './target';
/**
 * Log data to a target (default: stdout) in a specified format (default: json).
 * Configure output levels (info, warn, etc) with custom targets or serializers
 * Create transformations that extend or modify each log (e.g. add timestamp)
 * Dynamically create new log levels, or extend the Logger class
 */
declare class Logger {
    static readonly defaultOptions: Logger.Options;
    static readonly defaultHandler: Logger.Handler;
    static readonly defaultHandlers: Map<string, Logger.Handler>;
    /**
     * maps each log level to a handler.
     * Enabling a log level:
     *    `handlers.get('trace').enabled = true;`
     *  Change target:
     *    `handlers.get('warn').target = Target.stderr
     */
    handlers: Map<string, Logger.Handler>;
    constructor(opts?: Partial<Logger.Options>);
    /**
     * process and serialize log.
     * @param level name of the log level. must be default handler or initialized with logger.addHandler first'
     * @param userData - custom properties to log
     */
    log(level: string, message: string, userData?: object): void;
    /** system diagnostic info */
    diag(message: string, userData?: object): void;
    /** operational logging */
    trace(message: string, userData?: object): void;
    /** perforance and timing data */
    telem(message: string, userData?: object): void;
    /** network requests */
    request(message: string, userData?: object): void;
    /** startup status and notable events (ENABLED BY DEFAULT) */
    info(message: string, userData?: object): void;
    /** warning (ENABLED BY DEFAULT) */
    warn(message: string, userData?: object): void;
    /** unhandled error (ENABLED BY DEFAULT) */
    error(message: string, userData?: object): void;
    /** unrecoverable error (ENABLED BY DEFAULT) */
    fatal(message: string, userData?: object): void;
    /**
     * @param levels - adds the middleware to handlers for all listed levels. if true, add to all handlers
     */
    addMiddleware(middleware: Middleware, levels: true | string[]): void;
    /** add a log level, which can be inovked with logger.log(name, 'my message');
     * @param name - recorded in each log
     * @param handler - handler options. missing fields are populated by Logger.defaultHandler
     * @returns fully initialized log handler
     */
    addHandler(name: string, handler?: Partial<Logger.Handler>): Logger.Handler;
}
declare namespace Logger {
    /** class constructor options */
    interface Options {
        /** Middleware for each log level
         * appended to the default log middleware.
         * levels is an array of level names the middleware is applied to.
         * if levels is true, it is applied to all levels
         */
        middleware: Array<{
            mw: Middleware;
            levels: true | string[];
        }>;
        /** if provided, all log levels are initialized with this target */
        target?: Target;
        /** if provided, all log levels are initialized with this serializer */
        serializer?: Serializer;
    }
    /** Describes how logs for a level are processed */
    interface Handler {
        enabled: boolean;
        middleware: Middleware[];
        serializer: Serializer;
        target: Target;
    }
}
export { Logger };