@types/rx-lite - npm Package Compare versions

Comparing version 4.0.6 to 4.0.7

rx-lite/index.d.ts

@@ -12,3 +12,3 @@ // Type definitions for rx-lite 4.0
         function isEqual(left: any, right: any): boolean;
-        function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
+        function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable }): Observable<T>;
 
@@ -34,3 +34,9 @@ // Priority Queue for Scheduling
         class ScheduledItem<TTime> {
-            constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
+            constructor(
+                scheduler: IScheduler,
+                state: any,
+                action: (scheduler: IScheduler, state: any) => IDisposable,
+                dueTime: TTime,
+                comparer?: (x: TTime, y: TTime) => number,
+            );
 
@@ -52,3 +58,7 @@ scheduler: IScheduler;
     namespace config {
-        let Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
+        let Promise: {
+            new<T>(
+                resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void,
+            ): IPromise<T>;
+        };
     }
@@ -124,17 +134,49 @@
         schedule(action: () => void): IDisposable;
-        scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): 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;
+        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;
+        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;
+        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;
+        schedulePeriodicWithState<TState>(
+            state: TState,
+            period: number,
+            action: (state: TState) => TState,
+        ): IDisposable;
     }
@@ -146,7 +188,16 @@
     interface SchedulerStatic {
-        new (
+        new(
             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;
+            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;
 
@@ -171,3 +222,7 @@ normalize(timeSpan: number): number;
         accept(observer: IObserver<T>): void;
-        accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
+        accept<TResult>(
+            onNext: (value: T) => TResult,
+            onError?: (exception: any) => TResult,
+            onCompleted?: () => TResult,
+        ): TResult;
         toObservable(scheduler?: IScheduler): Observable<T>;
@@ -198,3 +253,7 @@ hasValue: boolean;
     interface ObserverStatic {
-        create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
+        create<T>(
+            onNext?: (value: T) => void,
+            onError?: (exception: any) => void,
+            onCompleted?: () => void,
+        ): Observer<T>;
         fromNotifier<T>(handler: (notification: Notification<T>, thisArg?: any) => void): Observer<T>;
@@ -207,3 +266,7 @@ }
         subscribe(observer: Observer<T>): IDisposable;
-        subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
+        subscribe(
+            onNext?: (value: T) => void,
+            onError?: (exception: any) => void,
+            onCompleted?: () => void,
+        ): IDisposable;
 
@@ -216,3 +279,3 @@ subscribeOnNext(onNext: (value: T) => void, thisArg?: any): IDisposable;
     interface Observable<T> extends IObservable<T> {
-        forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;    // alias for subscribe
+        forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable; // alias for subscribe
         toArray(): Observable<T[]>;
@@ -222,33 +285,105 @@
         catch(second: Observable<T>): Observable<T>;
-        catchException(handler: (exception: Error) => IPromise<T> | Observable<T>): Observable<T>;    // alias for catch
-        catchException(second: Observable<T>): Observable<T>;    // alias for catch
+        catchException(handler: (exception: Error) => IPromise<T> | Observable<T>): Observable<T>; // alias for catch
+        catchException(second: Observable<T>): Observable<T>; // alias for catch
         combineLatest<T2>(second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
-        combineLatest<T2, TResult>(second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-        combineLatest<T2, T3>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
-        combineLatest<T2, T3, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-        combineLatest<T2, T3, T4>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
-        combineLatest<T2, T3, T4, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-        combineLatest<T2, T3, T4, T5>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
-        combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
-        combineLatest<TOther, TResult>(souces: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
+        combineLatest<T2, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            resultSelector: (v1: T, v2: T2) => TResult,
+        ): Observable<TResult>;
+        combineLatest<T2, T3>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+        ): Observable<[T, T2, T3]>;
+        combineLatest<T2, T3, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            resultSelector: (v1: T, v2: T2, v3: T3) => TResult,
+        ): Observable<TResult>;
+        combineLatest<T2, T3, T4>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+        ): Observable<[T, T2, T3, T4]>;
+        combineLatest<T2, T3, T4, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult,
+        ): Observable<TResult>;
+        combineLatest<T2, T3, T4, T5>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+        ): Observable<[T, T2, T3, T4, T5]>;
+        combineLatest<T2, T3, T4, T5, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult,
+        ): Observable<TResult>;
+        combineLatest<TOther, TResult>(
+            souces: (Observable<TOther> | IPromise<TOther>)[],
+            resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult,
+        ): Observable<TResult>;
         withLatestFrom<T2>(second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
-        withLatestFrom<T2, TResult>(second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-        withLatestFrom<T2, T3>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
-        withLatestFrom<T2, T3, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-        withLatestFrom<T2, T3, T4>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
-        withLatestFrom<T2, T3, T4, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-        withLatestFrom<T2, T3, T4, T5>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
-        withLatestFrom<T2, T3, T4, T5, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
-        withLatestFrom<TOther, TResult>(souces: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
+        withLatestFrom<T2, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            resultSelector: (v1: T, v2: T2) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<T2, T3>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+        ): Observable<[T, T2, T3]>;
+        withLatestFrom<T2, T3, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            resultSelector: (v1: T, v2: T2, v3: T3) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<T2, T3, T4>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+        ): Observable<[T, T2, T3, T4]>;
+        withLatestFrom<T2, T3, T4, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<T2, T3, T4, T5>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+        ): Observable<[T, T2, T3, T4, T5]>;
+        withLatestFrom<T2, T3, T4, T5, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<TOther, TResult>(
+            souces: (Observable<TOther> | IPromise<TOther>)[],
+            resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult,
+        ): Observable<TResult>;
         concat(...sources: (Observable<T> | IPromise<T>)[]): Observable<T>;
         concat(sources: (Observable<T> | IPromise<T>)[]): Observable<T>;
         concatAll(): T;
