Skip to content

Instantly share code, notes, and snippets.

@ckknight

ckknight/rx.flow.js

Created October 17, 2015 04:11
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ckknight/44150bd101a3d0c36906 to your computer and use it in GitHub Desktop.
Save ckknight/44150bd101a3d0c36906 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
rx.flow.js
declare module "rx" {
declare interface IPromise<T> {
then<R>(
onFulfilled: (
value: T
) => IPromise<R>,
onRejected: (
reason: any
) => IPromise<R>
): IPromise<R>;
then<R>(
onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R
): IPromise<R>;
then<R>(
onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>
): IPromise<R>;
then<R>(
onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R
): IPromise<R>;
}
declare var config: {
Promise: {
new<T>(
resolver: (
resolvePromise: (
value: T
) => void,
rejectPromise: (
reason: any
) => void
) => void
): IPromise<T>;
},
useNativeEvents: boolean,
};
declare class ScheduledItem<TTime> {
constructor(
scheduler: IScheduler,
state: any,
action: (
scheduler: IScheduler, state: any
) => IDisposable,
dueTime: TTime,
comparer?: (
x: TTime, y: TTime
) => number
): any;
scheduler: IScheduler;
state: TTime;
action(scheduler: IScheduler, state: any): IDisposable;
dueTime: TTime;
comparer(x: TTime, y: TTime): number;
disposable: SingleAssignmentDisposable;
invoke(): void;
compareTo(other: ScheduledItem<TTime>): number;
isCancelled(): boolean;
invokeCore(): IDisposable;
}
declare interface IDisposable {
dispose(): void;
}
declare class Disposable extends IDisposable {
constructor(action: () => void): any;
static create(action: () => void): IDisposable;
static empty: IDisposable;
}
declare class CompositeDisposable extends Disposable {
constructor(...disposables: Array<IDisposable>): CompositeDisposable;
constructor(disposables: Array<IDisposable>): CompositeDisposable;
isDisposed: boolean;
length: number;
add(item: IDisposable): void;
remove(item: IDisposable): boolean;
toArray(): Array<IDisposable>;
}
declare class SingleAssignmentDisposable extends Disposable {
constructor(): any;
isDisposed: boolean;
current: IDisposable;
getDisposable(): IDisposable;
setDisposable(value: IDisposable): void;
}
declare class SerialDisposable extends SingleAssignmentDisposable {
constructor(): any;
}
declare class RefCountDisposable extends Disposable {
constructor(disposable: IDisposable): any;
isDisposed: boolean;
getDisposable(): IDisposable;
}
declare interface IScheduler {
now(): number;
isScheduler(value: any): boolean;
schedule(action: () => void): IDisposable;
scheduleWithState<TState>(
state: TState,
action: (
scheduler: IScheduler, state: TState
) => IDisposable
): IDisposable;
scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
scheduleWithAbsoluteAndState<TState>(
state: TState,
dueTime: number,
action: (
scheduler: IScheduler, state: TState
) => IDisposable
): IDisposable;
scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
scheduleWithRelativeAndState<TState>(
state: TState,
dueTime: number,
action: (
scheduler: IScheduler, state: TState
) => IDisposable
): IDisposable;
scheduleRecursive(action: (action: () => void) => void): IDisposable;
scheduleRecursiveWithState<TState>(
state: TState,
action: (
state: TState, action: (state: TState) => void
) => void
): IDisposable;
scheduleRecursiveWithAbsolute(
dueTime: number, action: (action: (dueTime: number) => void) => void
): IDisposable;
scheduleRecursiveWithAbsoluteAndState<TState>(
state: TState,
dueTime: number,
action: (
state: TState, action: (state: TState, dueTime: number) => void
) => void
): IDisposable;
scheduleRecursiveWithRelative(
dueTime: number, action: (action: (dueTime: number) => void) => void
): IDisposable;
scheduleRecursiveWithRelativeAndState<TState>(
state: TState,
dueTime: number,
action: (
state: TState, action: (state: TState, dueTime: number) => void
) => void
): IDisposable;
schedulePeriodic(period: number, action: () => void): IDisposable;
schedulePeriodicWithState<TState>(
state: TState, period: number, action: (state: TState) => TState
): IDisposable;
catch(handler: (exception: any) => boolean): IScheduler;
catchException(handler: (exception: any) => boolean): IScheduler;
}
declare class Scheduler extends IScheduler {
constructor(
now: (
) => number,
schedule: (
state: any,
action: (
scheduler: IScheduler, state: any
) => IDisposable
) => IDisposable,
scheduleRelative: (
state: any,
dueTime: number,
action: (
scheduler: IScheduler, state: any
) => IDisposable
) => IDisposable,
scheduleAbsolute: (
state: any,
dueTime: number,
action: (
scheduler: IScheduler, state: any
) => IDisposable
) => IDisposable
): Scheduler;
static normalize(timeSpan: number): number;
static immediate: IScheduler;
static currentThread: ICurrentThreadScheduler;
static default: IScheduler;
static timeout: IScheduler;
}
declare interface ICurrentThreadScheduler extends IScheduler {
scheduleRequired(): boolean;
}
declare class Notification<T> {
accept(observer: IObserver<T>): void;
accept<TResult>(
onNext: (
value: T
) => TResult,
onError?: (
exception: any
) => TResult,
onCompleted?: (
) => TResult
): TResult;
toObservable(scheduler?: IScheduler): Observable<T>;
hasValue: boolean;
equals(other: Notification<T>): boolean;
kind: string;
value: T;
exception: any;
createOnNext<T>(value: T): Notification<T>;
createOnError<T>(exception: any): Notification<T>;
createOnCompleted<T>(): Notification<T>;
}
declare interface IObserver<T> {
onNext(value: T): void;
onError(exception: any): void;
onCompleted(): void;
}
declare class Observer<T> extends IObserver<T> {
toNotifier(): (notification: Notification<T>) => void;
asObserver(): Observer<T>;
checked(): Observer<any>;
static notifyOn(scheduler: IScheduler): Observer<T>;
static create(
onNext?: (
value: T
) => void,
onError?: (
exception: any
) => void,
onCompleted?: (
) => void
): Observer<T>;
static fromNotifier(
handler: (notification: Notification<T>, thisArg?: any) => void
): Observer<T>;
}
declare interface IObservable<T> {
subscribe(observer: Observer<T>): IDisposable;
subscribe(
onNext?: (
value: T
) => void,
onError?: (
exception: any
) => void,
onCompleted?: (
) => void
): IDisposable;
subscribeOnNext(onNext: (value: T) => void, thisArg?: any): IDisposable;
subscribeOnError(
onError: (exception: any) => void, thisArg?: any
): IDisposable;
subscribeOnCompleted(onCompleted: () => void, thisArg?: any): IDisposable;
}
declare class Observable<T> extends IObservable<T> {
static create(
subscribe: (observer: Observer<T>) => IDisposable
): Observable<T>;
static create(
subscribe: (observer: Observer<T>) => () => void
): Observable<T>;
static create(subscribe: (observer: Observer<T>) => void): Observable<T>;
static createWithDisposable(
subscribe: (observer: Observer<T>) => IDisposable
): Observable<T>;
observeOn(scheduler: IScheduler): Observable<T>;
subscribeOn(scheduler: IScheduler): Observable<T>;
amb(rightSource: Observable<T>): Observable<T>;
amb(rightSource: IPromise<T>): Observable<T>;
onErrorResumeNext(second: Observable<T>): Observable<T>;
onErrorResumeNext(second: IPromise<T>): Observable<T>;
bufferWithCount(count: number, skip?: number): Observable<Array<T>>;
windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
defaultIfEmpty(defaultValue?: T): Observable<T>;
distinct(
skipParameter: boolean, valueSerializer: (value: T) => string
): Observable<T>;
distinct<TKey>(
keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string
): Observable<T>;
groupBy<TKey,TElement>(
keySelector: (
value: T
) => TKey,
skipElementSelector?: boolean,
keySerializer?: (
key: TKey
) => string
): Observable<GroupedObservable<TKey,T>>;
groupBy<TKey,TElement>(
keySelector: (
value: T
) => TKey,
elementSelector: (
value: T
) => TElement,
keySerializer?: (
key: TKey
) => string
): Observable<GroupedObservable<TKey,TElement>>;
groupByUntil<TKey,TDuration>(
keySelector: (
value: T
) => TKey,
skipElementSelector: boolean,
durationSelector: (
group: GroupedObservable<TKey,T>
) => Observable<TDuration>,
keySerializer?: (
key: TKey
) => string
): Observable<GroupedObservable<TKey,T>>;
groupByUntil<TKey,TElement,TDuration>(
keySelector: (
value: T
) => TKey,
elementSelector: (
value: T
) => TElement,
durationSelector: (
group: GroupedObservable<TKey,TElement>
) => Observable<TDuration>,
keySerializer?: (
key: TKey
) => string
): Observable<GroupedObservable<TKey,TElement>>;
finalValue(): Observable<T>;
aggregate(accumulator: (acc: T, value: T) => T): Observable<T>;
aggregate<TAcc>(
seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc
): Observable<TAcc>;
reduce(accumulator: (acc: T, value: T) => T): Observable<T>;
reduce<TAcc>(
accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc
): Observable<TAcc>;
any(
predicate?: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<boolean>;
some(
predicate?: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<boolean>;
isEmpty(): Observable<boolean>;
all(
predicate?: (value: T) => boolean, thisArg?: any
): Observable<boolean>;
every(
predicate?: (value: T) => boolean, thisArg?: any
): Observable<boolean>;
contains(value: T): Observable<boolean>;
contains<TOther>(
value: TOther, comparer: (value1: T, value2: TOther) => boolean
): Observable<boolean>;
count(
predicate?: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<number>;
sum(
keySelector?: (
value: T, index: number, source: Observable<T>
) => number,
thisArg?: any
): Observable<number>;
minBy<TKey>(
keySelector: (
item: T
) => TKey,
comparer: (
value1: TKey, value2: TKey
) => number
): Observable<T>;
minBy(keySelector: (item: T) => number): Observable<T>;
min(comparer?: (value1: T, value2: T) => number): Observable<T>;
maxBy<TKey>(
keySelector: (
item: T
) => TKey,
comparer: (
value1: TKey, value2: TKey
) => number
): Observable<T>;
maxBy(keySelector: (item: T) => number): Observable<T>;
max(comparer?: (value1: T, value2: T) => number): Observable<number>;
average(
keySelector?: (
value: T, index: number, source: Observable<T>
) => number,
thisArg?: any
): Observable<number>;
sequenceEqual<TOther>(
second: Observable<TOther>,
comparer: (
value1: T, value2: TOther
) => number
): Observable<boolean>;
sequenceEqual<TOther>(
second: IPromise<TOther>,
comparer: (
value1: T, value2: TOther
) => number
): Observable<boolean>;
sequenceEqual(second: Observable<T>): Observable<boolean>;
sequenceEqual(second: IPromise<T>): Observable<boolean>;
sequenceEqual<TOther>(
second: Array<TOther>, comparer: (value1: T, value2: TOther) => number
): Observable<boolean>;
sequenceEqual(second: Array<T>): Observable<boolean>;
elementAt(index: number): Observable<T>;
single(
predicate?: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
first(
predicate?: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
last(
predicate?: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
find(
predicate: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
findIndex(
predicate: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<number>;
pausable(pauser?: Observable<boolean>): PausableObservable<T>;
pausableBuffered(pauser?: Observable<boolean>): PausableObservable<T>;
controlled(enableQueue?: boolean): ControlledObservable<T>;
pairwise(): Observable<Array<T>>;
partition(
predicate: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg: any
): Array<Observable<T>>;
join<TRight,TDurationLeft,TDurationRight,TResult>(
right: Observable<TRight>,
leftDurationSelector: (
leftItem: T
) => Observable<TDurationLeft>,
rightDurationSelector: (
rightItem: TRight
) => Observable<TDurationRight>,
resultSelector: (
leftItem: T, rightItem: TRight
) => TResult
): Observable<TResult>;
groupJoin<TRight,TDurationLeft,TDurationRight,TResult>(
right: Observable<TRight>,
leftDurationSelector: (
leftItem: T
) => Observable<TDurationLeft>,
rightDurationSelector: (
rightItem: TRight
) => Observable<TDurationRight>,
resultSelector: (
leftItem: T, rightItem: Observable<TRight>
) => TResult
): Observable<TResult>;
window<TWindowOpening>(
windowOpenings: Observable<TWindowOpening>
): Observable<Observable<T>>;
window<TWindowClosing>(
windowClosingSelector: () => Observable<TWindowClosing>
): Observable<Observable<T>>;
window<TWindowOpening,TWindowClosing>(
windowOpenings: Observable<TWindowOpening>,
windowClosingSelector: (
) => Observable<TWindowClosing>
): Observable<Observable<T>>;
buffer<TBufferOpening>(
bufferOpenings: Observable<TBufferOpening>
): Observable<Array<T>>;
buffer<TBufferClosing>(
bufferClosingSelector: () => Observable<TBufferClosing>
): Observable<Array<T>>;
buffer<TBufferOpening,TBufferClosing>(
bufferOpenings: Observable<TBufferOpening>,
bufferClosingSelector: (
) => Observable<TBufferClosing>
): Observable<Array<T>>;
let<TResult>(
selector: (source: Observable<T>) => Observable<TResult>
): Observable<TResult>;
letBind<TResult>(
selector: (source: Observable<T>) => Observable<TResult>
): Observable<TResult>;
doWhile(condition: () => boolean): Observable<T>;
expand(
selector: (item: T) => Observable<T>, scheduler?: IScheduler
): Observable<T>;
forkJoin<TSecond,TResult>(
second: Observable<TSecond>,
resultSelector: (
left: T, right: TSecond
) => TResult
): Observable<TResult>;
forkJoin<TSecond,TResult>(
second: IPromise<TSecond>,
resultSelector: (
left: T, right: TSecond
) => TResult
): Observable<TResult>;
manySelect<TResult>(
selector: (
item: Observable<T>, index: number, source: Observable<T>
) => TResult,
scheduler?: IScheduler
): Observable<TResult>;
and<T2>(other: Observable<T2>): Pattern2<T,T2>;
thenDo<TR>(selector: (item1: T) => TR): Plan<TR>;
delay(dueTime: Date, scheduler?: IScheduler): Observable<T>;
delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
debounce(dueTime: number, scheduler?: IScheduler): Observable<T>;
throttleWithTimeout(
dueTime: number, scheduler?: IScheduler
): Observable<T>;
throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
timestamp(scheduler?: IScheduler): Observable<Timestamp<T>>;
sample(interval: number, scheduler?: IScheduler): Observable<T>;
sample<TSample>(
sampler: Observable<TSample>, scheduler?: IScheduler
): Observable<T>;
timeout(
dueTime: Date, other?: Observable<T>, scheduler?: IScheduler
): Observable<T>;
timeout(
dueTime: number, other?: Observable<T>, scheduler?: IScheduler
): Observable<T>;
delaySubscription(dueTime: number, scheduler?: IScheduler): Observable<T>;
delayWithSelector(
delayDurationSelector: (item: T) => number
): Observable<T>;
delayWithSelector(
subscriptionDelay: number, delayDurationSelector: (item: T) => number
): Observable<T>;
timeoutWithSelector<TTimeout>(
firstTimeout: Observable<TTimeout>,
timeoutdurationSelector?: (
item: T
) => Observable<TTimeout>,
other?: Observable<T>
): Observable<T>;
debounce<TTimeout>(
debounceDurationSelector: (item: T) => Observable<TTimeout>
): Observable<T>;
throttle<TTimeout>(
debounceDurationSelector: (item: T) => Observable<TTimeout>
): Observable<T>;
skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
takeLastWithTime(
duration: number,
timerScheduler?: IScheduler,
loopScheduler?: IScheduler
): Observable<T>;
takeLastBufferWithTime(
duration: number, scheduler?: IScheduler
): Observable<Array<T>>;
takeWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
skipWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable<T>;
skipUntilWithTime(
duration: number, scheduler?: IScheduler
): Observable<T>;
takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
takeUntilWithTime(
duration: number, scheduler?: IScheduler
): Observable<T>;
windowWithTime(
timeSpan: number, timeShift: number, scheduler?: IScheduler
): Observable<Observable<T>>;
windowWithTime(
timeSpan: number, scheduler?: IScheduler
): Observable<Observable<T>>;
windowWithTimeOrCount(
timeSpan: number, count: number, scheduler?: IScheduler
): Observable<Observable<T>>;
bufferWithTime(
timeSpan: number, timeShift: number, scheduler?: IScheduler
): Observable<Array<T>>;
bufferWithTime(
timeSpan: number, scheduler?: IScheduler
): Observable<Array<T>>;
bufferWithTimeOrCount(
timeSpan: number, count: number, scheduler?: IScheduler
): Observable<Array<T>>;
forEach(
onNext?: (
value: T
) => void,
onError?: (
exception: any
) => void,
onCompleted?: (
) => void
): IDisposable;
toArray(): Observable<Array<T>>;
catch(handler: (exception: any) => Observable<T>): Observable<T>;
catchException(handler: (exception: any) => Observable<T>): Observable<T>;
catch(handler: (exception: any) => IPromise<T>): Observable<T>;
catchException(handler: (exception: any) => IPromise<T>): Observable<T>;
catch(second: Observable<T>): Observable<T>;
catchException(second: Observable<T>): Observable<T>;
combineLatest<T2,TResult>(
second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult
): Observable<TResult>;
combineLatest<T2,TResult>(
second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult
): Observable<TResult>;
combineLatest<T2,T3,TResult>(
second: Observable<T2>,
third: Observable<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
combineLatest<T2,T3,T4,T5,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
fifth: Observable<T5>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4, v5: T5
) => TResult
): Observable<TResult>;
combineLatest<TOther,TResult>(
souces: Array<Observable<TOther>>,
resultSelector: (
firstValue: T, ...otherValues: Array<TOther>
) => TResult
): Observable<TResult>;
combineLatest<TOther,TResult>(
souces: Array<IPromise<TOther>>,
resultSelector: (
firstValue: T, ...otherValues: Array<TOther>
) => TResult
): Observable<TResult>;
withLatestFrom<T2,TResult>(
second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult
): Observable<TResult>;
withLatestFrom<T2,TResult>(
second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,TResult>(
second: Observable<T2>,
third: Observable<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
withLatestFrom<T2,T3,T4,T5,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
fifth: Observable<T5>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4, v5: T5
) => TResult
): Observable<TResult>;
withLatestFrom<TOther,TResult>(
souces: Array<Observable<TOther>>,
resultSelector: (
firstValue: T, ...otherValues: Array<TOther>
) => TResult
): Observable<TResult>;
withLatestFrom<TOther,TResult>(
souces: Array<IPromise<TOther>>,
resultSelector: (
firstValue: T, ...otherValues: Array<TOther>
) => TResult
): Observable<TResult>;
concat(...sources: Array<Observable<T>>): Observable<T>;
concat(...sources: Array<IPromise<T>>): Observable<T>;
concat(sources: Array<Observable<T>>): Observable<T>;
concat(sources: Array<IPromise<T>>): Observable<T>;
concatAll(): T;
concatObservable(): T;
concatMap<T2,R>(
selector: (
value: T, index: number
) => Observable<T2>,
resultSelector: (
value1: T, value2: T2, index: number
) => R
): Observable<R>;
concatMap<T2,R>(
selector: (
value: T, index: number
) => IPromise<T2>,
resultSelector: (
value1: T, value2: T2, index: number
) => R
): Observable<R>;
concatMap<R>(
selector: (value: T, index: number) => Observable<R>
): Observable<R>;
concatMap<R>(
selector: (value: T, index: number) => IPromise<R>
): Observable<R>;
concatMap<R>(sequence: Observable<R>): Observable<R>;
merge(maxConcurrent: number): T;
merge(other: Observable<T>): Observable<T>;
merge(other: IPromise<T>): Observable<T>;
mergeAll(): T;
mergeObservable(): T;
skipUntil<T2>(other: Observable<T2>): Observable<T>;
skipUntil<T2>(other: IPromise<T2>): Observable<T>;
switch(): T;
switchLatest(): T;
takeUntil<T2>(other: Observable<T2>): Observable<T>;
takeUntil<T2>(other: IPromise<T2>): Observable<T>;
zip<T2,TResult>(
second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult
): Observable<TResult>;
zip<T2,TResult>(
second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult
): Observable<TResult>;
zip<T2,T3,TResult>(
second: Observable<T2>,
third: Observable<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
zip<T2,T3,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
zip<T2,T3,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
zip<T2,T3,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: Observable<T2>,
third: IPromise<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: Observable<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,TResult>(
second: IPromise<T2>,
third: IPromise<T3>,
fourth: IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => TResult
): Observable<TResult>;
zip<T2,T3,T4,T5,TResult>(
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
fifth: Observable<T5>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4, v5: T5
) => TResult
): Observable<TResult>;
zip<TOther,TResult>(
second: Array<Observable<TOther>>,
resultSelector: (
left: T, ...right: Array<TOther>
) => TResult
): Observable<TResult>;
zip<TOther,TResult>(
second: Array<IPromise<TOther>>,
resultSelector: (
left: T, ...right: Array<TOther>
) => TResult
): Observable<TResult>;
asObservable(): Observable<T>;
dematerialize<TOrigin>(): Observable<TOrigin>;
distinctUntilChanged(
skipParameter: boolean, comparer: (x: T, y: T) => boolean
): Observable<T>;
distinctUntilChanged<TValue>(
keySelector?: (
value: T
) => TValue,
comparer?: (
x: TValue, y: TValue
) => boolean
): Observable<T>;
do(observer: Observer<T>): Observable<T>;
doAction(observer: Observer<T>): Observable<T>;
tap(observer: Observer<T>): Observable<T>;
do(
onNext?: (
value: T
) => mixed,
onError?: (
exception: any
) => mixed,
onCompleted?: (
) => mixed
): Observable<T>;
doAction(
onNext?: (
value: T
) => void,
onError?: (
exception: any
) => void,
onCompleted?: (
) => void
): Observable<T>;
tap(
onNext?: (
value: T
) => void,
onError?: (
exception: any
) => void,
onCompleted?: (
) => void
): Observable<T>;
doOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
doOnError(
onError: (exception: any) => void, thisArg?: any
): Observable<T>;
doOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
tapOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
tapOnError(
onError: (exception: any) => void, thisArg?: any
): Observable<T>;
tapOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
finally(action: () => void): Observable<T>;
finallyAction(action: () => void): Observable<T>;
ignoreElements(): Observable<T>;
materialize(): Observable<Notification<T>>;
repeat(repeatCount?: number): Observable<T>;
retry(retryCount?: number): Observable<T>;
scan<TAcc>(
accumulator: (
acc: TAcc, value: T, index?: number, source?: Observable<TAcc>
) => TAcc,
seed: TAcc
): Observable<TAcc>;
scan(
accumulator: (
acc: T, value: T, index?: number, source?: Observable<T>
) => T
): Observable<T>;
skipLast(count: number): Observable<T>;
startWith(...values: Array<T>): Observable<T>;
startWith(scheduler: IScheduler, ...values: Array<T>): Observable<T>;
takeLast(count: number): Observable<T>;
takeLastBuffer(count: number): Observable<Array<T>>;
select<TResult>(
selector: (
value: T, index: number, source: Observable<T>
) => TResult,
thisArg?: any
): Observable<TResult>;
map<TResult>(
selector: (
value: T, index: number, source: Observable<T>
) => TResult,
thisArg?: any
): Observable<TResult>;
pluck<TResult>(prop: string): Observable<TResult>;
selectMany<TOther,TResult>(
selector: (
value: T
) => Observable<TOther>,
resultSelector: (
item: T, other: TOther
) => TResult
): Observable<TResult>;
selectMany<TOther,TResult>(
selector: (
value: T
) => IPromise<TOther>,
resultSelector: (
item: T, other: TOther
) => TResult
): Observable<TResult>;
selectMany<TResult>(
selector: (value: T) => Observable<TResult>
): Observable<TResult>;
selectMany<TResult>(
selector: (value: T) => IPromise<TResult>
): Observable<TResult>;
selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
selectMany<TResult>(
selector: (value: T) => Array<TResult>
): Observable<TResult>;
flatMap<TOther,TResult>(
selector: (
value: T
) => Observable<TOther>,
resultSelector: (
item: T, other: TOther
) => TResult
): Observable<TResult>;
flatMap<TOther,TResult>(
selector: (
value: T
) => IPromise<TOther>,
resultSelector: (
item: T, other: TOther
) => TResult
): Observable<TResult>;
flatMap<TResult>(
selector: (value: T) => Observable<TResult>
): Observable<TResult>;
flatMap<TResult>(
selector: (value: T) => IPromise<TResult>
): Observable<TResult>;
flatMap<TResult>(other: Observable<TResult>): Observable<TResult>;
flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>;
flatMap<TResult>(
selector: (value: T) => Array<TResult>
): Observable<TResult>;
selectManyObserver<T2,T3,T4>(
onNext: (
value: T, index: number
) => Observable<T2>,
onError: (
exception: any
) => Observable<T3>,
onCompleted: (
) => Observable<T4>,
thisArg?: any
): Observable<T2 | T3 | T4>;
flatMapObserver<T2,T3,T4>(
onNext: (
value: T, index: number
) => Observable<T2>,
onError: (
exception: any
) => Observable<T3>,
onCompleted: (
) => Observable<T4>,
thisArg?: any
): Observable<T2 | T3 | T4>;
selectConcat<T2,R>(
selector: (
value: T, index: number
) => Observable<T2>,
resultSelector: (
value1: T, value2: T2, index: number
) => R
): Observable<R>;
selectConcat<T2,R>(
selector: (
value: T, index: number
) => IPromise<T2>,
resultSelector: (
value1: T, value2: T2, index: number
) => R
): Observable<R>;
selectConcat<R>(
selector: (value: T, index: number) => Observable<R>
): Observable<R>;
selectConcat<R>(
selector: (value: T, index: number) => IPromise<R>
): Observable<R>;
selectConcat<R>(sequence: Observable<R>): Observable<R>;
selectSwitch<TResult>(
selector: (
value: T, index: number, source: Observable<T>
) => Observable<TResult>,
thisArg?: any
): Observable<TResult>;
flatMapLatest<TResult>(
selector: (
value: T, index: number, source: Observable<T>
) => Observable<TResult>,
thisArg?: any
): Observable<TResult>;
switchMap<TResult>(
selector: (
value: T, index: number, source: Observable<T>
) => TResult,
thisArg?: any
): Observable<TResult>;
skip(count: number): Observable<T>;
skipWhile(
predicate: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
take(count: number, scheduler?: IScheduler): Observable<T>;
takeWhile(
predicate: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
where(
predicate: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
filter(
predicate: (
value: T, index: number, source: Observable<T>
) => boolean,
thisArg?: any
): Observable<T>;
toPromise<TPromise>(
promiseCtor: {
new(
resolver: (
resolvePromise: (
value: T
) => void,
rejectPromise: (
reason: any
) => void
) => void
): TPromise;
}
): TPromise;
toPromise(
promiseCtor?: {
new(
resolver: (
resolvePromise: (
value: T
) => void,
rejectPromise: (
reason: any
) => void
) => void
): IPromise<T>;
}
): IPromise<T>;
exclusive<R>(): Observable<R>;
exclusiveMap<I,R>(
selector: (
value: I, index: number, source: Observable<I>
) => R,
thisArg?: any
): Observable<R>;
static using<TResource>(
resourceFactory: (
) => TResource,
observableFactory: (
resource: TResource
) => Observable<T>
): Observable<T>;
static amb(...sources: Array<Observable<T>>): Observable<T>;
static amb(...sources: Array<IPromise<T>>): Observable<T>;
static amb(sources: Array<Observable<T>>): Observable<T>;
static amb(sources: Array<IPromise<T>>): Observable<T>;
static onErrorResumeNext(...sources: Array<Observable<T>>): Observable<T>;
static onErrorResumeNext(...sources: Array<IPromise<T>>): Observable<T>;
static onErrorResumeNext(sources: Array<Observable<T>>): Observable<T>;
static onErrorResumeNext(sources: Array<IPromise<T>>): Observable<T>;
static startAsync(functionAsync: () => IPromise<T>): Observable<T>;
static fromCallback(
func: (callback: (result: T) => any) => any,
context?: any
): (
) => Observable<T>;
static fromCallback<T1>(
func: (
arg1: T1, callback: (result: T) => any
) => any,
context?: any
): (
arg1: T1
) => Observable<T>;
static fromCallback<T1, T2>(
func: (
arg1: T1, arg2: T2, callback: (result: T) => any
) => any,
context?: any
): (
arg1: T1,
arg2: T2
) => Observable<T>;
static fromCallback<T1, T2, T3>(
func: (
arg1: T1, arg2: T2, arg3: T3, callback: (result: T) => any
) => any,
context?: any
): (
arg1: T1,
arg2: T2,
arg3: T3
) => Observable<T>;
static fromCallback<TCallbackResult>(
func: (
callback: Function
) => any,
context: any,
selector: (
args: Array<TCallbackResult>
) => T
): () => Observable<T>;
static fromCallback<T1, TCallbackResult>(
func: (
arg1: T1, callback: Function
) => any,
context: any,
selector: (
args: Array<TCallbackResult>
) => T
): (
arg1: T1
) => Observable<T>;
static fromCallback<T1, T2, TCallbackResult>(
func: (
arg1: T1, arg2: T2, callback: Function
) => any,
context: any,
selector: (
args: Array<TCallbackResult>
) => T
): (
arg1: T1,
arg2: T2
) => Observable<T>;
static fromCallback<T1, T2, T3, TCallbackResult>(
func: (
arg1: T1, arg2: T2, arg3: T3, callback: Function
) => any,
context: any,
selector: (
args: Array<TCallbackResult>
) => T
): (
arg1: T1,
arg2: T2,
arg3: T3
) => Observable<T>;
static fromCallback(
func: (callback: Function) => any, context?: any
): () => Observable<T>;
static fromCallback<T1>(
func: (arg1: T1, callback: Function) => any, context?: any
): (arg1: T1) => Observable<T>;
static fromCallback<T1, T2>(
func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any
): (arg1: T1, arg2: T2) => Observable<T>;
static fromCallback<T1, T2, T3>(
func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context?: any
): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
static fromCallback<TCallbackResult>(
func: Function,
context: any,
selector: (
args: Array<TCallbackResult>
) => T
): (...args: Array<any>) => Observable<T>;
static fromCallback<TCallbackResult>(
func: Function,
context?: any
): (...args: Array<any>) => Observable<T>;
// static fromNodeCallback: {
// $call<T>(
// func: (callback: (err: any, result: T) => any) => any, context?: any
// ): (
//
// ) => Observable<T>;
// $call<T1,T>(
// func: (
// arg1: T1, callback: (err: any, result: T) => any
// ) => any,
// context?: any
// ): (
// arg1: T1
// ) => Observable<T>;
// $call<T1,T2,T>(
// func: (
// arg1: T1, arg2: T2, callback: (err: any, result: T) => any
// ) => any,
// context?: any
// ): (
// arg1: T1, arg2: T2
// ) => Observable<T>;
// $call<T1,T2,T3,T>(
// func: (
// arg1: T1,
// arg2: T2,
// arg3: T3,
// callback: (
// err: any, result: T
// ) => any
// ) => any,
// context?: any
// ): (
// arg1: T1, arg2: T2, arg3: T3
// ) => Observable<T>;
// $call<TC,TR>(
// func: (
// callback: Function
// ) => any,
// context: any,
// selector: (
// results: Array<TC>
// ) => TR
// ): (
//
// ) => Observable<TR>;
// $call<T1,TC,TR>(
// func: (
// arg1: T1, callback: Function
// ) => any,
// context: any,
// selector: (
// results: Array<TC>
// ) => TR
// ): (
// arg1: T1
// ) => Observable<TR>;
// $call<T1,T2,TC,TR>(
// func: (
// arg1: T1, arg2: T2, callback: Function
// ) => any,
// context: any,
// selector: (
// results: Array<TC>
// ) => TR
// ): (
// arg1: T1, arg2: T2
// ) => Observable<TR>;
// $call<T1,T2,T3,TC,TR>(
// func: (
// arg1: T1, arg2: T2, arg3: T3, callback: Function
// ) => any,
// context: any,
// selector: (
// results: Array<TC>
// ) => TR
// ): (
// arg1: T1, arg2: T2, arg3: T3
// ) => Observable<TR>;
// $call<TR>(
// func: (callback: Function) => any, context?: any
// ): (
//
// ) => Observable<TR>;
// $call<T1,TR>(
// func: (arg1: T1, callback: Function) => any, context?: any
// ): (
// arg1: T1
// ) => Observable<TR>;
// $call<T1,T2,TR>(
// func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any
// ): (
// arg1: T1, arg2: T2
// ) => Observable<TR>;
// $call<T1,T2,T3,TR>(
// func: (
// arg1: T1, arg2: T2, arg3: T3, callback: Function
// ) => any,
// context?: any
// ): (
// arg1: T1, arg2: T2, arg3: T3
// ) => Observable<TR>;
// $call<TC,T>(
// func: Function, context: any, selector: (results: Array<TC>) => T
// ): (
// ...args: Array<any>
// ) => Observable<T>;
// $call<T>(
// func: Function, context?: any
// ): (
// ...args: Array<any>
// ) => Observable<T>;
// };
static fromEvent(
element: NodeList,
eventName: string,
selector?: (
arguments: Array<any>
) => T
): Observable<T>;
static fromEvent(
element: Node,
eventName: string,
selector?: (
arguments: Array<any>
) => T
): Observable<T>;
static fromEvent(
element: {
on(name: string, cb: (e: any) => any): void;
off(name: string, cb: (e: any) => any): void;
},
eventName: string,
selector?: (
arguments: Array<any>
) => T
): Observable<T>;
static fromEventPattern(
addHandler: (
handler: Function
) => void,
removeHandler: (
handler: Function
) => void,
selector?: (
arguments: Array<any>
) => T
): Observable<T>;
static start(
func: () => T, context?: any, scheduler?: IScheduler
): Observable<T>;
static toAsync(
func: () => T, context?: any, scheduler?: IScheduler
): (
) => Observable<T>;
static toAsync<T1>(
func: (arg1: T1) => T, context?: any, scheduler?: IScheduler
): (
arg1: T1
) => Observable<T>;
static toAsync<T1>(
func: (arg1?: T1) => T, context?: any, scheduler?: IScheduler
): (
arg1?: T1
) => Observable<T>;
static toAsync<T1>(
func: (
...args: Array<T1>
) => T,
context?: any,
scheduler?: IScheduler
): (
...args: Array<T1>
) => Observable<T>;
static toAsync<T1,T2>(
func: (
arg1: T1, arg2: T2
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2
) => Observable<T>;
static toAsync<T1,T2>(
func: (
arg1: T1, arg2?: T2
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2?: T2
) => Observable<T>;
static toAsync<T1,T2>(
func: (
arg1?: T1, arg2?: T2
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1?: T1, arg2?: T2
) => Observable<T>;
static toAsync<T1,T2>(
func: (
arg1: T1, ...args: Array<T2>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, ...args: Array<T2>
) => Observable<T>;
static toAsync<T1,T2>(
func: (
arg1?: T1, ...args: Array<T2>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1?: T1, ...args: Array<T2>
) => Observable<T>;
static toAsync<T1,T2,T3>(
func: (
arg1: T1, arg2: T2, arg3: T3
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, arg3: T3
) => Observable<T>;
static toAsync<T1,T2,T3>(
func: (
arg1: T1, arg2: T2, arg3?: T3
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, arg3?: T3
) => Observable<T>;
static toAsync<T1,T2,T3>(
func: (
arg1: T1, arg2?: T2, arg3?: T3
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2?: T2, arg3?: T3
) => Observable<T>;
static toAsync<T1,T2,T3>(
func: (
arg1?: T1, arg2?: T2, arg3?: T3
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1?: T1, arg2?: T2, arg3?: T3
) => Observable<T>;
static toAsync<T1,T2,T3>(
func: (
arg1: T1, arg2: T2, ...args: Array<T3>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, ...args: Array<T3>
) => Observable<T>;
static toAsync<T1,T2,T3>(
func: (
arg1: T1, arg2?: T2, ...args: Array<T3>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2?: T2, ...args: Array<T3>
) => Observable<T>;
static toAsync<T1,T2,T3>(
func: (
arg1?: T1, arg2?: T2, ...args: Array<T3>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1?: T1, arg2?: T2, ...args: Array<T3>
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1: T1, arg2: T2, arg3: T3, arg4: T4
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, arg3: T3, arg4: T4
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1: T1, arg2: T2, arg3: T3, arg4?: T4
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, arg3: T3, arg4?: T4
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1: T1, arg2: T2, arg3?: T3, arg4?: T4
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, arg3?: T3, arg4?: T4
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1: T1, arg2: T2, arg3: T3, ...args: Array<T4>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, arg3: T3, ...args: Array<T4>
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1: T1, arg2: T2, arg3?: T3, ...args: Array<T4>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2: T2, arg3?: T3, ...args: Array<T4>
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1: T1, arg2?: T2, arg3?: T3, ...args: Array<T4>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1: T1, arg2?: T2, arg3?: T3, ...args: Array<T4>
) => Observable<T>;
static toAsync<T1,T2,T3,T4>(
func: (
arg1?: T1, arg2?: T2, arg3?: T3, ...args: Array<T4>
) => T,
context?: any,
scheduler?: IScheduler
): (
arg1?: T1, arg2?: T2, arg3?: T3, ...args: Array<T4>
) => Observable<T>;
static if(
condition: (
) => boolean,
thenSource: Observable<T>,
elseSource: Observable<T>
): Observable<T>;
static if(
condition: (
) => boolean,
thenSource: Observable<T>,
elseSource: IPromise<T>
): Observable<T>;
static if(
condition: (
) => boolean,
thenSource: IPromise<T>,
elseSource: Observable<T>
): Observable<T>;
static if(
condition: (
) => boolean,
thenSource: IPromise<T>,
elseSource: IPromise<T>
): Observable<T>;
static if(
condition: (
) => boolean,
thenSource: Observable<T>,
scheduler?: IScheduler
): Observable<T>;
static if(
condition: (
) => boolean,
thenSource: IPromise<T>,
scheduler?: IScheduler
): Observable<T>;
static ifThen(
condition: (
) => boolean,
thenSource: Observable<T>,
elseSource: Observable<T>
): Observable<T>;
static ifThen(
condition: (
) => boolean,
thenSource: Observable<T>,
elseSource: IPromise<T>
): Observable<T>;
static ifThen(
condition: (
) => boolean,
thenSource: IPromise<T>,
elseSource: Observable<T>
): Observable<T>;
static ifThen(
condition: (
) => boolean,
thenSource: IPromise<T>,
elseSource: IPromise<T>
): Observable<T>;
static ifThen(
condition: (
) => boolean,
thenSource: Observable<T>,
scheduler?: IScheduler
): Observable<T>;
static ifThen(
condition: (
) => boolean,
thenSource: IPromise<T>,
scheduler?: IScheduler
): Observable<T>;
static for<TSource>(
sources: Array<TSource>, resultSelector: (item: TSource) => Observable<T>
): Observable<T>;
static forIn<TSource>(
sources: Array<TSource>, resultSelector: (item: TSource) => Observable<T>
): Observable<T>;
static while(condition: () => boolean, source: Observable<T>): Observable<T>;
static while(condition: () => boolean, source: IPromise<T>): Observable<T>;
static whileDo(
condition: () => boolean, source: Observable<T>
): Observable<T>;
static whileDo(condition: () => boolean, source: IPromise<T>): Observable<T>;
static case(
selector: (
) => string,
sources: {
[key: string]: Observable<T>;
},
elseSource: Observable<T>
): Observable<T>;
static case(
selector: (
) => string,
sources: {
[key: string]: IPromise<T>;
},
elseSource: Observable<T>
): Observable<T>;
static case(
selector: (
) => string,
sources: {
[key: string]: Observable<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static case(
selector: (
) => string,
sources: {
[key: string]: IPromise<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static case(
selector: (
) => string,
sources: {
[key: string]: Observable<T>;
},
scheduler?: IScheduler
): Observable<T>;
static case(
selector: (
) => string,
sources: {
[key: string]: IPromise<T>;
},
scheduler?: IScheduler
): Observable<T>;
static case(
selector: (
) => number,
sources: {
[key: number]: Observable<T>;
},
elseSource: Observable<T>
): Observable<T>;
static case(
selector: (
) => number,
sources: {
[key: number]: IPromise<T>;
},
elseSource: Observable<T>
): Observable<T>;
static case(
selector: (
) => number,
sources: {
[key: number]: Observable<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static case(
selector: (
) => number,
sources: {
[key: number]: IPromise<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static case(
selector: (
) => number,
sources: {
[key: number]: Observable<T>;
},
scheduler?: IScheduler
): Observable<T>;
static case(
selector: (
) => number,
sources: {
[key: number]: IPromise<T>;
},
scheduler?: IScheduler
): Observable<T>;
static switchCase(
selector: (
) => string,
sources: {
[key: string]: Observable<T>;
},
elseSource: Observable<T>
): Observable<T>;
static switchCase(
selector: (
) => string,
sources: {
[key: string]: IPromise<T>;
},
elseSource: Observable<T>
): Observable<T>;
static switchCase(
selector: (
) => string,
sources: {
[key: string]: Observable<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static switchCase(
selector: (
) => string,
sources: {
[key: string]: IPromise<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static switchCase(
selector: (
) => string,
sources: {
[key: string]: Observable<T>;
},
scheduler?: IScheduler
): Observable<T>;
static switchCase(
selector: (
) => string,
sources: {
[key: string]: IPromise<T>;
},
scheduler?: IScheduler
): Observable<T>;
static switchCase(
selector: (
) => number,
sources: {
[key: number]: Observable<T>;
},
elseSource: Observable<T>
): Observable<T>;
static switchCase(
selector: (
) => number,
sources: {
[key: number]: IPromise<T>;
},
elseSource: Observable<T>
): Observable<T>;
static switchCase(
selector: (
) => number,
sources: {
[key: number]: Observable<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static switchCase(
selector: (
) => number,
sources: {
[key: number]: IPromise<T>;
},
elseSource: IPromise<T>
): Observable<T>;
static switchCase(
selector: (
) => number,
sources: {
[key: number]: Observable<T>;
},
scheduler?: IScheduler
): Observable<T>;
static switchCase(
selector: (
) => number,
sources: {
[key: number]: IPromise<T>;
},
scheduler?: IScheduler
): Observable<T>;
static forkJoin(sources: Array<Observable<T>>): Observable<Array<T>>;
static forkJoin(sources: Array<IPromise<T>>): Observable<Array<T>>;
static forkJoin(...args: Array<Observable<T>>): Observable<Array<T>>;
static forkJoin(...args: Array<IPromise<T>>): Observable<Array<T>>;
static when(plan: Plan<T>): Observable<T>;
static interval(period: number, scheduler?: IScheduler): Observable<number>;
static interval(
dutTime: number, period: number, scheduler?: IScheduler
): Observable<number>;
static timer(
dueTime: number, period: number, scheduler?: IScheduler
): Observable<number>;
static timer(dueTime: number, scheduler?: IScheduler): Observable<number>;
static timer(
dueTime: Date, period: number, scheduler?: IScheduler
): Observable<number>;
static timer(dueTime: Date, scheduler?: IScheduler): Observable<number>;
static generateWithRelativeTime<TState>(
initialState: TState,
condition: (
state: TState
) => boolean,
iterate: (
state: TState
) => TState,
resultSelector: (
state: TState
) => T,
timeSelector: (
state: TState
) => number,
scheduler?: IScheduler
): Observable<T>;
static generateWithAbsoluteTime<TState>(
initialState: TState,
condition: (
state: TState
) => boolean,
iterate: (
state: TState
) => TState,
resultSelector: (
state: TState
) => T,
timeSelector: (
state: TState
) => Date,
scheduler?: IScheduler
): Observable<T>;
static defer(observableFactory: () => Observable<T>): Observable<T>;
static defer(observableFactory: () => IPromise<T>): Observable<T>;
static empty(scheduler?: IScheduler): Observable<T>;
static from<TSource>(
array: Array<TSource>,
mapFn: (
value: TSource, index: number
) => T,
thisArg?: any,
scheduler?: IScheduler
): Observable<T>;
static from(
array: Array<T>,
mapFn?: (
value: T, index: number
) => T,
thisArg?: any,
scheduler?: IScheduler
): Observable<T>;
static from<TSource>(
array: {
length: number;
[index: number]: TSource;
},
mapFn: (
value: TSource, index: number
) => T,
thisArg?: any,
scheduler?: IScheduler
): Observable<T>;
static from(
array: {
length: number;
[index: number]: T;
},
mapFn?: (
value: T, index: number
) => T,
thisArg?: any,
scheduler?: IScheduler
): Observable<T>;
static from(
iterable: any,
mapFn?: (
value: any, index: number
) => T,
thisArg?: any,
scheduler?: IScheduler
): Observable<T>;
static fromArray(array: Array<T>, scheduler?: IScheduler): Observable<T>;
static fromArray(
array: {length: number;
[index: number]: T;}, scheduler?: IScheduler
): Observable<T>;
static generate<TState>(
initialState: TState,
condition: (
state: TState
) => boolean,
iterate: (
state: TState
) => TState,
resultSelector: (
state: TState
) => T,
scheduler?: IScheduler
): Observable<T>;
static never(): Observable<T>;
static of(...values: Array<T>): Observable<T>;
static ofWithScheduler(
scheduler?: IScheduler, ...values: Array<T>
): Observable<T>;
static range(
start: number, count: number, scheduler?: IScheduler
): Observable<number>;
static repeat(
value: T, repeatCount?: number, scheduler?: IScheduler
): Observable<T>;
static return(value: T, scheduler?: IScheduler): Observable<T>;
static just(value: T, scheduler?: IScheduler): Observable<T>;
static returnValue(value: T, scheduler?: IScheduler): Observable<T>;
static throw(exception: Error, scheduler?: IScheduler): Observable<T>;
static throw(exception: any, scheduler?: IScheduler): Observable<T>;
static throwException(
exception: Error, scheduler?: IScheduler
): Observable<T>;
static throwException(exception: any, scheduler?: IScheduler): Observable<T>;
static throwError(error: Error, scheduler?: IScheduler): Observable<T>;
static throwError(error: any, scheduler?: IScheduler): Observable<T>;
static catch(sources: Array<Observable<T>>): Observable<T>;
static catch(sources: Array<IPromise<T>>): Observable<T>;
static catchException(sources: Array<Observable<T>>): Observable<T>;
static catchException(sources: Array<IPromise<T>>): Observable<T>;
static catchError(sources: Array<Observable<T>>): Observable<T>;
static catchError(sources: Array<IPromise<T>>): Observable<T>;
static catch(...sources: Array<Observable<T>>): Observable<T>;
static catch(...sources: Array<IPromise<T>>): Observable<T>;
static catchException(...sources: Array<Observable<T>>): Observable<T>;
static catchException(...sources: Array<IPromise<T>>): Observable<T>;
static catchError(...sources: Array<Observable<T>>): Observable<T>;
static catchError(...sources: Array<IPromise<T>>): Observable<T>;
static combineLatest<T1,T2>(
first: Observable<T1>,
second: Observable<T2>,
resultSelector: (
v1: T1, v2: T2
) => T
): Observable<T>;
static combineLatest<T1,T2,T3>(
first: Observable<T1>,
second: Observable<T2>,
third: Observable<T3>,
resultSelector: (
v1: T1, v2: T2, v3: T3
) => T
): Observable<T>;
static combineLatest<T1,T2,T3,T4>(
first: Observable<T1>,
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
resultSelector: (
v1: T1, v2: T2, v3: T3, v4: T4
) => T
): Observable<T>;
static combineLatest<T1,T2,T3,T4,T5>(
first: Observable<T1>,
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
fifth: Observable<T5>,
resultSelector: (
v1: T1, v2: T2, v3: T3, v4: T4, v5: T5
) => T
): Observable<T>;
static combineLatest<T1,T2,T3,T4,T5,T6>(
first: Observable<T1>,
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
fifth: Observable<T5>,
sixth: Observable<T6>,
resultSelector: (
v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6
) => T
): Observable<T>;
static combineLatest<T1,T2,T3,T4,T5,T6,T7>(
first: Observable<T1>,
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
fifth: Observable<T5>,
sixth: Observable<T6>,
seventh: Observable<T7>,
resultSelector: (
v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7
) => T
): Observable<T>;
static combineLatest<T1,T2,T3,T4,T5,T6,T7,T8>(
first: Observable<T1>,
second: Observable<T2>,
third: Observable<T3>,
fourth: Observable<T4>,
fifth: Observable<T5>,
sixth: Observable<T6>,
seventh: Observable<T7>,
seventh: Observable<T8>,
resultSelector: (
v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8
) => T
): Observable<T>;
static combineLatest<TSource>(
sources: Array<Observable<TSource> | IPromise<TSource>>,
resultSelector: (
...otherValues: Array<TSource>
) => T
): Observable<T>;
static withLatestFrom<T1,T2>(
first: Observable<T1> | IPromise<T1>,
second: Observable<T2> | IPromise<T2>,
resultSelector: (
v1: T, v2: T2
) => T
): Observable<T>;
static withLatestFrom<T1,T2,T3>(
first: Observable<T1> | IPromise<T1>,
second: Observable<T2> | IPromise<T2>,
second: Observable<T3> | IPromise<T3>,
resultSelector: (
v1: T, v2: T2, v3: T3
) => T
): Observable<T>;
static withLatestFrom<T1,T2,T3,T4>(
first: Observable<T1> | IPromise<T1>,
second: Observable<T2> | IPromise<T2>,
second: Observable<T3> | IPromise<T3>,
second: Observable<T4> | IPromise<T4>,
resultSelector: (
v1: T, v2: T2, v3: T3, v4: T4
) => T
): Observable<T>;
static withLatestFrom<TSource>(
sources: Array<Observable<TSource> | IPromise<TSource>>,
resultSelector: (
...otherValues: Array<TSource>
) => T
): Observable<T>;
static concat(...sources: Array<Observable<T> | IPromise<T>>): Observable<T>;
static concat(sources: Array<Observable<T> | IPromise<T>>): Observable<T>;
static merge(...sources: Array<Observable<T> | IPromise<T>>): Observable<T>;
static merge(sources: Array<Observable<T> | IPromise<T>>): Observable<T>;
static merge(scheduler: IScheduler, ...sources: Array<Observable<T> | IPromise<T>>): Observable<T>;
static merge(scheduler: IScheduler, sources: Array<Observable<T> | IPromise<T>>): Observable<T>;
static zip<T1,T2>(
first: Observable<T1> | IPromise<T1>,
sources: Array<Observable<T2> | IPromise<T2>>,
resultSelector: (
item1: T1, ...right: Array<T2>
) => T
): Observable<T>;
static zip<T1,T2>(
first: Observable<T1> | IPromise<T1>,
second: Observable<T2> | IPromise<T2>,
resultSelector: (
item1: T1, item2: T2
) => T
): Observable<T>;
static zip<T1,T2,T3>(
first: Observable<T1> | IPromise<T1>,
second: Observable<T2> | IPromise<T2>,
third: Observable<T3> | IPromise<T3>,
resultSelector: (
item1: T1, item2: T2, item3: T3
) => T
): Observable<T>;
static zip<T1,T2,T3,T4>(
first: Observable<T1> | IPromise<T1>,
second: Observable<T2> | IPromise<T2>,
third: Observable<T3> | IPromise<T3>,
fourth: Observable<T4> | IPromise<T4>,
resultSelector: (
item1: T1, item2: T2, item3: T3, item4: T4
) => T
): Observable<T>;
static zipArray(...sources: Array<Observable<T> | IPromise<T>>) : Observable<Array<T>>;
static zipArray(sources: Array<Observable<T> | IPromise<T>>) : Observable<Array<T>>;
static fromPromise(promise: IPromise<T>): 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>;
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>;
shareValue(initialValue: T): Observable<T>;
replay(
selector?: boolean,
bufferSize?: number,
window?: number,
scheduler?: IScheduler
): ConnectableObservable<T>;
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 class ControlledObservable<T> extends Observable<T> {
request(numberOfItems?: number): IDisposable;
}
declare class PausableObservable<T> extends Observable<T> {
pause(): void;
resume(): void;
}
declare interface ISubject<T> extends Observable<T>, IObserver<T>, IDisposable {
hasObservers(): boolean;
}
declare class Subject<T> extends ISubject<T> {
constructor(): Subject<T>;
create(
observer?: Observer<T>,
observable?: Observable<T>
): ISubject<T>;
}
declare class AsyncSubject<T> extends Subject<T> {
constructor(): AsyncSubject<T>;
}
declare class BehaviorSubject<T> extends Subject<T> {
constructor(initialValue: T): BehaviorSubject<T>;
getValue(): T;
}
declare class ReplaySubject<T> extends Subject<T> {
constructor(
bufferSize?: number, window?: number, scheduler?: IScheduler
): ReplaySubject<T>;
}
declare class ConnectableObservable<T> extends Observable<T> {
constructor(): ConnectableObservable<T>;
connect(): IDisposable;
refCount(): Observable<T>;
}
declare interface Pattern1<T1> {
and<T2>(other: Observable<T2>): Pattern2<T1,T2>;
thenDo<TR>(selector: (item1: T1) => TR): Plan<TR>;
}
declare interface Pattern2<T1,T2> {
and<T3>(other: Observable<T3>): Pattern3<T1,T2,T3>;
thenDo<TR>(selector: (item1: T1, item2: T2) => TR): Plan<TR>;
}
declare interface Pattern3<T1,T2,T3> {
and<T4>(other: Observable<T4>): Pattern4<T1,T2,T3,T4>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan<TR>;
}
declare interface Pattern4<T1,T2,T3,T4> {
and<T5>(other: Observable<T5>): Pattern5<T1,T2,T3,T4,T5>;
thenDo<TR>(
selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR
): Plan<TR>;
}
declare interface Pattern5<T1,T2,T3,T4,T5> {
and<T6>(other: Observable<T6>): Pattern6<T1,T2,T3,T4,T5,T6>;
thenDo<TR>(
selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR
): Plan<TR>;
}
declare interface Pattern6<T1,T2,T3,T4,T5,T6> {
and<T7>(other: Observable<T7>): Pattern7<T1,T2,T3,T4,T5,T6,T7>;
thenDo<TR>(
selector: (
item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6
) => TR
): Plan<TR>;
}
declare interface Pattern7<T1,T2,T3,T4,T5,T6,T7> {
and<T8>(other: Observable<T8>): Pattern8<T1,T2,T3,T4,T5,T6,T7,T8>;
thenDo<TR>(
selector: (
item1: T1,
item2: T2,
item3: T3,
item4: T4,
item5: T5,
item6: T6,
item7: T7
) => TR
): Plan<TR>;
}
declare interface Pattern8<T1,T2,T3,T4,T5,T6,T7,T8> {
and<T9>(other: Observable<T9>): Pattern9<T1,T2,T3,T4,T5,T6,T7,T8,T9>;
thenDo<TR>(
selector: (
item1: T1,
item2: T2,
item3: T3,
item4: T4,
item5: T5,
item6: T6,
item7: T7,
item8: T8
) => TR
): Plan<TR>;
}
declare interface Pattern9<T1,T2,T3,T4,T5,T6,T7,T8,T9> {
thenDo<TR>(
selector: (
item1: T1,
item2: T2,
item3: T3,
item4: T4,
item5: T5,
item6: T6,
item7: T7,
item8: T8,
item9: T9
) => TR
): Plan<TR>;
}
declare interface Plan<T> {
}
declare interface GroupedObservable<TKey,TElement> extends Observable<
TElement> {
key: TKey;
underlyingObservable: Observable<TElement>;
}
declare class TestScheduler extends VirtualTimeScheduler<number,number> {
createColdObservable<T>(...records: Array<Recorded>): Observable<T>;
createHotObservable<T>(...records: Array<Recorded>): Observable<T>;
createObserver<T>(): MockObserver<T>;
startWithTiming<T>(
create: (
) => Observable<T>,
createdAt: number,
subscribedAt: number,
disposedAt: number
): MockObserver<T>;
startWithDispose<T>(
create: () => Observable<T>, disposedAt: number
): MockObserver<T>;
startWithCreate<T>(create: () => Observable<T>): MockObserver<T>;
new(): TestScheduler;
}
declare class Recorded {
constructor(
time: number,
value: any,
equalityComparer?: (
x: any, y: any
) => boolean
): any;
equals(other: Recorded): boolean;
toString(): string;
time: number;
value: any;
}
declare class Subscription {
constructor(subscribeAt: number, unsubscribeAt?: number): any;
equals(other: Subscription): boolean;
}
declare var ReactiveTest: {
created: number;
subscribed: number;
disposed: number;
onNext(ticks: number, value: any): Recorded;
onNext(ticks: number, predicate: (value: any) => boolean): Recorded;
onError(ticks: number, exception: any): Recorded;
onError(ticks: number, predicate: (exception: any) => boolean): Recorded;
onCompleted(ticks: number): Recorded;
subscribe(subscribeAt: number, unsubscribeAt?: number): Subscription;
};
declare interface MockObserver<T> extends Observer<T> {
static constructor(scheduler: IScheduler): MockObserver<T>;
messages: Array<Recorded>;
}
declare interface TimeInterval<T> {
value: T;
interval: number;
}
declare interface Timestamp<T> {
value: T;
timestamp: number;
}
declare interface VirtualTimeScheduler<TAbsolute,TRelative> extends
Scheduler {
advanceBy(time: TRelative): void;
advanceTo(time: TAbsolute): void;
scheduleAbsolute(dueTime: TAbsolute, action: () => void): IDisposable;
scheduleAbsoluteWithState<TState>(
state: TState,
dueTime: TAbsolute,
action: (
scheduler: IScheduler, state: TState
) => IDisposable
): IDisposable;
scheduleRelative(dueTime: TRelative, action: () => void): IDisposable;
scheduleRelativeWithState<TState>(
state: TState,
dueTime: TRelative,
action: (
scheduler: IScheduler, state: TState
) => IDisposable
): IDisposable;
sleep(time: TRelative): void;
start(): IDisposable;
stop(): void;
isEnabled: boolean;
add(from: TAbsolute, by: TRelative): TAbsolute;
toDateTimeOffset(duetime: TAbsolute): number;
toRelative(duetime: number): TRelative;
getNext(): ScheduledItem<TAbsolute>;
}
declare class HistoricalScheduler extends VirtualTimeScheduler<number,
number> {
new(
initialClock: number,
comparer: (
first: number, second: number
) => number
): HistoricalScheduler;
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment