// Type definitions for rx-core-binding 4.0
// Project: https://github.com/Reactive-Extensions/RxJS
// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

/// <reference types="rx-core" />

declare namespace Rx {
    interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
        hasObservers(): boolean;
    }

    interface Subject<T> extends ISubject<T> {
    }

    interface SubjectStatic {
        new <T>(): Subject<T>;
        create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
    }

    const Subject: SubjectStatic;

    interface AsyncSubject<T> extends Subject<T> {
    }

    interface AsyncSubjectStatic {
        new <T>(): AsyncSubject<T>;
    }

    const AsyncSubject: AsyncSubjectStatic;

    interface BehaviorSubject<T> extends Subject<T> {
        getValue(): T;
    }

    interface BehaviorSubjectStatic {
        new <T>(initialValue: T): BehaviorSubject<T>;
    }

    const BehaviorSubject: BehaviorSubjectStatic;

    interface ReplaySubject<T> extends Subject<T> {
    }

    interface ReplaySubjectStatic {
        new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
    }

    const ReplaySubject: ReplaySubjectStatic;

    interface ConnectableObservable<T> extends Observable<T> {
        connect(): IDisposable;
        refCount(): Observable<T>;
    }

    interface ConnectableObservableStatic {
        new <T>(): ConnectableObservable<T>;
    }

    const ConnectableObservable: ConnectableObservableStatic;

    interface Observable<T> {
        multicast(subject: Observable<T>): ConnectableObservable<T>;
        multicast<TResult>(subjectSelector: () => ISubject<T>, selector: (source: ConnectableObservable<T>) => Observable<T>): Observable<T>;
        publish(): ConnectableObservable<T>;
        publish<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
        /**
         * Returns an observable sequence that shares a single subscription to the underlying sequence.
         * This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one,
         * then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
         *
         * @example
         * var res = source.share();
         *
         * @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
         */
        share(): Observable<T>;
        publishLast(): ConnectableObservable<T>;
        publishLast<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
        publishValue(initialValue: T): ConnectableObservable<T>;
        publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: T): Observable<TResult>;
        /**
         * Returns an observable sequence that shares a single subscription to the underlying sequence and starts with an initialValue.
         * This operator is a specialization of publishValue which creates a subscription when the number of observers goes from zero to one,
         * then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
         *
         * @example
         * var res = source.shareValue(42);
         *
         * @param initialValue Initial value received by observers upon subscription.
         * @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
         */
        shareValue(initialValue: T): Observable<T>;
        replay(selector?: boolean, bufferSize?: number, window?: number, scheduler?: IScheduler): ConnectableObservable<T>;    // hack to catch first omitted parameter
        replay(selector: (source: ConnectableObservable<T>) => Observable<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
        shareReplay(bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
    }
}

declare module "rx-core-binding" {
    export = Rx;
}