-        concatObservable(): Observable<T>;    // alias for concatAll
-        concatMap<T2, R>(selector: (value: T, index: number) => Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;    // alias for selectConcat
-        concatMap<T2, R>(selector: (value: T, index: number) => IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;    // alias for selectConcat
-        concatMap<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>;    // alias for selectConcat
-        concatMap<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>;    // alias for selectConcat
-        concatMap<R>(selector: (value: T, index: number) => R[]): Observable<R>;    // alias for selectConcat
-        concatMap<R>(sequence: Observable<R>): Observable<R>;    // alias for selectConcat
-        concatMap<R>(sequence: R[]): Observable<R>;    // alias for selectConcat
+        concatObservable(): Observable<T>; // alias for concatAll
+        concatMap<T2, R>(
+            selector: (value: T, index: number) => Observable<T2>,
+            resultSelector: (value1: T, value2: T2, index: number) => R,
+        ): Observable<R>; // alias for selectConcat
+        concatMap<T2, R>(
+            selector: (value: T, index: number) => IPromise<T2>,
+            resultSelector: (value1: T, value2: T2, index: number) => R,
+        ): Observable<R>; // alias for selectConcat
+        concatMap<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>; // alias for selectConcat
+        concatMap<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>; // alias for selectConcat
+        concatMap<R>(selector: (value: T, index: number) => R[]): Observable<R>; // alias for selectConcat
+        concatMap<R>(sequence: Observable<R>): Observable<R>; // alias for selectConcat
+        concatMap<R>(sequence: R[]): Observable<R>; // alias for selectConcat
         merge(maxConcurrent: number): T;
@@ -258,18 +393,51 @@ merge(other: Observable<T>): Observable<T>;
         mergeAll(): T;
-        mergeObservable(): T;    // alias for mergeAll
+        mergeObservable(): T; // alias for mergeAll
         skipUntil<T2>(other: Observable<T2>): Observable<T>;
         skipUntil<T2>(other: IPromise<T2>): Observable<T>;
         switch(): T;
-        switchLatest(): T;    // alias for switch
+        switchLatest(): T; // alias for switch
         takeUntil<T2>(other: Observable<T2>): Observable<T>;
         takeUntil<T2>(other: IPromise<T2>): Observable<T>;
         zip<T2>(second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
-        zip<T2, TResult>(second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-        zip<T2, T3>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
-        zip<T2, T3, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-        zip<T2, T3, T4>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
-        zip<T2, T3, T4, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-        zip<T2, T3, T4, T5>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
-        zip<T2, T3, T4, T5, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
-        zip<TOther, TResult>(second: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
+        zip<T2, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            resultSelector: (v1: T, v2: T2) => TResult,
+        ): Observable<TResult>;
+        zip<T2, T3>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+        ): Observable<[T, T2, T3]>;
+        zip<T2, T3, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            resultSelector: (v1: T, v2: T2, v3: T3) => TResult,
+        ): Observable<TResult>;
+        zip<T2, T3, T4>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+        ): Observable<[T, T2, T3, T4]>;
+        zip<T2, T3, T4, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult,
+        ): Observable<TResult>;
+        zip<T2, T3, T4, T5>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+        ): Observable<[T, T2, T3, T4, T5]>;
+        zip<T2, T3, T4, T5, TResult>(
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult,
+        ): Observable<TResult>;
+        zip<TOther, TResult>(
+            second: (Observable<TOther> | IPromise<TOther>)[],
+            resultSelector: (left: T, ...right: TOther[]) => TResult,
+        ): Observable<TResult>;
 
