import { Time, Task } from '@koober/std';
import { UUID } from '@koober/uuid';
import { LogRecord } from './record';
import { LogDispatcher } from './dispatcher';
import { LogLevel } from './level';
export interface Logger extends Readonly<{
    dispatcher: LogDispatcher.Module<LogRecord>;
    loggerMiddlewares: ReadonlyArray<Logger.Middleware>;
    loggerName: string;
    currentTime: Task.Sync<Time, never>;
    randomUUID: Task.Sync<UUID, never>;
}> {
}
export declare namespace Logger {
    type Middleware = (record: LogRecord) => LogRecord;
    type Params = Pick<LogRecord, 'level' | 'levelName' | 'message' | 'data'>;
    const defaultCurrentTime: Logger['currentTime'];
    const defaultRandomUUID: Logger['randomUUID'];
    /**
     * Construct LoggerType
     *
     * @param data - constructor parameters
     * @returns a new LoggerType
     */
    function create({ loggerName, loggerMiddlewares, dispatcher, currentTime, randomUUID, }: {
        dispatcher: Logger['dispatcher'];
        loggerMiddlewares: Logger['loggerMiddlewares'];
        loggerName: Logger['loggerName'];
        currentTime?: Logger['currentTime'];
        randomUUID?: Logger['randomUUID'];
    }): Logger;
    /**
     * Send a logRecord to the log module
     *
     * @param logger - the logger
     * @param params - params needed to create the record
     */
    function handleRecord(logger: Logger, params: Params): LogRecord;
}
export declare type LoggerFunction = {
    (params: Logger.Params): LogRecord;
    loggerName: string;
    loggerMiddlewares: ReadonlyArray<Logger.Middleware>;
};
export declare type LoggerParams = Logger.Params & {
    /**
     * Add `extraData` to current data
     *
     * @param extraData
     */
    withData(extraData: Logger.Params['data']): LoggerParams;
};
export declare namespace LoggerParams {
    /**
     * Return a new logger params
     *
     * @param data
     */
    function create({ data, ...other }: Logger.Params): LoggerParams;
}
/**
 * Return a new logger factory function
 *
 * @param dispatcher - the dispatcher instance
 */
export declare function loggerFactory(dispatcher: LogDispatcher.Module<LogRecord>): (name: LogRecord['category'], middlewares?: ReadonlyArray<Logger.Middleware>) => LoggerFunction;
declare type ReferenceInput = [string, unknown] | {
    [key: string]: unknown;
};
/**
 * Return a function that creates params to be used with a logger function
 *
 * @param level - the default message level
 * @returns a new logger params factory
 */
export declare function loggerParamsFactory(level: LogLevel): (strings: TemplateStringsArray, ...referencesInput: Array<undefined | null | string | ReferenceInput>) => LoggerParams;
export {};
//# sourceMappingURL=logger.d.ts.map