declare const promisifySymbol: unique symbol;
/**
 * When entering a clock, the current state of the global is saved If another
 * clock was already entered, it will revert back to that when exiting.
 *
 * When we exit, if the monkey-patched global proxies get called, they will
 * revert back to whatever the saved value was when they were patched. If that
 * is another exited clock, it will proxy back to its original saved state, and
 * so on, eventually hitting the original global state again if all clocks in
 * the stack have been exited.
 */
export interface Saved {
    performance: {
        now: () => number;
    };
    Date: typeof Date | ReturnType<typeof MockDate>;
    setTimeout: SetTimeout;
    setInterval: SetInterval;
    setImmediate: SetImmediate;
    clearTimeout: typeof clearTimeout;
    clearInterval: typeof clearInterval;
    clearImmediate: typeof clearImmediate;
    process: {
        hrtime: {
            (t?: [number, number]): [number, number];
            bigint(): bigint;
        };
    };
}
/**
 * The promisified form of setTimeout
 */
export interface SetTimeoutPromise {
    (n?: number, value?: undefined, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<void>;
    <T = void>(n: number, value: T, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<T>;
}
/**
 * setTimeout which can be promisified
 */
export interface SetTimeout {
    (f: (a: void) => any, n?: number): Timer;
    <TArgs extends any[]>(f: (...a: TArgs) => any, n?: number, ...a: TArgs): Timer;
    __promisify__: SetTimeoutPromise;
    [promisifySymbol]: SetTimeoutPromise;
}
/**
 * Promisified form of setInterval
 */
export interface SetIntervalPromise {
    (n?: number, value?: undefined, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): AsyncGenerator<void>;
    <T = void>(n?: number, value?: T, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): AsyncGenerator<T>;
}
/**
 * setInterval which can be promisified
 */
export interface SetInterval {
    (f: (a: void) => any, n?: number): Timer;
    <TArgs extends any[]>(f: (...a: TArgs) => any, n?: number, ...a: TArgs): Timer;
    __promisify__: SetIntervalPromise;
    [promisifySymbol]: SetIntervalPromise;
}
/**
 * The promisified form of setImmediate
 */
export interface SetImmediatePromise {
    (value?: undefined, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<void>;
    <T = void>(value: T, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<T>;
}
/**
 * setImmediate which can be promisified
 */
export interface SetImmediate {
    (f: (a: void) => any): Timer;
    <TArgs extends any[]>(f: (...a: TArgs) => any, ...a: TArgs): Timer;
    __promisify__: SetImmediatePromise;
    [promisifySymbol]: SetImmediatePromise;
}
/**
 * Interface of an object with timer methods
 */
export interface TimerProvider {
    setTimeout: SetTimeout;
    setInterval: SetInterval;
    setImmediate: SetImmediate;
}
/**
 * The mock clock implementation
 */
export declare class Clock implements TimerProvider {
    #private;
    get timers(): Map<number, Timer[]>;
    Date: ReturnType<typeof MockDate>;
    /**
     * Schedule a function to be run when the clock has advanced `n` ms beyond
     * the current point.
     *
     * Only ms granularity.
     */
    setTimeout: SetTimeout;
    /**
     * Schedule a function to be run when the clock advances each multiple
     * of `n` past the current point.
     *
     * If multiple steps are advanced at once, for example doing
     * `c.setInterval(fn, 1) ; c.advance(1000)`, then it will only call the
     * function once.  This allows you to simulate clock jitter.
     *
     * Only ms granularity.
     */
    setInterval: SetInterval;
    /**
     * Schedule a function to be run the next time the clock is advanced by
     * any ammount.
     */
    setImmediate: SetImmediate;
    constructor();
    /**
     * Returns the current ms time on the clock.
     */
    now(): number;
    /**
     * Set the clock to a specific time.  Will fire timers that you zoom past.
     */
    travel(to: number): void;
    /**
     * Advance the clock by `n` ms.  Use floats for smaller increments of time.
     */
    advance(n: number): void;
    /**
     * Advance the clock in steps, awaiting a Promise at each step, so that
     * actual asynchronous events can occur, as well as timers.
     */
    flow(n: number, step?: number): Promise<void>;
    /**
     * The promisified setImmediate, also available via
     * `promisify(clock.setImmediate)`
     */
    setImmediatePromise(value?: undefined, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<void>;
    setImmediatePromise<T = void>(value: T, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<T>;
    /**
     * The promisified setTimeout, also available via
     * `promisify(clock.setTimeout)`
     */
    setTimeoutPromise(n?: number, value?: undefined, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<void>;
    setTimeoutPromise<T = void>(n: number, value: T, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): Promise<T>;
    /**
     * Clear a timeout created by the clock.
     */
    clearTimeout(t: Timer | NodeJS.Timeout): void;
    /**
     * Clear an interval created by the clock. (alias for
     * {@link Clock#clearTimeout})
     */
    clearInterval(t: Timer | NodeJS.Timeout): void;
    /**
     * Clear an immediate timer created by the clock. (alias for
     * {@link Clock#clearTimeout})
     */
    clearImmediate(t: Timer | NodeJS.Immediate): void;
    /**
     * promisified `setInterval`, also available via
     * `promisify(clock.setImmediate)`
     */
    setIntervalPromise(n?: number, value?: undefined, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): AsyncGenerator<void>;
    setIntervalPromise<T = void>(n?: number, value?: T, options?: {
        signal?: AbortSignal;
        reffed?: boolean;
    }): AsyncGenerator<T>;
    /**
     * Mock of `process.hrtime()`, returning `[seconds, nanoseconds]` on the
     * clock.
     */
    hrtime(s?: [number, number]): [number, number];
    /**
     * Mock of `process.hrtime.bigint()`, returning BigInt representation of
     * current nanosecond time.
     */
    hrtimeBigint(): bigint;
    /**
     * Mocks all the things in the global space.
     *
     * Returns exit function, for ease of doing `t.teardown(c.enter())`.
     */
    enter(): () => void;
    /**
     * If entered, exit the clock, restoring the global state
     */
    exit(): boolean;
}
/**
 * Create a class like `Date`, but with its `now` value tied
 * to the value of a {@link Clock} instance.
 */
export declare const MockDate: (clock: Clock) => {
    new (...args: any[]): {
        toString(): string;
        toDateString(): string;
        toTimeString(): string;
        toLocaleString(): string;
        toLocaleString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
        toLocaleDateString(): string;
        toLocaleDateString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
        toLocaleDateString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
        toLocaleTimeString(): string;
        toLocaleTimeString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
        toLocaleTimeString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
        valueOf(): number;
        getTime(): number;
        getFullYear(): number;
        getUTCFullYear(): number;
        getMonth(): number;
        getUTCMonth(): number;
        getDate(): number;
        getUTCDate(): number;
        getDay(): number;
        getUTCDay(): number;
        getHours(): number;
        getUTCHours(): number;
        getMinutes(): number;
        getUTCMinutes(): number;
        getSeconds(): number;
        getUTCSeconds(): number;
        getMilliseconds(): number;
        getUTCMilliseconds(): number;
        getTimezoneOffset(): number;
        setTime(time: number): number;
        setMilliseconds(ms: number): number;
        setUTCMilliseconds(ms: number): number;
        setSeconds(sec: number, ms?: number): number;
        setUTCSeconds(sec: number, ms?: number): number;
        setMinutes(min: number, sec?: number, ms?: number): number;
        setUTCMinutes(min: number, sec?: number, ms?: number): number;
        setHours(hours: number, min?: number, sec?: number, ms?: number): number;
        setUTCHours(hours: number, min?: number, sec?: number, ms?: number): number;
        setDate(date: number): number;
        setUTCDate(date: number): number;
        setMonth(month: number, date?: number): number;
        setUTCMonth(month: number, date?: number): number;
        setFullYear(year: number, month?: number, date?: number): number;
        setUTCFullYear(year: number, month?: number, date?: number): number;
        toUTCString(): string;
        toISOString(): string;
        toJSON(key?: any): string;
        getVarDate: () => VarDate;
        [Symbol.toPrimitive](hint: "default"): string;
        [Symbol.toPrimitive](hint: "string"): string;
        [Symbol.toPrimitive](hint: "number"): number;
        [Symbol.toPrimitive](hint: string): string | number;
    };
    now(): number;
    parse(s: string): number;
    UTC(year: number, monthIndex: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
    UTC(year: number, monthIndex?: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
};
/**
 * A Timer that lives in the mock clock
 */
export declare class Timer {
    /**
     * {@link Clock} governing this timer
     */
    clock: Clock;
    /**
     * When this timer should fire
     */
    w: number;
    /**
     * use the property name `_onTimeout` so that the global `clearTimeout`
     * method in Node will make it no-op if it gets passed there.
     */
    _onTimeout: null | ((...a: any[]) => any);
    /**
     * set by {@link Timer#unref}
     *
     * These timers don't keep the event loop open anyway, so this doesn't
     * do much, but it's useful when testing to ensure that a timeout
     * had .ref() or .unref() called on it.
     */
    reffed: boolean;
    constructor(clock: Clock, w: number, f: (...a: any[]) => any);
    /**
     * simulacrum of node's Timer.unref. Just sets the {@link Timer#ref} field.
     */
    unref(): void;
    /**
     * simulacrum of node's Timer.ref. Just sets the {@link Timer#ref} field.
     */
    ref(): void;
    /**
     * Remove this timer from the clock's queue.
     */
    clear(): void;
}
export {};
//# sourceMappingURL=index.d.ts.map