@@ -279,9 +447,16 @@ asObservable(): Observable<T>;
         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>;
+        distinctUntilChanged<TValue>(
+            keySelector?: (value: T) => TValue,
+            comparer?: (x: TValue, y: TValue) => boolean,
+        ): Observable<T>;
         do(observer: Observer<T>): Observable<T>;
         do(onNext?: (value: T) => void, onError?: (exception: Error) => void, onCompleted?: () => void): Observable<T>;
-        doAction(observer: Observer<T>): Observable<T>;    // alias for do
-        doAction(onNext?: (value: T) => void, onError?: (exception: Error) => void, onCompleted?: () => void): Observable<T>;    // alias for do
-        tap(observer: Observer<T>): Observable<T>;    // alias for do
-        tap(onNext?: (value: T) => void, onError?: (exception: Error) => void, onCompleted?: () => void): Observable<T>;    // alias for do
+        doAction(observer: Observer<T>): Observable<T>; // alias for do
+        doAction(
+            onNext?: (value: T) => void,
+            onError?: (exception: Error) => void,
+            onCompleted?: () => void,
+        ): Observable<T>; // alias for do
+        tap(observer: Observer<T>): Observable<T>; // alias for do
+        tap(onNext?: (value: T) => void, onError?: (exception: Error) => void, onCompleted?: () => void): Observable<T>; // alias for do
 
@@ -296,3 +471,3 @@ doOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
         finally(action: () => void): Observable<T>;
-        finallyAction(action: () => void): Observable<T>;    // alias for finally
+        finallyAction(action: () => void): Observable<T>; // alias for finally
         ignoreElements(): Observable<T>;
@@ -314,3 +489,6 @@ materialize(): Observable<Notification<T>>;
          */
-        scan<TAcc>(accumulator: (acc: TAcc, value: T, index?: number, source?: Observable<TAcc>) => TAcc, seed: TAcc): Observable<TAcc>;
+        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>;
@@ -324,7 +502,19 @@
 
-        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>;    // alias for select
+        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>; // alias for select
         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<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>;
@@ -334,10 +524,16 @@ selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
         selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
-        selectMany<TResult>(selector: (value: T) => TResult[]): Observable<TResult>;    // alias for selectMany
-        flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;    // alias for selectMany
-        flatMap<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;    // alias for selectMany
-        flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;    // alias for selectMany
-        flatMap<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;    // alias for selectMany
-        flatMap<TResult>(other: Observable<TResult>): Observable<TResult>;    // alias for selectMany
-        flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>;    // alias for selectMany
-        flatMap<TResult>(selector: (value: T) => TResult[]): Observable<TResult>;    // alias for selectMany
+        selectMany<TResult>(selector: (value: T) => TResult[]): Observable<TResult>; // alias for selectMany
+        flatMap<TOther, TResult>(
+            selector: (value: T) => Observable<TOther>,
+            resultSelector: (item: T, other: TOther) => TResult,
+        ): Observable<TResult>; // alias for selectMany
+        flatMap<TOther, TResult>(
+            selector: (value: T) => IPromise<TOther>,
+            resultSelector: (item: T, other: TOther) => TResult,
+        ): Observable<TResult>; // alias for selectMany
+        flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>; // alias for selectMany
+        flatMap<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>; // alias for selectMany
+        flatMap<TResult>(other: Observable<TResult>): Observable<TResult>; // alias for selectMany
+        flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>; // alias for selectMany
+        flatMap<TResult>(selector: (value: T) => TResult[]): Observable<TResult>; // alias for selectMany
 
