import type { CommonLogger } from '@naturalcycles/js-lib/log';
import type { AnyObject, PositiveInteger } from '@naturalcycles/js-lib/types';
import type { ReadableMapper } from './stream.model.js';
export interface ProgressLoggerCfg<T = any> {
    /**
     * Progress metric
     *
     * @default `progress`
     */
    metric?: string;
    /**
     * Include `heapUsed` in log.
     *
     * @default false
     */
    heapUsed?: boolean;
    /**
     * Include `heapTotal` in log.
     *
     * @default false
     */
    heapTotal?: boolean;
    /**
     * Include `rss` in log.
     *
     * @default true
     */
    rss?: boolean;
    /**
     * Incude Peak RSS in log.
     *
     * @default true
     */
    peakRSS?: boolean;
    /**
     * Include `external` in log.
     *
     * @default false
     */
    external?: boolean;
    /**
     * Include `arrayBuffers` in log.
     *
     * @default false
     */
    arrayBuffers?: boolean;
    /**
     * Log (rss - heapTotal)
     * For convenience of debugging "out-of-heap" memory size.
     *
     * @default false
     */
    rssMinusHeap?: boolean;
    /**
     * Log "rows per second"
     *
     * @default true
     */
    logRPS?: boolean;
    /**
     * Set to false to disable logging progress
     *
     * @default true
     */
    logProgress?: boolean;
    /**
     * Log progress event Nth record that is _processed_ (went through mapper).
     * Set to 0 to disable logging.
     *
     * @default 1000
     */
    logEvery?: PositiveInteger;
    logger?: CommonLogger;
    /**
     * Function to return extra properties to the "progress object".
     *
     * chunk is undefined for "final" stats, otherwise is defined.
     */
    extra?: (chunk: T | undefined, index: number) => AnyObject;
    /**
     * Hook that is called when the last item is passed through.
     * Passes the final stats as `ProgressLogItem`.
     */
    onProgressDone?: (stats: ProgressLogItem) => any;
    /**
     * If specified - will multiply the counter by this number.
     * Useful e.g when using `transformChunk({ chunkSize: 500 })`, so
     * it'll accurately represent the number of processed entries (not chunks).
     *
     * Defaults to 1.
     */
    chunkSize?: PositiveInteger;
}
export interface ProgressLogItem extends AnyObject {
    heapUsed?: number;
    heapTotal?: number;
    rss?: number;
    peakRSS?: number;
    rssMinusHeap?: number;
    external?: number;
    arrayBuffers?: number;
    rps10?: number;
    rpsTotal?: number;
}
export declare class ProgressLogger<T> implements Disposable {
    constructor(cfg?: ProgressLoggerCfg<T>);
    cfg: ProgressLoggerCfg<T> & {
        logEvery: number;
        logSizesBuffer: number;
        chunkSize: number;
        metric: string;
        logger: CommonLogger;
    };
    private started;
    private lastSecondStarted;
    private sma;
    private logEvery10;
    private processedLastSecond;
    private progress;
    private peakRSS;
    private start;
    log(chunk?: T): void;
    done(): void;
    [Symbol.dispose](): void;
    private logStats;
}
/**
 * Create new ProgressLogger.
 */
export declare function progressLogger<T>(cfg?: ProgressLoggerCfg<T>): ProgressLogger<T>;
/**
 * Limitation: I don't know how to catch the `final` callback to log final stats.
 *
 * @experimental
 */
export declare function progressReadableMapper<T>(cfg?: ProgressLoggerCfg<T>): ReadableMapper<T, T>;