export type TimedValue<T extends Record<string, number | null>> = {
    value: Values<T>;
    timestamp: number;
};
export type Values<T> = {
    [P in keyof T]: number | null;
};
export type Deltas<T> = {
    [P in keyof T & string as `delta${Capitalize<P>}`]: number | null;
};
export type SliceConfig = {
    numberOfSamples: number;
    offset?: number;
};
export type SliceConfigs = Readonly<Record<string, SliceConfig>>;
export type SlicedWindowConfigBase = {
    capacity?: number;
    maxAllowedGapInMs: number;
};
export type SlicedWindowConfig<T extends Record<string, number | null>, S extends SliceConfigs> = SlicedWindowConfigBase & {
    totals: T;
    slices: S;
};
export declare class Slice {
    readonly numberOfSamples: number;
    readonly offset: number;
    durationInMs: number;
    numberOfEntries: number;
    constructor(numberOfSamples: number, offset: number);
    get isReady(): boolean;
}
export type WindowSlice<T extends Record<string, number | null>> = Slice & Deltas<T>;
export declare class SlicedWindow<T extends Record<string, number | null>, S extends SliceConfigs> {
    readonly config: SlicedWindowConfig<T, S>;
    static readonly MIN_SAMPLES = 2;
    readonly slices: {
        readonly [N in keyof S]: WindowSlice<T>;
    };
    readonly capacity: number;
    private readonly fields;
    private readonly entries;
    private readonly slicesByName;
    private lastTimestamp;
    constructor(config: SlicedWindowConfig<T, S>);
    get numberOfEntries(): number;
    get registeredSlices(): readonly WindowSlice<T>[];
    getSlice<N extends keyof S & string>(name: N): WindowSlice<T>;
    add(item: TimedValue<T>): void;
    reset(): void;
    private createSlice;
    private refreshSlices;
    private refreshSlice;
}