@@ -352,3 +548,8 @@ /**
          */
-        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>;
+        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>;
 
@@ -363,6 +564,17 @@ /**
          */
-        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>;
+        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<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>;
@@ -380,3 +592,6 @@ selectConcat<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>;
          */
-        selectSwitch<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>;
+        selectSwitch<TResult>(
+            selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>,
+            thisArg?: any,
+        ): Observable<TResult>;
         /**
@@ -390,3 +605,6 @@ *  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then
          */
-        flatMapLatest<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>;    // alias for selectSwitch
+        flatMapLatest<TResult>(
+            selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>,
+            thisArg?: any,
+        ): Observable<TResult>; // alias for selectSwitch
         /**
@@ -401,3 +619,6 @@ *  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then
          */
-        switchMap<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;    // alias for selectSwitch
+        switchMap<TResult>(
+            selector: (value: T, index: number, source: Observable<T>) => TResult,
+            thisArg?: any,
+        ): Observable<TResult>; // alias for selectSwitch
 
@@ -418,3 +639,9 @@ skip(count: number): Observable<T>;
          */
-        toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
+        toPromise<TPromise extends IPromise<T>>(
+            promiseCtor: {
+                new(
+                    resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void,
+                ): TPromise;
+            },
+        ): TPromise;
         /**
@@ -431,3 +658,9 @@ * Converts an existing observable sequence to an ES6 Compatible Promise
          */
