export declare type MetricsDefinition = Record<string, Metric>;
interface MetricEvents {
    record: (value: number) => void;
}
export declare abstract class Sampler {
    protected readonly metric: Metric;
    private readonly listener;
    constructor(metric: Metric);
    start(_now: number): void;
    stop(_now: number): void;
    protected abstract onRecord(value: number): void;
    abstract getAggregatedValue(): number | undefined;
}
export declare class Metric {
    private latestValue;
    private readonly eventEmitter;
    private readonly samplerFactory;
    constructor(samplerFactory: (metric: Metric) => Sampler, initialValue?: number);
    record(value: number): void;
    getLatestValue(): number | undefined;
    on<T extends keyof MetricEvents>(eventName: T, listener: MetricEvents[T]): void;
    off<T extends keyof MetricEvents>(eventName: T, listener: MetricEvents[T]): void;
    createSampler(): Sampler;
}
export declare class CountMetric extends Metric {
    constructor();
}
export declare class AverageMetric extends Metric {
    constructor();
}
export declare class LevelMetric extends Metric {
    constructor(initialValue?: number);
}
export declare class RateMetric extends Metric {
    constructor();
}
export declare type MetricsReport = {
    period: {
        start: number;
        end: number;
    };
} & Record<string, any>;
export declare class MetricsContext {
    private readonly metrics;
    addMetrics(namespace: string, definitions: MetricsDefinition): void;
    getMetric(id: string): Metric | undefined;
    createReportProducer(onReport: (report: MetricsReport) => void, interval: number, formatNumber?: (value: number) => string): {
        stop: () => void;
    };
}
export {};