Module Rx

public aggregate(accumulator: (acc: T, value: T) => T): Observable

Parameters

• accumulator: (acc: T, value: T) => T

Returns

Observable

public aggregate(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable

Parameters

• seed: TAcc

• accumulator: (acc: TAcc, value: T) => TAcc

Returns

Observable

public all(predicate?: (value: T) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T) => boolean optional

• thisArg?: any optional

Returns

Observable

public amb(rightSource: Observable): Observable

Parameters

• rightSource: Observable

Returns

Observable

public amb(rightSource: IPromise): Observable

Parameters

• rightSource: IPromise

Returns

Observable

public any(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public asObservable(): Observable

Returns

Observable

public asObserver(): Observer

Returns

Observer

public average(keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number, thisArg?: any): Observable

Parameters

• keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number optional

• thisArg?: any optional

Returns

Observable

public bufferWithCount(count: number, skip?: number): Observable

Parameters

• count: number

• skip?: number optional

Returns

Observable

public catch(handler: (exception: any) => Rx.Observable<T>): Observable

Parameters

• handler: (exception: any) => Rx.Observable<T>

Returns

Observable

public catch(handler: (exception: any) => Rx.IPromise<T>): Observable

Parameters

• handler: (exception: any) => Rx.IPromise<T>

Returns

Observable

public catch(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public catchException(handler: (exception: any) => Rx.Observable<T>): Observable

Parameters

• handler: (exception: any) => Rx.Observable<T>

Returns

Observable

public catchException(handler: (exception: any) => Rx.IPromise<T>): Observable

Parameters

• handler: (exception: any) => Rx.IPromise<T>

Returns

Observable

public catchException(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public checked(): Observer

Returns

Observer

public combineLatest(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: Observable

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public combineLatest(second: IPromise, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: IPromise

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: Observable, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• fifth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult

Returns

Observable

public combineLatest(souces: Observable[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable

Parameters

• souces: Observable[]

• resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult

Returns

Observable

public combineLatest(souces: IPromise[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable

Parameters

• souces: IPromise[]

• resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult

Returns

Observable

public concat(sources?: Observable[]): Observable

Parameters

• sources?: Observable[] optional

Returns

Observable

public concat(sources?: IPromise[]): Observable

Parameters

• sources?: IPromise[] optional

Returns

Observable

public concat(sources: Observable[]): Observable

Parameters

• sources: Observable[]

Returns

Observable

public concat(sources: IPromise[]): Observable

Parameters

• sources: IPromise[]

Returns

Observable

public concatAll(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public concatMap(selector: (value: T, index: number) => Rx.Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public concatMap(selector: (value: T, index: number) => Rx.IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public concatMap(selector: (value: T, index: number) => Rx.Observable<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<R>

Returns

Observable

public concatMap(selector: (value: T, index: number) => Rx.IPromise<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<R>

Returns

Observable

public concatMap(sequence: Observable): Observable

Parameters

• sequence: Observable

Returns

Observable

public concatObservable(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public contains(value: T in Rx.Observable<T>): Observable

Parameters

• value: T in Rx.Observable<T>

Returns

Observable

public contains(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable

Parameters

• value: TOther

• comparer: (value1: T, value2: TOther) => boolean

Returns

Observable

public count(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public defaultIfEmpty(defaultValue?: T in Rx.Observable<T>): Observable

Parameters

• defaultValue?: T in Rx.Observable<T> optional

Returns

Observable

public dematerialize(): Observable

Returns

Observable

public dispose()

public distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable

Parameters

• skipParameter: boolean

• valueSerializer: (value: T) => string

Returns

Observable

public distinct(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector?: (value: T) => TKey optional

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable

Parameters

• skipParameter: boolean

• comparer: (x: T, y: T) => boolean

Returns

Observable

public distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable

Parameters

• keySelector?: (value: T) => TValue optional

• comparer?: (x: TValue, y: TValue) => boolean optional

Returns

Observable

public do(observer: Observer): Observable

Parameters

• observer: Observer

Returns

Observable

public do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

Observable

public doAction(observer: Observer): Observable

Parameters

• observer: Observer

Returns

Observable

public doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

Observable

public elementAt(index: number): Observable

Parameters

• index: number

Returns

Observable

public elementAtOrDefault(index: number, defaultValue?: T in Rx.Observable<T>): Observable

Parameters

• index: number

• defaultValue?: T in Rx.Observable<T> optional

Returns

Observable

public every(predicate?: (value: T) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T) => boolean optional

• thisArg?: any optional

Returns

Observable

public filter(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public finalValue(): Observable

Returns

Observable

public finally(action: () => void): Observable

Parameters

• action: () => void

Returns

Observable

public finallyAction(action: () => void): Observable

Parameters

• action: () => void

Returns

Observable

public find(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public findIndex(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public first(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public firstOrDefault(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, defaultValue?: T in Rx.Observable<T>, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• defaultValue?: T in Rx.Observable<T> optional

• thisArg?: any optional

Returns

Observable

public flatMap(selector: (value: T) => Rx.Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.Observable<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public flatMap(selector: (value: T) => Rx.IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public flatMap(selector: (value: T) => Rx.Observable<TResult>): Observable

Parameters

• selector: (value: T) => Rx.Observable<TResult>

Returns

Observable

public flatMap(selector: (value: T) => Rx.IPromise<TResult>): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TResult>

Returns

Observable

public flatMap(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public flatMap(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public flatMapLatest(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

  A transform function to apply to each source element; the second parameter of the function represents the index of the source element.

• thisArg?: any optional

Returns

Observable

An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences and that at any point in time produces the elements of the most recent inner observable sequence that has been received.

public forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public groupBy(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• skipElementSelector?: boolean optional

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public groupBy(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• elementSelector: (value: T) => TElement

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public groupByUntil(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: Rx.GroupedObservable<TKey, T>) => Rx.Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• skipElementSelector: boolean

• durationSelector: (group: Rx.GroupedObservable<TKey, T>) => Rx.Observable<TDuration>

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: Rx.GroupedObservable<TKey, TElement>) => Rx.Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• elementSelector: (value: T) => TElement

• durationSelector: (group: Rx.GroupedObservable<TKey, TElement>) => Rx.Observable<TDuration>

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public hasObservers(): boolean

Returns

boolean

public ignoreElements(): Observable

Returns

Observable

public isEmpty(): Observable

Returns

Observable

public last(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public lastOrDefault(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, defaultValue?: T in Rx.Observable<T>, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• defaultValue?: T in Rx.Observable<T> optional

• thisArg?: any optional

Returns

Observable

public map(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

• thisArg?: any optional

Returns

Observable

public materialize(): Observable

Returns

Observable

public max(comparer?: (value1: T, value2: T) => number): Observable

Parameters

• comparer?: (value1: T, value2: T) => number optional

Returns

Observable

public maxBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable

Parameters

• keySelector: (item: T) => TKey

• comparer: (value1: TKey, value2: TKey) => number

Returns

Observable

public maxBy(keySelector: (item: T) => number): Observable

Parameters

• keySelector: (item: T) => number

Returns

Observable

public merge(maxConcurrent: number): T in Rx.Observable<T>

Parameters

• maxConcurrent: number

Returns

T in Rx.Observable<T>

public merge(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public merge(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public mergeAll(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public mergeObservable(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public min(comparer?: (value1: T, value2: T) => number): Observable

Parameters

• comparer?: (value1: T, value2: T) => number optional

Returns

Observable

public minBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable

Parameters

• keySelector: (item: T) => TKey

• comparer: (value1: TKey, value2: TKey) => number

Returns

Observable

public minBy(keySelector: (item: T) => number): Observable

Parameters

• keySelector: (item: T) => number

Returns

Observable

public observeOn(scheduler: IScheduler): Observable

Parameters

• scheduler: IScheduler

Returns

Observable

public onCompleted()

public onCompleted()

public onError(exception: any)

Parameters

• exception: any

public onError(exception: any)

Parameters

• exception: any

public onErrorResumeNext(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public onErrorResumeNext(second: IPromise): Observable

Parameters

• second: IPromise

Returns

Observable

public onNext(value: T in Rx.IObserver<T>)

Parameters

• value: T in Rx.IObserver<T>

public onNext(value: T in Rx.IObserver<T>)

Parameters

• value: T in Rx.IObserver<T>

public reduce(accumulator: (acc: T, value: T) => T): Observable

Parameters

• accumulator: (acc: T, value: T) => T

Returns

Observable

public reduce(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable

Parameters

• accumulator: (acc: TAcc, value: T) => TAcc

• seed: TAcc

Returns

Observable

public repeat(repeatCount?: number): Observable

Parameters

• repeatCount?: number optional

Returns

Observable

public retry(retryCount?: number): Observable

Parameters

• retryCount?: number optional

Returns

Observable

public scan(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable

Parameters

• seed: TAcc

• accumulator: (acc: TAcc, value: T) => TAcc

Returns

Observable

public scan(accumulator: (acc: T, value: T) => T): Observable

Parameters

• accumulator: (acc: T, value: T) => T

Returns

Observable

public select(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

• thisArg?: any optional

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.Observable<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<R>

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.IPromise<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<R>

Returns

Observable

public selectConcat(sequence: Observable): Observable

Parameters

• sequence: Observable

Returns

Observable

public selectMany(selector: (value: T) => Rx.Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.Observable<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public selectMany(selector: (value: T) => Rx.IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public selectMany(selector: (value: T) => Rx.Observable<TResult>): Observable

Parameters

• selector: (value: T) => Rx.Observable<TResult>

Returns

Observable

public selectMany(selector: (value: T) => Rx.IPromise<TResult>): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TResult>

Returns

Observable

public selectMany(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public selectMany(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public selectSwitch(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

  A transform function to apply to each source element; the second parameter of the function represents the index of the source element.

• thisArg?: any optional

Returns

Observable

An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences and that at any point in time produces the elements of the most recent inner observable sequence that has been received.

public sequenceEqual(second: Observable, comparer: (value1: T, value2: TOther) => number): Observable

Parameters

• second: Observable

• comparer: (value1: T, value2: TOther) => number

Returns

Observable

public sequenceEqual(second: IPromise, comparer: (value1: T, value2: TOther) => number): Observable

Parameters

• second: IPromise

• comparer: (value1: T, value2: TOther) => number

Returns

Observable

public sequenceEqual(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public sequenceEqual(second: IPromise): Observable

Parameters

• second: IPromise

Returns

Observable

public sequenceEqual(second: Array<TOther>, comparer: (value1: T, value2: TOther) => number): Observable

Parameters

• second: Array<TOther>

• comparer: (value1: T, value2: TOther) => number

Returns

Observable

public sequenceEqual(second: Array<T>): Observable

Parameters

• second: Array<T>

Returns

Observable

public single(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public singleOrDefault(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, defaultValue?: T in Rx.Observable<T>, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• defaultValue?: T in Rx.Observable<T> optional

• thisArg?: any optional

Returns

Observable

public skip(count: number): Observable

Parameters

• count: number

Returns

Observable

public skipLast(count: number): Observable

Parameters

• count: number

Returns

Observable

public skipUntil(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public skipUntil(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public skipWhile(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public some(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public startWith(values?: Array<T>): Observable

Parameters

• values?: Array<T> optional

Returns

Observable

public startWith(scheduler: IScheduler, values?: Array<T>): Observable

Parameters

• scheduler: IScheduler

• values?: Array<T> optional

Returns

Observable

public subscribe(observer: Observer): IDisposable

Parameters

• observer: Observer

Returns

IDisposable

public subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public subscribe(observer: Observer): IDisposable

Parameters

• observer: Observer

Returns

IDisposable

public subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public subscribe(observer: Observer): IDisposable

Parameters

• observer: Observer

Returns

IDisposable

public subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public subscribeOn(scheduler: IScheduler): Observable

Parameters

• scheduler: IScheduler

Returns

Observable

public sum(keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number, thisArg?: any): Observable

Parameters

• keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number optional

• thisArg?: any optional

Returns

Observable

public switch(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public switchLatest(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public take(count: number, scheduler?: IScheduler): Observable

Parameters

• count: number

• scheduler?: IScheduler optional

Returns

Observable

public takeLast(count: number, scheduler?: IScheduler): Observable

Parameters

• count: number

• scheduler?: IScheduler optional

Returns

Observable

public takeLastBuffer(count: number): Observable

Parameters

• count: number

Returns

Observable

public takeUntil(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public takeUntil(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public takeWhile(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public toArray(): Observable

Returns

Observable

public toNotifier(): (notification: Rx.Notification<T>) => void

Returns

(notification: Rx.Notification<T>) => void

public toPromise(promiseCtor: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => TPromise): TPromise

Converts an existing observable sequence to an ES6 Compatible Promise

example

var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);

Parameters

• promiseCtor: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => TPromise

  The constructor of the promise.

Returns

TPromise

An ES6 compatible promise with the last value from the observable sequence.

public toPromise(promiseCtor?: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => Rx.IPromise<T>): IPromise

Converts an existing observable sequence to an ES6 Compatible Promise

example

var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);

// With config Rx.config.Promise = RSVP.Promise; var promise = Rx.Observable.return(42).toPromise();

Parameters

• promiseCtor?: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => Rx.IPromise<T> optional

Returns

IPromise

An ES6 compatible promise with the last value from the observable sequence.

public where(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public windowWithCount(count: number, skip?: number): Observable

Parameters

• count: number

• skip?: number optional

Returns

Observable

public zip(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: Observable

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public zip(second: IPromise, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: IPromise

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: Observable, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: IPromise, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: IPromise, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• fifth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult

Returns

Observable

public zip(second: Observable[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable

Parameters

• second: Observable[]

• resultSelector: (left: T, ...right: TOther[]) => TResult

Returns

Observable

public zip(second: IPromise[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable

Parameters

• second: IPromise[]

• resultSelector: (left: T, ...right: TOther[]) => TResult

Returns

Observable

public aggregate(accumulator: (acc: T, value: T) => T): Observable

Parameters

• accumulator: (acc: T, value: T) => T

Returns

Observable

public aggregate(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable

Parameters

• seed: TAcc

• accumulator: (acc: TAcc, value: T) => TAcc

Returns

Observable

public all(predicate?: (value: T) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T) => boolean optional

• thisArg?: any optional

Returns

Observable

public amb(rightSource: Observable): Observable

Parameters

• rightSource: Observable

Returns

Observable

public amb(rightSource: IPromise): Observable

Parameters

• rightSource: IPromise

Returns

Observable

public any(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public asObservable(): Observable

Returns

Observable

public asObserver(): Observer

Returns

Observer

public average(keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number, thisArg?: any): Observable

Parameters

• keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number optional

• thisArg?: any optional

Returns

Observable

public bufferWithCount(count: number, skip?: number): Observable

Parameters

• count: number

• skip?: number optional

Returns

Observable

public catch(handler: (exception: any) => Rx.Observable<T>): Observable

Parameters

• handler: (exception: any) => Rx.Observable<T>

Returns

Observable

public catch(handler: (exception: any) => Rx.IPromise<T>): Observable

Parameters

• handler: (exception: any) => Rx.IPromise<T>

Returns

Observable

public catch(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public catchException(handler: (exception: any) => Rx.Observable<T>): Observable

Parameters

• handler: (exception: any) => Rx.Observable<T>

Returns

Observable

public catchException(handler: (exception: any) => Rx.IPromise<T>): Observable

Parameters

• handler: (exception: any) => Rx.IPromise<T>

Returns

Observable

public catchException(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public checked(): Observer

Returns

Observer

public combineLatest(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: Observable

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public combineLatest(second: IPromise, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: IPromise

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: Observable, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: IPromise, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public combineLatest(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• fifth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult

Returns

Observable

public combineLatest(souces: Observable[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable

Parameters

• souces: Observable[]

• resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult

Returns

Observable

public combineLatest(souces: IPromise[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable

Parameters

• souces: IPromise[]

• resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult

Returns

Observable

public concat(sources?: Observable[]): Observable

Parameters

• sources?: Observable[] optional

Returns

Observable

public concat(sources?: IPromise[]): Observable

Parameters

• sources?: IPromise[] optional

Returns

Observable

public concat(sources: Observable[]): Observable

Parameters

• sources: Observable[]

Returns

Observable

public concat(sources: IPromise[]): Observable

Parameters

• sources: IPromise[]

Returns

Observable

public concatAll(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public concatMap(selector: (value: T, index: number) => Rx.Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public concatMap(selector: (value: T, index: number) => Rx.IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public concatMap(selector: (value: T, index: number) => Rx.Observable<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<R>

Returns

Observable

public concatMap(selector: (value: T, index: number) => Rx.IPromise<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<R>

Returns

Observable

public concatMap(sequence: Observable): Observable

Parameters

• sequence: Observable

Returns

Observable

public concatObservable(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public contains(value: T in Rx.Observable<T>): Observable

Parameters

• value: T in Rx.Observable<T>

Returns

Observable

public contains(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable

Parameters

• value: TOther

• comparer: (value1: T, value2: TOther) => boolean

Returns

Observable

public count(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public defaultIfEmpty(defaultValue?: T in Rx.Observable<T>): Observable

Parameters

• defaultValue?: T in Rx.Observable<T> optional

Returns

Observable

public dematerialize(): Observable

Returns

Observable

public dispose()

public distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable

Parameters

• skipParameter: boolean

• valueSerializer: (value: T) => string

Returns

Observable

public distinct(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector?: (value: T) => TKey optional

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable

Parameters

• skipParameter: boolean

• comparer: (x: T, y: T) => boolean

Returns

Observable

public distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable

Parameters

• keySelector?: (value: T) => TValue optional

• comparer?: (x: TValue, y: TValue) => boolean optional

Returns

Observable

public do(observer: Observer): Observable

Parameters

• observer: Observer

Returns

Observable

public do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

Observable

public doAction(observer: Observer): Observable

Parameters

• observer: Observer

Returns

Observable

public doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

Observable

public elementAt(index: number): Observable

Parameters

• index: number

Returns

Observable

public elementAtOrDefault(index: number, defaultValue?: T in Rx.Observable<T>): Observable

Parameters

• index: number

• defaultValue?: T in Rx.Observable<T> optional

Returns

Observable

public every(predicate?: (value: T) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T) => boolean optional

• thisArg?: any optional

Returns

Observable

public filter(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public finalValue(): Observable

Returns

Observable

public finally(action: () => void): Observable

Parameters

• action: () => void

Returns

Observable

public finallyAction(action: () => void): Observable

Parameters

• action: () => void

Returns

Observable

public find(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public findIndex(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public first(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public firstOrDefault(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, defaultValue?: T in Rx.Observable<T>, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• defaultValue?: T in Rx.Observable<T> optional

• thisArg?: any optional

Returns

Observable

public flatMap(selector: (value: T) => Rx.Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.Observable<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public flatMap(selector: (value: T) => Rx.IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public flatMap(selector: (value: T) => Rx.Observable<TResult>): Observable

Parameters

• selector: (value: T) => Rx.Observable<TResult>

Returns

Observable

public flatMap(selector: (value: T) => Rx.IPromise<TResult>): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TResult>

Returns

Observable

public flatMap(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public flatMap(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public flatMapLatest(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

  A transform function to apply to each source element; the second parameter of the function represents the index of the source element.

• thisArg?: any optional

Returns

Observable

An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences and that at any point in time produces the elements of the most recent inner observable sequence that has been received.

public forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public groupBy(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• skipElementSelector?: boolean optional

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public groupBy(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• elementSelector: (value: T) => TElement

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public groupByUntil(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: Rx.GroupedObservable<TKey, T>) => Rx.Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• skipElementSelector: boolean

• durationSelector: (group: Rx.GroupedObservable<TKey, T>) => Rx.Observable<TDuration>

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: Rx.GroupedObservable<TKey, TElement>) => Rx.Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable

Parameters

• keySelector: (value: T) => TKey

• elementSelector: (value: T) => TElement

• durationSelector: (group: Rx.GroupedObservable<TKey, TElement>) => Rx.Observable<TDuration>

• keySerializer?: (key: TKey) => string optional

Returns

Observable

public hasObservers(): boolean

Returns

boolean

public ignoreElements(): Observable

Returns

Observable

public isEmpty(): Observable

Returns

Observable

public last(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public lastOrDefault(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, defaultValue?: T in Rx.Observable<T>, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• defaultValue?: T in Rx.Observable<T> optional

• thisArg?: any optional

Returns

Observable

public map(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

• thisArg?: any optional

Returns

Observable

public materialize(): Observable

Returns

Observable

public max(comparer?: (value1: T, value2: T) => number): Observable

Parameters

• comparer?: (value1: T, value2: T) => number optional

Returns

Observable

public maxBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable

Parameters

• keySelector: (item: T) => TKey

• comparer: (value1: TKey, value2: TKey) => number

Returns

Observable

public maxBy(keySelector: (item: T) => number): Observable

Parameters

• keySelector: (item: T) => number

Returns

Observable

public merge(maxConcurrent: number): T in Rx.Observable<T>

Parameters

• maxConcurrent: number

Returns

T in Rx.Observable<T>

public merge(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public merge(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public mergeAll(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public mergeObservable(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public min(comparer?: (value1: T, value2: T) => number): Observable

Parameters

• comparer?: (value1: T, value2: T) => number optional

Returns

Observable

public minBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable

Parameters

• keySelector: (item: T) => TKey

• comparer: (value1: TKey, value2: TKey) => number

Returns

Observable

public minBy(keySelector: (item: T) => number): Observable

Parameters

• keySelector: (item: T) => number

Returns

Observable

public observeOn(scheduler: IScheduler): Observable

Parameters

• scheduler: IScheduler

Returns

Observable

public onCompleted()

public onCompleted()

public onError(exception: any)

Parameters

• exception: any

public onError(exception: any)

Parameters

• exception: any

public onErrorResumeNext(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public onErrorResumeNext(second: IPromise): Observable

Parameters

• second: IPromise

Returns

Observable

public onNext(value: T in Rx.IObserver<T>)

Parameters

• value: T in Rx.IObserver<T>

public onNext(value: T in Rx.IObserver<T>)

Parameters

• value: T in Rx.IObserver<T>

public reduce(accumulator: (acc: T, value: T) => T): Observable

Parameters

• accumulator: (acc: T, value: T) => T

Returns

Observable

public reduce(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable

Parameters

• accumulator: (acc: TAcc, value: T) => TAcc

• seed: TAcc

Returns

Observable

public repeat(repeatCount?: number): Observable

Parameters

• repeatCount?: number optional

Returns

Observable

public retry(retryCount?: number): Observable

Parameters

• retryCount?: number optional

Returns

Observable

public scan(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable

Parameters

• seed: TAcc

• accumulator: (acc: TAcc, value: T) => TAcc

Returns

Observable

public scan(accumulator: (acc: T, value: T) => T): Observable

Parameters

• accumulator: (acc: T, value: T) => T

Returns

Observable

public select(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

• thisArg?: any optional

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<T2>

• resultSelector: (value1: T, value2: T2, index: number) => R

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.Observable<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.Observable<R>

Returns

Observable

public selectConcat(selector: (value: T, index: number) => Rx.IPromise<R>): Observable

Parameters

• selector: (value: T, index: number) => Rx.IPromise<R>

Returns

Observable

public selectConcat(sequence: Observable): Observable

Parameters

• sequence: Observable

Returns

Observable

public selectMany(selector: (value: T) => Rx.Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.Observable<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public selectMany(selector: (value: T) => Rx.IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TOther>

• resultSelector: (item: T, other: TOther) => TResult

Returns

Observable

public selectMany(selector: (value: T) => Rx.Observable<TResult>): Observable

Parameters

• selector: (value: T) => Rx.Observable<TResult>

Returns

Observable

public selectMany(selector: (value: T) => Rx.IPromise<TResult>): Observable

Parameters

• selector: (value: T) => Rx.IPromise<TResult>

Returns

Observable

public selectMany(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public selectMany(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public selectSwitch(selector: (value: T, index: number, source: Rx.Observable<T>) => TResult, thisArg?: any): Observable

Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

Parameters

• selector: (value: T, index: number, source: Rx.Observable<T>) => TResult

  A transform function to apply to each source element; the second parameter of the function represents the index of the source element.

• thisArg?: any optional

Returns

Observable

An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences and that at any point in time produces the elements of the most recent inner observable sequence that has been received.

public sequenceEqual(second: Observable, comparer: (value1: T, value2: TOther) => number): Observable

Parameters

• second: Observable

• comparer: (value1: T, value2: TOther) => number

Returns

Observable

public sequenceEqual(second: IPromise, comparer: (value1: T, value2: TOther) => number): Observable

Parameters

• second: IPromise

• comparer: (value1: T, value2: TOther) => number

Returns

Observable

public sequenceEqual(second: Observable): Observable

Parameters

• second: Observable

Returns

Observable

public sequenceEqual(second: IPromise): Observable

Parameters

• second: IPromise

Returns

Observable

public sequenceEqual(second: Array<TOther>, comparer: (value1: T, value2: TOther) => number): Observable

Parameters

• second: Array<TOther>

• comparer: (value1: T, value2: TOther) => number

Returns

Observable

public sequenceEqual(second: Array<T>): Observable

Parameters

• second: Array<T>

Returns

Observable

public single(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public singleOrDefault(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, defaultValue?: T in Rx.Observable<T>, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• defaultValue?: T in Rx.Observable<T> optional

• thisArg?: any optional

Returns

Observable

public skip(count: number): Observable

Parameters

• count: number

Returns

Observable

public skipLast(count: number): Observable

Parameters

• count: number

Returns

Observable

public skipUntil(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public skipUntil(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public skipWhile(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public some(predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate?: (value: T, index: number, source: Rx.Observable<T>) => boolean optional

• thisArg?: any optional

Returns

Observable

public startWith(values?: Array<T>): Observable

Parameters

• values?: Array<T> optional

Returns

Observable

public startWith(scheduler: IScheduler, values?: Array<T>): Observable

Parameters

• scheduler: IScheduler

• values?: Array<T> optional

Returns

Observable

public subscribe(observer: Observer): IDisposable

Parameters

• observer: Observer

Returns

IDisposable

public subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public subscribe(observer: Observer): IDisposable

Parameters

• observer: Observer

Returns

IDisposable

public subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public subscribe(observer: Observer): IDisposable

Parameters

• observer: Observer

Returns

IDisposable

public subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable

Parameters

• onNext?: (value: T) => void optional

• onError?: (exception: any) => void optional

• onCompleted?: () => void optional

Returns

IDisposable

public subscribeOn(scheduler: IScheduler): Observable

Parameters

• scheduler: IScheduler

Returns

Observable

public sum(keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number, thisArg?: any): Observable

Parameters

• keySelector?: (value: T, index: number, source: Rx.Observable<T>) => number optional

• thisArg?: any optional

Returns

Observable

public switch(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public switchLatest(): T in Rx.Observable<T>

Returns

T in Rx.Observable<T>

public take(count: number, scheduler?: IScheduler): Observable

Parameters

• count: number

• scheduler?: IScheduler optional

Returns

Observable

public takeLast(count: number, scheduler?: IScheduler): Observable

Parameters

• count: number

• scheduler?: IScheduler optional

Returns

Observable

public takeLastBuffer(count: number): Observable

Parameters

• count: number

Returns

Observable

public takeUntil(other: Observable): Observable

Parameters

• other: Observable

Returns

Observable

public takeUntil(other: IPromise): Observable

Parameters

• other: IPromise

Returns

Observable

public takeWhile(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public toArray(): Observable

Returns

Observable

public toNotifier(): (notification: Rx.Notification<T>) => void

Returns

(notification: Rx.Notification<T>) => void

public toPromise(promiseCtor: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => TPromise): TPromise

Converts an existing observable sequence to an ES6 Compatible Promise

example

var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);

Parameters

• promiseCtor: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => TPromise

  The constructor of the promise.

Returns

TPromise

An ES6 compatible promise with the last value from the observable sequence.

public toPromise(promiseCtor?: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => Rx.IPromise<T>): IPromise

Converts an existing observable sequence to an ES6 Compatible Promise

example

var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);

// With config Rx.config.Promise = RSVP.Promise; var promise = Rx.Observable.return(42).toPromise();

Parameters

• promiseCtor?: new(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void) => Rx.IPromise<T> optional

Returns

IPromise

An ES6 compatible promise with the last value from the observable sequence.

public where(predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean, thisArg?: any): Observable

Parameters

• predicate: (value: T, index: number, source: Rx.Observable<T>) => boolean

• thisArg?: any optional

Returns

Observable

public windowWithCount(count: number, skip?: number): Observable

Parameters

• count: number

• skip?: number optional

Returns

Observable

public zip(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: Observable

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public zip(second: IPromise, resultSelector: (v1: T, v2: T2) => TResult): Observable

Parameters

• second: IPromise

• resultSelector: (v1: T, v2: T2) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: Observable, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: IPromise, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: IPromise, third: IPromise, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: Observable

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: Observable, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: Observable

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: IPromise, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: IPromise, third: IPromise, fourth: IPromise, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable

Parameters

• second: IPromise

• third: IPromise

• fourth: IPromise

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult

Returns

Observable

public zip(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable

Parameters

• second: Observable

• third: Observable

• fourth: Observable

• fifth: Observable

• resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult

Returns

Observable

public zip(second: Observable[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable

Parameters

• second: Observable[]

• resultSelector: (left: T, ...right: TOther[]) => TResult

Returns

Observable

public zip(second: IPromise[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable

Parameters

• second: IPromise[]

• resultSelector: (left: T, ...right: TOther[]) => TResult

Returns

Observable