-        toPromise(promiseCtor?: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
+        toPromise(
+            promiseCtor?: {
+                new(
+                    resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void,
+                ): IPromise<T>;
+            },
+        ): IPromise<T>;
 
@@ -454,3 +687,6 @@ // Experimental Flattening
          */
-        exclusiveMap<I, R>(selector: (value: I, index: number, source: Observable<I>) => R, thisArg?: any): Observable<R>;
+        exclusiveMap<I, R>(
+            selector: (value: I, index: number, source: Observable<I>) => R,
+            thisArg?: any,
+        ): Observable<R>;
 
@@ -480,3 +716,8 @@ publish(): ConnectableObservable<T>;
          */
-        from<T, TResult>(array: T[], mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler): Observable<TResult>;
+        from<T, TResult>(
+            array: T[],
+            mapFn: (value: T, index: number) => TResult,
+            thisArg?: any,
+            scheduler?: IScheduler,
+        ): Observable<TResult>;
         /**
@@ -489,3 +730,8 @@ * This method creates a new Observable sequence from an array object.
          */
-        from<T>(array: T[], mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
+        from<T>(
+            array: T[],
+            mapFn?: (value: T, index: number) => T,
+            thisArg?: any,
+            scheduler?: IScheduler,
+        ): Observable<T>;
 
@@ -499,3 +745,8 @@ /**
          */
-        from<T, TResult>(array: { length: number; [index: number]: T; }, mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler): Observable<TResult>;
+        from<T, TResult>(
+            array: { length: number; [index: number]: T },
+            mapFn: (value: T, index: number) => TResult,
+            thisArg?: any,
+            scheduler?: IScheduler,
+        ): Observable<TResult>;
         /**
@@ -508,3 +759,8 @@ * This method creates a new Observable sequence from an array-like object.
          */
-        from<T>(array: { length: number; [index: number]: T; }, mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
+        from<T>(
+            array: { length: number; [index: number]: T },
+            mapFn?: (value: T, index: number) => T,
+            thisArg?: any,
+            scheduler?: IScheduler,
+        ): Observable<T>;
 
@@ -518,8 +774,19 @@ /**
          */
-        from<T>(iterable: any, mapFn?: (value: any, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
+        from<T>(
+            iterable: any,
+            mapFn?: (value: any, index: number) => T,
+            thisArg?: any,
+            scheduler?: IScheduler,
+        ): Observable<T>;
 
         fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
-        fromArray<T>(array: { length: number; [index: number]: T; }, scheduler?: IScheduler): Observable<T>;
+        fromArray<T>(array: { length: number; [index: number]: T }, scheduler?: IScheduler): Observable<T>;
 
-        generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable<TResult>;
+        generate<TState, TResult>(
+            initialState: TState,
+            condition: (state: TState) => boolean,
+            iterate: (state: TState) => TState,
+            resultSelector: (state: TState) => TResult,
+            scheduler?: IScheduler,
+        ): Observable<TResult>;
         never<T>(): Observable<T>;
@@ -552,7 +819,7 @@
          */
-        just<T>(value: T, scheduler?: IScheduler): Observable<T>;    // alias for return
-        returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;    // alias for return
+        just<T>(value: T, scheduler?: IScheduler): Observable<T>; // alias for return
+        returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>; // alias for return
         throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
-        throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;    // alias for throw
-        throwError<T>(error: Error, scheduler?: IScheduler): Observable<T>;    // alias for throw
+        throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>; // alias for throw
+        throwError<T>(error: Error, scheduler?: IScheduler): Observable<T>; // alias for throw
 
@@ -562,29 +829,115 @@ catch<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>;
         catch<T>(...sources: IPromise<T>[]): Observable<T>;
-        catchException<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>;    // alias for catch
-        catchException<T>(...sources: Observable<T>[]): Observable<T>;    // alias for catch
-        catchException<T>(...sources: IPromise<T>[]): Observable<T>;    // alias for catch
-        catchError<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>;    // alias for catch
-        catchError<T>(...sources: Observable<T>[]): Observable<T>;    // alias for catch
-        catchError<T>(...sources: IPromise<T>[]): Observable<T>;    // alias for catch
+        catchException<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>; // alias for catch
+        catchException<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
+        catchException<T>(...sources: IPromise<T>[]): Observable<T>; // alias for catch
+        catchError<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>; // alias for catch
+        catchError<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
+        catchError<T>(...sources: IPromise<T>[]): Observable<T>; // alias for catch
 
-        combineLatest<T, T2>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
-        combineLatest<T, T2, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-        combineLatest<T, T2, T3>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
-        combineLatest<T, T2, T3, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-        combineLatest<T, T2, T3, T4>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
-        combineLatest<T, T2, T3, T4, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-        combineLatest<T, T2, T3, T4, T5>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
-        combineLatest<T, T2, T3, T4, T5, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
+        combineLatest<T, T2>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+        ): Observable<[T, T2]>;
+        combineLatest<T, T2, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            resultSelector: (v1: T, v2: T2) => TResult,
+        ): Observable<TResult>;
+        combineLatest<T, T2, T3>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+        ): Observable<[T, T2, T3]>;
+        combineLatest<T, T2, T3, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            resultSelector: (v1: T, v2: T2, v3: T3) => TResult,
+        ): Observable<TResult>;
+        combineLatest<T, T2, T3, T4>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+        ): Observable<[T, T2, T3, T4]>;
+        combineLatest<T, T2, T3, T4, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult,
+        ): Observable<TResult>;
+        combineLatest<T, T2, T3, T4, T5>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+        ): Observable<[T, T2, T3, T4, T5]>;
+        combineLatest<T, T2, T3, T4, T5, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult,
+        ): Observable<TResult>;
         combineLatest<T>(sources: (Observable<T> | IPromise<T>)[]): Observable<T[]>;
-        combineLatest<TOther, TResult>(sources: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
+        combineLatest<TOther, TResult>(
+            sources: (Observable<TOther> | IPromise<TOther>)[],
+            resultSelector: (...otherValues: TOther[]) => TResult,
+        ): Observable<TResult>;
 
-        withLatestFrom<T, T2>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
-        withLatestFrom<T, T2, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-        withLatestFrom<T, T2, T3>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
-        withLatestFrom<T, T2, T3, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-        withLatestFrom<T, T2, T3, T4>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
-        withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-        withLatestFrom<T, T2, T3, T4, T5>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
-        withLatestFrom<T, T2, T3, T4, T5, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
-        withLatestFrom<TOther, TResult>(souces: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
+        withLatestFrom<T, T2>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+        ): Observable<[T, T2]>;
+        withLatestFrom<T, T2, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            resultSelector: (v1: T, v2: T2) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<T, T2, T3>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+        ): Observable<[T, T2, T3]>;
+        withLatestFrom<T, T2, T3, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            resultSelector: (v1: T, v2: T2, v3: T3) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<T, T2, T3, T4>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+        ): Observable<[T, T2, T3, T4]>;
+        withLatestFrom<T, T2, T3, T4, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<T, T2, T3, T4, T5>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+        ): Observable<[T, T2, T3, T4, T5]>;
+        withLatestFrom<T, T2, T3, T4, T5, TResult>(
+            first: Observable<T> | IPromise<T>,
+            second: Observable<T2> | IPromise<T2>,
+            third: Observable<T3> | IPromise<T3>,
+            fourth: Observable<T4> | IPromise<T4>,
+            fifth: Observable<T5> | IPromise<T5>,
+            resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult,
+        ): Observable<TResult>;
+        withLatestFrom<TOther, TResult>(
+            souces: (Observable<TOther> | IPromise<TOther>)[],
+            resultSelector: (...otherValues: TOther[]) => TResult,
+        ): Observable<TResult>;
 
