import { Observable } from '../Observable';
import { Observer } from '../Observer';
import { ColdObservable } from './ColdObservable';
import { HotObservable } from './HotObservable';
import { TestMessage } from './TestMessage';
import { SubscriptionLog } from './SubscriptionLog';
import { Subscription } from '../Subscription';
import { VirtualTimeScheduler } from '../scheduler/VirtualTimeScheduler';
export declare type observableToBeFn = (marbles: string, values?: any, errorValue?: any) => void;
export declare type subscriptionLogsToBeFn = (marbles: string | string[]) => void;
export declare class TestScheduler extends VirtualTimeScheduler {
    assertDeepEqual: (actual: any, expected: any) => boolean | void;
    private hotObservables;
    private coldObservables;
    private flushTests;
    constructor(assertDeepEqual: (actual: any, expected: any) => boolean | void);
    createTime(marbles: string): number;
    createColdObservable<T>(...messages: TestMessage[]): ColdObservable<T>;
    createColdObservable<T>(marbles: string, values?: any, error?: any): ColdObservable<T>;
    createHotObservable<T>(...messages: TestMessage[]): HotObservable<any>;
    createHotObservable<T>(marbles: string, values?: any, error?: any): HotObservable<T>;
    private materializeInnerObservable(observable, outerFrame);
    expectObservable(observable: Observable<any>, unsubscriptionMarbles?: string): ({
        toBe: observableToBeFn;
    });
    expectSubscriptions(actualSubscriptionLogs: SubscriptionLog[]): ({
        toBe: subscriptionLogsToBeFn;
    });
    flush(limit?: number): void;
    static parseMarblesAsSubscriptions(marbles: string): SubscriptionLog;
    static parseMarbles(marbles: string, values?: any, errorValue?: any, materializeInnerObservables?: boolean): TestMessage[];
    createObserver(): Observer<any> & {
        messages: TestMessage[];
    };
    startScheduler(factory: () => Observable<any>, settings?: {
        created: number;
        subscribed: number;
        disposed: number;
    }): {
        messages: TestMessage[];
    };
    scheduleAbsolute(state: any, dueTime: number, action: () => any): Subscription;
    advanceBy(time: number): void;
    advanceTo(time: number): void;
    createResolvedPromise(time: number, value: any): {
        then: Function;
    };
    createRejectedPromise(time: number, rejection: any): {
        then: Function;
    };
    scheduleRelative(state: any, delay: number, action: () => void): void;
    stop(): void;
    start: this['flush'];
}