import type { LevelParam, LoggerConfig } from './types';
import type { Level } from './level';
import { ParseCallStackFunction } from './defaultParseCallStack';
export type TransformFunctionReturn<T> = {
    data: T;
    error?: Error | {
        message: string;
        stack?: string;
        [x: string]: any;
    };
};
export declare class Logger<TData extends any[], TContext extends Record<string, any> = never, TDataOut = TData> {
    loggerName: string;
    private _level;
    useCallStack: boolean;
    context: TContext;
    private callStackSkipIndex;
    private parseCallStack;
    constructor(param: LoggerConfig<TContext>);
    get level(): Level;
    get callStackLinesToSkip(): number;
    set callStackLinesToSkip(number: number);
    protected transform: (...args: TData) => TransformFunctionReturn<TDataOut>;
    private log;
    trace: (...args: TData) => void;
    debug: (...args: TData) => void;
    info: (...args: TData) => void;
    warn: (...args: TData) => void;
    error: (...args: TData) => void;
    fatal: (...args: TData) => void;
    isLevelEnabled(otherLevel: LevelParam): boolean;
    private _log;
    addContext<K extends TContext extends undefined ? never : keyof TContext>(key: K, value: TContext[K]): void;
    removeContext(key: string): void;
    clearContext(): void;
    setParseCallStackFunction(parseFunction?: ParseCallStackFunction): void;
}