import { LogLevel, LogFilter } from "./LogFilter";
import type { Logger } from "./Logger";
import type { ISerializedItem, ILogItem, LogItemValues, LabelOrValues, FilterCreator, LogCallback } from "./types";
export declare class LogItem implements ILogItem {
    readonly start: number;
    logLevel: LogLevel;
    error?: Error;
    end?: number;
    private _values;
    protected _logger: Logger;
    private _filterCreator?;
    private _children?;
    private _discard;
    constructor(labelOrValues: LabelOrValues, logLevel: LogLevel, logger: Logger, filterCreator?: FilterCreator);
    /**
     * Prevents this log item from being present in the exported output.
     */
    discard(): void;
    /** start a new root log item and run it detached mode, see Logger.runDetached */
    runDetached(labelOrValues: LabelOrValues, callback: LogCallback<unknown>, logLevel?: LogLevel, filterCreator?: FilterCreator): ILogItem;
    /** start a new detached root log item and log a reference to it from this item */
    wrapDetached(labelOrValues: LabelOrValues, callback: LogCallback<unknown>, logLevel?: LogLevel, filterCreator?: FilterCreator): void;
    /** logs a reference to a different log item, usually obtained from runDetached.
    This is useful if the referenced operation can't be awaited. */
    refDetached(logItem: ILogItem, logLevel?: LogLevel): void;
    ensureRefId(): void;
    /**
     * Creates a new child item and runs it in `callback`.
     */
    wrap<T>(labelOrValues: LabelOrValues, callback: LogCallback<T>, logLevel?: LogLevel, filterCreator?: FilterCreator): T;
    get duration(): number | undefined;
    durationWithoutType(type: string): number | undefined;
    durationOfType(type: string): number | undefined;
    /**
     * Creates a new child item that finishes immediately
     * Finished items should not be modified anymore as they can be serialized
     * at any stage, but using `set` on the return value in a synchronous way should still be safe.
     */
    log(labelOrValues: LabelOrValues, logLevel?: LogLevel): ILogItem;
    set(key: string | object, value?: unknown): ILogItem;
    serialize(filter: LogFilter, parentStartTime: number | undefined, forced: boolean): ISerializedItem | undefined;
    /**
     * You probably want to use `wrap` instead of this.
     *
     * Runs a callback passing this log item,
     * recording the timing and any error.
     *
     * callback can return a Promise.
     *
     * Should only be called once.
     *
     * @param  {Function} callback [description]
     * @return {[type]}            [description]
     */
    run<T>(callback: LogCallback<T>): T;
    /**
     * finished the item, recording the end time. After finishing, an item can't be modified anymore as it will be persisted.
     * @internal shouldn't typically be called by hand. allows to force finish if a promise is still running when closing the app
     */
    finish(): void;
    /** @internal */
    forceFinish(): void;
    get level(): typeof LogLevel;
    catch(err: Error): Error;
    child(labelOrValues: LabelOrValues, logLevel?: LogLevel, filterCreator?: FilterCreator): LogItem;
    get logger(): Logger;
    get values(): LogItemValues;
    get children(): Array<LogItem> | undefined;
}