import { ChainForkConfig } from "@lodestar/config";
import { Epoch, Slot, TimeSeconds } from "@lodestar/types";
import { Logger } from "@lodestar/utils";
type RunEveryFn = (slot: Slot, signal: AbortSignal) => Promise<void>;
export type ClockOptions = {
    skipSlots?: boolean;
};
export interface IClock {
    readonly genesisTime: number;
    readonly secondsPerSlot: number;
    readonly currentEpoch: number;
    start(signal: AbortSignal): void;
    runEverySlot(fn: (slot: Slot, signal: AbortSignal) => Promise<void>): void;
    runEveryEpoch(fn: (epoch: Epoch, signal: AbortSignal) => Promise<void>): void;
    msToSlot(slot: Slot): number;
    msFromSlot(slot: Slot): number;
    secFromSlot(slot: Slot): number;
    getCurrentSlot(): Slot;
    getCurrentEpoch(): Epoch;
}
export declare enum TimeItem {
    Slot = 0,
    Epoch = 1
}
export declare class Clock implements IClock {
    private readonly opts;
    readonly genesisTime: number;
    readonly secondsPerSlot: number;
    private readonly config;
    private readonly logger;
    private readonly fns;
    constructor(config: ChainForkConfig, logger: Logger, opts: {
        genesisTime: number;
    } & ClockOptions);
    get currentEpoch(): Epoch;
    start(signal: AbortSignal): void;
    getCurrentSlot(): Slot;
    getCurrentEpoch(): Epoch;
    runEverySlot(fn: RunEveryFn): void;
    runEveryEpoch(fn: RunEveryFn): void;
    /** Milliseconds from now to a specific slot */
    msToSlot(slot: Slot): number;
    /** Milliseconds elapsed from a specific slot to now */
    msFromSlot(slot: Slot): number;
    /** Seconds elapsed from a specific slot to now */
    secFromSlot(slot: Slot): number;
    private runAtMostEvery;
    private timeUntilNext;
}
/**
 * Same to the spec but we use Math.round instead of Math.floor.
 */
export declare function getCurrentSlotAround(config: ChainForkConfig, genesisTime: TimeSeconds): Slot;
export {};
//# sourceMappingURL=clock.d.ts.map