@@ -603,11 +956,55 @@ concat<T>(...sources: Observable<T>[]): Observable<T>;
 
-        zip<T1, T2>(first: Observable<T1> | IPromise<T1>, sources: Observable<T2> | IPromise<T2> | (Observable<T2> | IPromise<T2>)[]): Observable<[T1, T2]>;
-        zip<T1, T2, TResult>(first: Observable<T1> | IPromise<T1>, sources: (Observable<T2> | IPromise<T2>)[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
-        zip<T1, T2, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
-        zip<T1, T2, T3>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>): Observable<[T1, T2, T3]>;
-        zip<T1, T2, T3, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
-        zip<T1, T2, T3, T4>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>): Observable<[T1, T2, T3, T4]>;
-        zip<T1, T2, T3, T4, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-        zip<T1, T2, T3, T4, T5>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>, source5: Observable<T5> | IPromise<T5>): Observable<[T1, T2, T3, T4, T5]>;
-        zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>, source5: Observable<T5> | IPromise<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
+        zip<T1, T2>(
+            first: Observable<T1> | IPromise<T1>,
+            sources: Observable<T2> | IPromise<T2> | (Observable<T2> | IPromise<T2>)[],
+        ): Observable<[T1, T2]>;
+        zip<T1, T2, TResult>(
+            first: Observable<T1> | IPromise<T1>,
+            sources: (Observable<T2> | IPromise<T2>)[],
+            resultSelector: (item1: T1, ...right: T2[]) => TResult,
+        ): Observable<TResult>;
+        zip<T1, T2, TResult>(
+            source1: Observable<T1> | IPromise<T1>,
+            source2: Observable<T2> | IPromise<T2>,
+            resultSelector: (item1: T1, item2: T2) => TResult,
+        ): Observable<TResult>;
+        zip<T1, T2, T3>(
+            source1: Observable<T1> | IPromise<T1>,
+            source2: Observable<T2> | IPromise<T2>,
+            source3: Observable<T3> | IPromise<T3>,
+        ): Observable<[T1, T2, T3]>;
+        zip<T1, T2, T3, TResult>(
+            source1: Observable<T1> | IPromise<T1>,
+            source2: Observable<T2> | IPromise<T2>,
+            source3: Observable<T3> | IPromise<T3>,
+            resultSelector: (item1: T1, item2: T2, item3: T3) => TResult,
+        ): Observable<TResult>;
+        zip<T1, T2, T3, T4>(
+            source1: Observable<T1> | IPromise<T1>,
+            source2: Observable<T2> | IPromise<T2>,
+            source3: Observable<T3> | IPromise<T3>,
+            source4: Observable<T4> | IPromise<T4>,
+        ): Observable<[T1, T2, T3, T4]>;
+        zip<T1, T2, T3, T4, TResult>(
+            source1: Observable<T1> | IPromise<T1>,
+            source2: Observable<T2> | IPromise<T2>,
+            source3: Observable<T3> | IPromise<T3>,
+            source4: Observable<T4> | IPromise<T4>,
+            resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult,
+        ): Observable<TResult>;
+        zip<T1, T2, T3, T4, T5>(
+            source1: Observable<T1> | IPromise<T1>,
+            source2: Observable<T2> | IPromise<T2>,
+            source3: Observable<T3> | IPromise<T3>,
+            source4: Observable<T4> | IPromise<T4>,
+            source5: Observable<T5> | IPromise<T5>,
+        ): Observable<[T1, T2, T3, T4, T5]>;
+        zip<T1, T2, T3, T4, T5, TResult>(
+            source1: Observable<T1> | IPromise<T1>,
+            source2: Observable<T2> | IPromise<T2>,
+            source3: Observable<T3> | IPromise<T3>,
+            source4: Observable<T4> | IPromise<T4>,
+            source5: Observable<T5> | IPromise<T5>,
+            resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult,
+        ): Observable<TResult>;
         zipArray<T>(...sources: (Observable<T> | IPromise<T>)[]): Observable<T[]>;
