export declare type ConsoleWritter = {
    debug(...args: any[]): void;
    error(...args: any[]): void;
    log(...args: any[]): void;
    warn(...args: any[]): void;
};

/**
 * Binds all methods of an class to this class
 * @example class SomeClass extends LiteAutoBind
 */
declare abstract class LiteAutoBind {
    constructor();
}

export declare type LiteLogEvent<PayloadT = any> = {
    type: LiteLogType;
    timestamp: string;
    link: string;
    executor: string;
    loggerName: string;
    logPrefix: string;
    logSuffix: string;
    logArgs: any[];
    payload?: PayloadT;
};

export declare class LiteLogger<PayloadT = any> extends LiteAutoBind implements LiteLogWritter {
    private readonly handleLog;
    private readonly sourceFolderName;
    private readonly executorOffset;
    private readonly loggerName;
    private readonly logPrefix;
    private readonly logSuffix;
    private readonly payload;
    constructor(params?: LiteLoggerParams<PayloadT>);
    debug(...args: any[]): void;
    error(...args: any[]): void;
    info(...args: any[]): void;
    warn(...args: any[]): void;
    private handle;
    private getLogCurrentTimestamp;
    private getExecutorInfo;
}

export declare type LiteLoggerParams<PayloadT = any> = {
    handleLog?: (logEvent: LiteLogEvent) => void;
    sourceFolderName?: string;
    executorOffset?: number;
    loggerName?: string;
    logPrefix?: string;
    logSuffix?: string;
    payload?: PayloadT;
};

export declare type LiteLogType = 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR';

export declare type LiteLogWritter = {
    debug(...args: any[]): void;
    error: (...args: any[]) => void;
    info: (...args: any[]) => void;
    warn: (...args: any[]) => void;
};

export declare type LogArgsParams = {
    withDivider?: boolean;
    withCodeLink?: boolean;
    withCodeExecutor?: boolean;
};

export declare function logArgsToString(args: any[]): string;

export declare const logArgToString: (arg: unknown) => string;

export declare function logEventToLogArgs({ timestamp, type, link, loggerName, executor, logArgs, logPrefix, logSuffix }: LiteLogEvent, { withDivider, withCodeLink, withCodeExecutor }?: LogArgsParams): any[];

export declare function logEventToString(logEvent: LiteLogEvent, params?: LogArgsParams): string;

export declare function spyConsole(logWritter: LiteLogWritter, { onlyErrors }?: {
    onlyErrors: boolean;
}): ConsoleWritter;

export declare function writeLogArgsInConsole(consoleImpl: ConsoleWritter, type: LiteLogType, logArgs: unknown[]): void;

export { }