import { IObservableEvent } from '../internal/Events';
import { IObservable } from '../internal/Observable';
import { ISubscription } from '../internal/Subscription';
import { TestObservable } from '../internal/TestObservable';
import { TestObserver } from '../internal/TestObserver';
import { IScheduler } from './Scheduler';
export declare type EventSource = Array<IObservableEvent>;
export declare class TestScheduler implements IScheduler {
    private rafTimeout;
    asap(task: () => void): ISubscription;
    private clock;
    private queue;
    constructor(rafTimeout: number);
    readonly length: number;
    tick(): void;
    advanceBy(time: number): void;
    advanceTo(time: number): void;
    now(): number;
    delay(task: () => void, time: number, now?: number): ISubscription;
    frame(task: () => void): ISubscription;
    frames(task: () => void): ISubscription;
    periodic(task: () => void, interval: number): ISubscription;
    private run;
    subscribeTo<T>(f: () => IObservable<T>, start?: number, stop?: number): TestObserver<{}>;
    start<T>(f: () => IObservable<T>, start?: number, stop?: number): TestObserver<{}>;
    startSubscription(f: () => ISubscription, start?: number, stop?: number): void;
    Cold<T>(events: string): TestObservable<T>;
    Cold<T>(events: EventSource): TestObservable<T>;
    Cold<T>(...events: EventSource): TestObservable<T>;
    Hot<T>(events: string): TestObservable<T>;
    Hot<T>(...events: EventSource): TestObservable<T>;
    Hot<T>(events: EventSource): TestObservable<T>;
    Observer<T>(): TestObserver<T>;
    timeline(tasks: Array<[number, () => void]>): void;
}
export declare const createTestScheduler: (rafTimeout?: number) => TestScheduler;