API @deepkit/logger

export class ConsoleTransport implements LoggerTransport {
    constructor(protected withColors: boolean = true);
    write(message: LogMessage): void;
    supportsColor();
}

export class JSONTransport implements LoggerTransport {
    out: {
        write: (v: string) => any;
    };
    write(message: LogMessage);
    supportsColor();
}

export class ColorFormatter implements LoggerFormatter {
    static colors: string[];
    format(message: LogMessage): void;
}

export class RemoveColorFormatter implements LoggerFormatter {
    format(message: LogMessage): void;
}

export class DefaultFormatter implements LoggerFormatter {
    formatters: LoggerFormatter[];
    format(message: LogMessage): void;
}

export class TimestampFormatter implements LoggerFormatter {
    format(message: LogMessage): void;
}

export class LogLevelFormatter implements LoggerFormatter {
    format(message: LogMessage): void;
}

export class ScopeFormatter implements LoggerFormatter {
    format(message: LogMessage): void;
}

export class Logger implements LoggerInterface {
    /**
     * Setting a log level means only logs below or equal to this level will be handled.
     */
    level: LoggerLevel;
    constructor(protected transporter: LoggerTransport[] = [], protected formatter: LoggerFormatter[] = [], public scope: string = );
    setLevel(level: keyof typeof LoggerLevel);
    isScopeEnabled(name: string): boolean;
    setScopeLevel(name: string, level: LoggerLevel);
    unsetScopeLevel(name: string);
    getScopeLevel(name: string): number;
    /**
     * Sends additional log data for the very next log/error/alert/warning/etc call.
     *
     * @example
     * ```typescript
     *
     * logger.data({user: user}).log('User logged in');
     *
     * //or
     *
     * //the given data is only used for the very next log (or error/alert/warning etc) call.
     * logger.data({user: user})
     * logger.log('User logged in');
     *
     * //at this point `data` is consumed, and for all other log calls not used anymore.
     * logger.log('another message without data');
     *
     *
     * ```
     */
    data(data: LogData): this;
    /**
     * Creates a new scoped logger. A scoped logger has the same log level, transports, and formatters as the parent logger,
     * and references them directly. This means if you change the log level on the parent logger, it will also change for all
     * scoped loggers.
     */
    scoped(name: string): Logger;
    addTransport(transport: LoggerTransport);
    setTransport(transport: LoggerTransport[]);
    removeTransport(transport: LoggerTransport);
    hasFormatter(formatterType: ClassType<LoggerFormatter>);
    hasFormatters(): boolean;
    addFormatter(formatter: LoggerFormatter);
    setFormatter(formatter: LoggerFormatter[]);
    is(level: LoggerLevel): boolean;
    alert(...message: any[]);
    error(...message: any[]);
    warn(...message: any[]);
    log(...message: any[]);
    info(...message: any[]);
    debug(...message: any[]);
    debug2(...message: any[]);
}

export class ConsoleLogger extends Logger {
    constructor();
}

export class MemoryLogger extends Logger {
    memory;
    constructor(transporter: LoggerTransport[] = [], formatter: LoggerFormatter[] = [], scope: string = );
    getOutput(): string;
    clear();
}

export class MemoryLoggerTransport implements LoggerTransport {
    messages: LogMessage[];
    messageStrings: string[];
    clear(): void;
    write(message: LogMessage);
    supportsColor();
}

type ScopedLogger = Inject<Logger, 'scoped-logger'>;

type LogData = { [name: string]: any };

interface LogMessage {
    message: string;
    rawMessage: string;
    date: Date;
    level: LoggerLevel;
    scope: string;
    data: LogData;
}

interface LoggerTransport {
    write(message: LogMessage): void;

    supportsColor(): boolean;
}

interface LoggerFormatter {
    format(message: LogMessage): void;
}

interface LoggerInterface {
    level: LoggerLevel;

    scoped(name: string): LoggerInterface;

    /**
     * Sends additional log data for the very next log/error/alert/warning/etc call.
     *
     * @example
     * ```typescript
     *
     * logger.data({user: user}).log('User logged in');
     *
     * //or
     *
     * //the given data is only used for the very next log (or error/alert/warning etc) call.
     * logger.data({user: user})
     * logger.log('User logged in');
     *
     * //at this point `data` is consumed, and for all other log calls not used anymore.
     * logger.log('another message without data');
     *
     *
     * ```
     */
    data(data: LogData): LoggerInterface;

    is(level: LoggerLevel): boolean;

    alert(...message: any[]): void;

    error(...message: any[]): void;

    warn(...message: any[]): void;

    log(...message: any[]): void;

    info(...message: any[]): void;

    debug(...message: any[]): void;

    debug2(...message: any[]): void;
}

type ScopedLogger = Inject<Logger, 'scoped-logger'>;