@@ -643,17 +1040,55 @@ zipArray<T>(sources: (Observable<T> | IPromise<T>)[]): Observable<T[]>;
             <TResult>(func: (callback: (result: TResult) => any) => any, context?: any): () => Observable<TResult>;
-            <T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, context?: any): (arg1: T1) => Observable<TResult>;
-            <T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-            <T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+            <T1, TResult>(
+                func: (arg1: T1, callback: (result: TResult) => any) => any,
+                context?: any,
+            ): (arg1: T1) => Observable<TResult>;
+            <T1, T2, TResult>(
+                func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any,
+                context?: any,
+            ): (arg1: T1, arg2: T2) => Observable<TResult>;
+            <T1, T2, T3, TResult>(
+                func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any,
+                context?: any,
+            ): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
             // with any callback with selector
-            <TCallbackResult, TResult>(func: (callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
-            <T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
-            <T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
-            <T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+            <TCallbackResult, TResult>(
+                func: (callback: Function) => any,
+                context: any,
+                selector: (args: TCallbackResult[]) => TResult,
+            ): () => Observable<TResult>;
+            <T1, TCallbackResult, TResult>(
+                func: (arg1: T1, callback: Function) => any,
+                context: any,
+                selector: (args: TCallbackResult[]) => TResult,
+            ): (arg1: T1) => Observable<TResult>;
+            <T1, T2, TCallbackResult, TResult>(
+                func: (arg1: T1, arg2: T2, callback: Function) => any,
+                context: any,
+                selector: (args: TCallbackResult[]) => TResult,
+            ): (arg1: T1, arg2: T2) => Observable<TResult>;
+            <T1, T2, T3, TCallbackResult, TResult>(
+                func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any,
+                context: any,
+                selector: (args: TCallbackResult[]) => TResult,
+            ): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
             // with any callback without selector
             <TResult>(func: (callback: Function) => any, context?: any): () => Observable<TResult>;
-            <T1, TResult>(func: (arg1: T1, callback: Function) => any, context?: any): (arg1: T1) => Observable<TResult>;
-            <T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-            <T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+            <T1, TResult>(
+                func: (arg1: T1, callback: Function) => any,
+                context?: any,
+            ): (arg1: T1) => Observable<TResult>;
+            <T1, T2, TResult>(
+                func: (arg1: T1, arg2: T2, callback: Function) => any,
+                context?: any,
+            ): (arg1: T1, arg2: T2) => Observable<TResult>;
+            <T1, T2, T3, TResult>(
+                func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any,
+                context?: any,
+            ): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
             // with any function with selector
-            <TCallbackResult, TResult>(func: Function, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
+            <TCallbackResult, TResult>(
+                func: Function,
+                context: any,
+                selector: (args: TCallbackResult[]) => TResult,
+            ): (...args: any[]) => Observable<TResult>;
             // with any function without selector
@@ -666,15 +1101,46 @@ <TResult>(func: Function, context?: any): (...args: any[]) => Observable<TResult>;
             <T>(func: (callback: (err: any, result: T) => any) => any, context?: any): () => Observable<T>;
-            <T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1) => Observable<T>;
-            <T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
-            <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>;
+            <T1, T>(
+                func: (arg1: T1, callback: (err: any, result: T) => any) => any,
+                context?: any,
+            ): (arg1: T1) => Observable<T>;
+            <T1, T2, T>(
+                func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any,
+                context?: any,
+            ): (arg1: T1, arg2: T2) => Observable<T>;
+            <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>;
             // with any callback with selector
-            <TC, TR>(func: (callback: Function) => any, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
-            <T1, TC, TR>(func: (arg1: T1, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
-            <T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
-            <T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+            <TC, TR>(
+                func: (callback: Function) => any,
+                context: any,
+                selector: (results: TC[]) => TR,
+            ): () => Observable<TR>;
+            <T1, TC, TR>(
+                func: (arg1: T1, callback: Function) => any,
+                context: any,
+                selector: (results: TC[]) => TR,
+            ): (arg1: T1) => Observable<TR>;
+            <T1, T2, TC, TR>(
+                func: (arg1: T1, arg2: T2, callback: Function) => any,
+                context: any,
+                selector: (results: TC[]) => TR,
+            ): (arg1: T1, arg2: T2) => Observable<TR>;
+            <T1, T2, T3, TC, TR>(
+                func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any,
+                context: any,
+                selector: (results: TC[]) => TR,
+            ): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
             // with any callback without selector
             <TR>(func: (callback: Function) => any, context?: any): () => Observable<TR>;
             <T1, TR>(func: (arg1: T1, callback: Function) => any, context?: any): (arg1: T1) => Observable<TR>;
-            <T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
-            <T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+            <T1, T2, TR>(
+                func: (arg1: T1, arg2: T2, callback: Function) => any,
+                context?: any,
+            ): (arg1: T1, arg2: T2) => Observable<TR>;
+            <T1, T2, T3, TR>(
+                func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any,
+                context?: any,
+            ): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
             // with any function with selector
@@ -686,5 +1152,13 @@ <TC, T>(func: Function, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
 
-        fromEvent<T>(element: ArrayLike<DOMEventTarget> | DOMEventTarget | NodeEventTarget| NativeEventTarget, eventName: string, selector?: (...args: any[]) => T): Observable<T>;
+        fromEvent<T>(
+            element: ArrayLike<DOMEventTarget> | DOMEventTarget | NodeEventTarget | NativeEventTarget,
+            eventName: string,
+            selector?: (...args: any[]) => T,
+        ): Observable<T>;
 
-        fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (...args: any[]) => T): Observable<T>;
+        fromEventPattern<T>(
+            addHandler: (handler: Function) => void,
+            removeHandler: (handler: Function) => void,
+            selector?: (...args: any[]) => T,
+        ): Observable<T>;
     }
@@ -691,0 +1165,0 @@

rx-lite/package.json

 {
     "name": "@types/rx-lite",
-    "version": "4.0.6",
+    "version": "4.0.7",
     "description": "TypeScript definitions for rx-lite",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/rx-lite",
     "license": "MIT",
@@ -18,6 +19,7 @@ "contributors": [
     "main": "",
-    "types": "",
+    "types": "index.d.ts",
     "repository": {
         "type": "git",
-        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git"
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/rx-lite"
     },
@@ -29,4 +31,4 @@ "scripts": {},
     },
-    "typesPublisherContentHash": "f10c67e27e62bcdec1794fd0fac2ee2d5e557ec3f9bc831aad90a9c986aa13bf",
-    "typeScriptVersion": "2.0"
+    "typesPublisherContentHash": "8139a726b9c61834997ac5fa44821d0b266717f9d1a9985ed1457be3cae659d7",
+    "typeScriptVersion": "4.5"
 }

rx-lite/README.md

@@ -8,10 +8,10 @@ # Installation
 # Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/rx-lite
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/rx-lite.
 
-Additional Details
- * Last updated: Wed, 17 Oct 2018 20:11:30 GMT
- * Dependencies: rx-core, rx-core-binding
- * Global values: Rx
+### Additional Details
+ * Last updated: Wed, 27 Sep 2023 07:12:04 GMT
+ * Dependencies: [@types/rx-core](https://npmjs.com/package/@types/rx-core), [@types/rx-core-binding](https://npmjs.com/package/@types/rx-core-binding)
+ * Global values: `Rx`
 
 # Credits
-These definitions were written by gsino <http://www.codeplex.com/site/users/view/gsino>, Igor Oleinikov <https://github.com/Igorbek>.
+These definitions were written by [gsino](http://www.codeplex.com/site/users/view/gsino), and [Igor Oleinikov](https://github.com/Igorbek).

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No website

Quality

Package does not have a website.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

59582

increased by11.29%

Lines of code

1093

increased by75.72%

Number of low quality alerts

0

decreased by-100%

No dependency changes