text: /** OPERATOR INTERFACES */
  declare interface rxjs$UnaryFunction<T, R> {
    (source: T): R;
  }
  declare interface rxjs$OperatorFunction<T, R>
    extends rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$Observable<R>> {}
  declare type rxjs$FactoryOrValue<T> = T | (() => T);
  declare interface rxjs$MonoTypeOperatorFunction<T>
    extends rxjs$OperatorFunction<T, T> {}
  declare interface rxjs$Timestamp<T> {
    value: T;
    timestamp: number;
  }
  declare interface rxjs$TimeInterval<T> {
    value: T;
    interval: number;
  }
  /** SUBSCRIPTION INTERFACES */
  declare interface rxjs$Unsubscribable {
    unsubscribe(): void;
  }
  declare type rxjs$TeardownLogic = rxjs$Unsubscribable | Function | void;
  declare interface rxjs$SubscriptionLike extends rxjs$Unsubscribable {
    unsubscribe(): void;
    +closed: boolean;
  }
  declare type rxjs$SubscribableOrPromise<T> =
    | rxjs$Subscribable<T>
    | rxjs$Subscribable<empty>
    | Promise<T>
    | rxjs$InteropObservable<T>;
  
  /** OBSERVABLE INTERFACES */
  declare interface rxjs$Subscribable<T> {
    subscribe(observer?: rxjs$PartialObserver<T>): rxjs$Unsubscribable;
    subscribe(
      next?: (value: T) => void,
      error?: (error: any) => void,
      complete?: () => void
    ): rxjs$Unsubscribable;
  }
  declare type rxjs$ObservableInput<T> =
    | rxjs$SubscribableOrPromise<T>
    | Array<T>
    | Iterable<T>;
  
  declare type rxjs$InteropObservable<T> = { [string | mixed]: () => rxjs$Subscribable<T>, ... };
  /** OBSERVER INTERFACES */
  declare interface rxjs$NextObserver<T> {
    closed?: boolean;
    +next: (value: T) => void;
    +error?: (err: any) => void;
    +complete?: () => void;
  }
  declare interface rxjs$ErrorObserver<T> {
    closed?: boolean;
    +next?: (value: T) => void;
    +error: (err: any) => void;
    +complete?: () => void;
  }
  declare interface rxjs$CompletionObserver<T> {
    closed?: boolean;
    +next?: (value: T) => void;
    +error?: (err: any) => void;
    +complete: () => void;
  }
  declare interface rxjs$PartialObserver<T> {
    closed?: boolean;
    +next?: (value: T) => void;
    +error?: (err: any) => void;
    +complete?: () => void;
  }
  declare interface rxjs$Observer<T> {
    closed?: boolean;
    next(value: T): void;
    error(err: any): void;
    complete(): void;
  }
  /** SCHEDULER INTERFACES */
  declare interface rxjs$SchedulerLike {
    now(): number;
    schedule<T>(
      work: (state?: T) => void,
      delay?: number,
      state?: T
    ): rxjs$Subscription;
  }
  declare interface rxjs$SchedulerAction<T> extends rxjs$Subscription {
    schedule(state?: T, delay?: number): rxjs$Subscription;
  }
  
  declare interface rxjs$EventListenerOptions {
    capture?: boolean;
    passive?: boolean;
    once?: boolean;
  }
  
  declare class rxjs$Observable<T> implements rxjs$Subscribable<T> {
    // @internal
    _isScalar: boolean;
    // @deprecated  This is an internal implementation detail, do not use.
    source: rxjs$Observable<any>;
    // @deprecated  This is an internal implementation detail, do not use.
    operator: rxjs$Operator<any, T>;
    constructor(
      subscribe?: (subscriber: rxjs$Subscriber<T>) => rxjs$TeardownLogic
    ): void;
    static create(
      subscribe?: (subscriber: rxjs$Subscriber<T>) => rxjs$TeardownLogic
    ): rxjs$Observable<T>;
    lift<R>(operator: rxjs$Operator<T, R>): rxjs$Observable<R>;
    subscribe(observer?: rxjs$PartialObserver<T>): rxjs$Subscription;
    subscribe(
      next?: (value: T) => void,
      error?: (error: any) => void,
      complete?: () => void
    ): rxjs$Subscription;
    // @deprecated  This is an internal implementation detail, do not use.
    _trySubscribe(sink: rxjs$Subscriber<T>): rxjs$TeardownLogic;
    forEach(
      next: (value: T) => void,
      promiseCtor?: Promise.constructor
    ): Promise<void>;
    // @internal  This is an internal implementation detail, do not use.
    _subscribe(subscriber: rxjs$Subscriber<any>): rxjs$TeardownLogic;
    // @deprecated  In favor of iif creation function: import { iif } from 'rxjs';
    static if: typeof rxjs$iif;
    // @deprecated  In favor of throwError creation function: import { throwError } from 'rxjs';
    static throw: typeof rxjs$throwError;
    pipe(): rxjs$Observable<T>;
    pipe<A>(op1: rxjs$OperatorFunction<T, A>): rxjs$Observable<A>;
    pipe<A, B>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>
    ): rxjs$Observable<B>;
    pipe<A, B, C>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>
    ): rxjs$Observable<C>;
    pipe<A, B, C, D>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>,
      op4: rxjs$OperatorFunction<C, D>
    ): rxjs$Observable<D>;
    pipe<A, B, C, D, E>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>,
      op4: rxjs$OperatorFunction<C, D>,
      op5: rxjs$OperatorFunction<D, E>
    ): rxjs$Observable<E>;
    pipe<A, B, C, D, E, F>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>,
      op4: rxjs$OperatorFunction<C, D>,
      op5: rxjs$OperatorFunction<D, E>,
      op6: rxjs$OperatorFunction<E, F>
    ): rxjs$Observable<F>;
    pipe<A, B, C, D, E, F, G>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>,
      op4: rxjs$OperatorFunction<C, D>,
      op5: rxjs$OperatorFunction<D, E>,
      op6: rxjs$OperatorFunction<E, F>,
      op7: rxjs$OperatorFunction<F, G>
    ): rxjs$Observable<G>;
    pipe<A, B, C, D, E, F, G, H>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>,
      op4: rxjs$OperatorFunction<C, D>,
      op5: rxjs$OperatorFunction<D, E>,
      op6: rxjs$OperatorFunction<E, F>,
      op7: rxjs$OperatorFunction<F, G>,
      op8: rxjs$OperatorFunction<G, H>
    ): rxjs$Observable<H>;
    pipe<A, B, C, D, E, F, G, H, I>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>,
      op4: rxjs$OperatorFunction<C, D>,
      op5: rxjs$OperatorFunction<D, E>,
      op6: rxjs$OperatorFunction<E, F>,
      op7: rxjs$OperatorFunction<F, G>,
      op8: rxjs$OperatorFunction<G, H>,
      op9: rxjs$OperatorFunction<H, I>
    ): rxjs$Observable<I>;
    pipe<A, B, C, D, E, F, G, H, I>(
      op1: rxjs$OperatorFunction<T, A>,
      op2: rxjs$OperatorFunction<A, B>,
      op3: rxjs$OperatorFunction<B, C>,
      op4: rxjs$OperatorFunction<C, D>,
      op5: rxjs$OperatorFunction<D, E>,
      op6: rxjs$OperatorFunction<E, F>,
      op7: rxjs$OperatorFunction<F, G>,
      op8: rxjs$OperatorFunction<G, H>,
      op9: rxjs$OperatorFunction<H, I>,
      ...operations: rxjs$OperatorFunction<any, any>[]
    ): rxjs$Observable<{...}>;
    toPromise<T>(): Promise<T>;
    toPromise<T>(PromiseCtor: typeof Promise): Promise<T>;
    toPromise<T>(PromiseCtor: Promise.constructor): Promise<T>;
  }
  
  declare class rxjs$Subscription implements rxjs$SubscriptionLike {
    static EMPTY: rxjs$Subscription;
    closed: boolean;
    // @internal
    _parent: rxjs$Subscription;
    // @internal
    _parents: rxjs$Subscription[];
    constructor(unsubscribe?: () => void): void;
    unsubscribe(): void;
    add(teardown: rxjs$TeardownLogic): rxjs$Subscription;
    remove(subscription: rxjs$Subscription): void;
  }
  
  declare interface rxjs$Operator<T, R> {
    call(subscriber: rxjs$Subscriber<R>, source: any): rxjs$TeardownLogic;
  }
  
  declare class rxjs$Subscriber<T> extends rxjs$Subscription
    implements rxjs$Observer<T> {
    static create<T>(
      next?: (x?: T) => void,
      error?: (e?: any) => void,
      complete?: () => void
    ): rxjs$Subscriber<T>;
    // @internal
    syncErrorValue: any;
    // @internal
    syncErrorThrown: boolean;
    // @internal
    syncErrorThrowable: boolean;
    isStopped: boolean;
    destination: rxjs$PartialObserver<any> | rxjs$Subscriber<any>;
    constructor(
      destinationOrNext?: rxjs$PartialObserver<any> | ((value: T) => void),
      error?: (e?: any) => void,
      complete?: () => void
    ): void;
    next(value?: T): void;
    error(err?: any): void;
    complete(): void;
    unsubscribe(): void;
    _next(value: T): void;
    _error(err: any): void;
    _complete(): void;
    // @deprecated  This is an internal implementation detail, do not use.
    _unsubscribeAndRecycle(): rxjs$Subscriber<T>;
  }
  
  declare class rxjs$ConnectableObservable<T> extends rxjs$Observable<T> {
    source: rxjs$Observable<T>;
    subjectFactory: () => rxjs$Subject<T>;
    _subject: rxjs$Subject<T>;
    _refCount: number;
    _connection: rxjs$Subscription;
    // @internal
    _isComplete: boolean;
    constructor(
      source: rxjs$Observable<T>,
      subjectFactory: () => rxjs$Subject<T>
    ): void;
    // @deprecated  This is an internal implementation detail, do not use.
    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
    getSubject(): rxjs$Subject<T>;
    connect(): rxjs$Subscription;
    refCount(): rxjs$Observable<T>;
  }
  
  declare class rxjs$Subject<T> extends rxjs$Observable<T>
    implements rxjs$SubscriptionLike {
    observers: rxjs$Observer<T>[];
    closed: boolean;
    isStopped: boolean;
    hasError: boolean;
    thrownError: any;
    constructor(): void;
    static create: Function;
    lift<R>(operator: rxjs$Operator<T, R>): rxjs$Observable<R>;
    next(value?: T): void;
    error(err: any): void;
    complete(): void;
    unsubscribe(): void;
    // @deprecated  This is an internal implementation detail, do not use.
    _trySubscribe(subscriber: rxjs$Subscriber<T>): rxjs$TeardownLogic;
    // @deprecated  This is an internal implementation detail, do not use.
    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
    asObservable(): rxjs$Observable<T>;
  }
  
  declare class rxjs$Notification<T> {
    kind: string;
    value: T;
    error: any;
    hasValue: boolean;
    constructor(kind: string, value?: T, error?: any): void;
    observe(observer: rxjs$PartialObserver<T>): any;
    do(
      next: (value: T) => void,
      error?: (err: any) => void,
      complete?: () => void
    ): any;
    accept(
      nextOrObserver: rxjs$PartialObserver<T> | ((value: T) => void),
      error?: (err: any) => void,
      complete?: () => void
    ): any;
    toObservable(): rxjs$Observable<T>;
    static createNext<T>(value: T): rxjs$Notification<T>;
    static createError<T>(err?: any): rxjs$Notification<T>;
    static createComplete(): rxjs$Notification<any>;
  }
  
  declare class rxjs$GroupedObservable<K, T> extends rxjs$Observable<T> {
    key: K;
    // @deprecated  Do not construct this type. Internal use only
    constructor(
      key: K,
      groupSubject: rxjs$Subject<T>,
      refCountSubscription?: rxjs$RefCountSubscription
    ): void;
    // @deprecated  This is an internal implementation detail, do not use.
    _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
  }
  
  declare interface rxjs$RefCountSubscription {
    count: number;
    unsubscribe: () => void;
    closed: boolean;
    attemptedToUnsubscribe: boolean;
  }
  
  declare function rxjs$throwError(
    error: any,
    scheduler?: rxjs$SchedulerLike
  ): rxjs$Observable<any>;
  
  declare function rxjs$iif<T, F>(
    condition: () => boolean,
    trueResult?: rxjs$SubscribableOrPromise<T>,
    falseResult?: rxjs$SubscribableOrPromise<F>
  ): rxjs$Observable<T | F>;
  
  declare module "rxjs" {
    declare module.exports: {
      Observable: typeof rxjs$Observable,
      Subscriber: typeof rxjs$Subscriber,
      Subscription: typeof rxjs$Subscription,
      throwError: typeof rxjs$throwError,
      iif: typeof rxjs$iif,
      ConnectableObservable: typeof rxjs$ConnectableObservable,
      GroupedObservable: typeof rxjs$GroupedObservable,
      observable: string | mixed,
      Subject: typeof rxjs$Subject,
      BehaviorSubject: typeof BehaviorSubject,
      ReplaySubject: typeof ReplaySubject,
      AsyncSubject: typeof AsyncSubject,
      asapScheduler: AsapScheduler,
      asyncScheduler: AsyncScheduler,
      queueScheduler: QueueScheduler,
      animationFrameScheduler: AnimationFrameScheduler,
      VirtualTimeScheduler: typeof VirtualTimeScheduler,
      VirtualAction: typeof VirtualAction,
      Scheduler: typeof Scheduler,
      Notification: typeof rxjs$Notification,
      pipe: (<T>() => rxjs$UnaryFunction<T, T>) &
        (<T, A>(fn1: rxjs$UnaryFunction<T, A>) => rxjs$UnaryFunction<T, A>) &
        (<T, A, B>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>
        ) => rxjs$UnaryFunction<T, B>) &
        (<T, A, B, C>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>
        ) => rxjs$UnaryFunction<T, C>) &
        (<T, A, B, C, D>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>,
          fn4: rxjs$UnaryFunction<C, D>
        ) => rxjs$UnaryFunction<T, D>) &
        (<T, A, B, C, D, E>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>,
          fn4: rxjs$UnaryFunction<C, D>,
          fn5: rxjs$UnaryFunction<D, E>
        ) => rxjs$UnaryFunction<T, E>) &
        (<T, A, B, C, D, E, F>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>,
          fn4: rxjs$UnaryFunction<C, D>,
          fn5: rxjs$UnaryFunction<D, E>,
          fn6: rxjs$UnaryFunction<E, F>
        ) => rxjs$UnaryFunction<T, F>) &
        (<T, A, B, C, D, E, F, G>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>,
          fn4: rxjs$UnaryFunction<C, D>,
          fn5: rxjs$UnaryFunction<D, E>,
          fn6: rxjs$UnaryFunction<E, F>,
          fn7: rxjs$UnaryFunction<F, G>
        ) => rxjs$UnaryFunction<T, G>) &
        (<T, A, B, C, D, E, F, G, H>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>,
          fn4: rxjs$UnaryFunction<C, D>,
          fn5: rxjs$UnaryFunction<D, E>,
          fn6: rxjs$UnaryFunction<E, F>,
          fn7: rxjs$UnaryFunction<F, G>,
          fn8: rxjs$UnaryFunction<G, H>
        ) => rxjs$UnaryFunction<T, H>) &
        (<T, A, B, C, D, E, F, G, H, I>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>,
          fn4: rxjs$UnaryFunction<C, D>,
          fn5: rxjs$UnaryFunction<D, E>,
          fn6: rxjs$UnaryFunction<E, F>,
          fn7: rxjs$UnaryFunction<F, G>,
          fn8: rxjs$UnaryFunction<G, H>,
          fn9: rxjs$UnaryFunction<H, I>
        ) => rxjs$UnaryFunction<T, I>) &
        (<T, A, B, C, D, E, F, G, H, I>(
          fn1: rxjs$UnaryFunction<T, A>,
          fn2: rxjs$UnaryFunction<A, B>,
          fn3: rxjs$UnaryFunction<B, C>,
          fn4: rxjs$UnaryFunction<C, D>,
          fn5: rxjs$UnaryFunction<D, E>,
          fn6: rxjs$UnaryFunction<E, F>,
          fn7: rxjs$UnaryFunction<F, G>,
          fn8: rxjs$UnaryFunction<G, H>,
          fn9: rxjs$UnaryFunction<H, I>,
          ...fns: rxjs$UnaryFunction<any, any>[]
        ) => rxjs$UnaryFunction<T, {...}>),
      noop(): void,
      identity<T>(x: T): T,
      isObservable<T>(obj: any): boolean,
      concat: (<T>(
        v1: rxjs$ObservableInput<T>,
        scheduler?: rxjs$SchedulerLike
      ) => rxjs$Observable<T>) &
        (<T, T2>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2>) &
        (<T, T2, T3>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3>) &
        (<T, T2, T3, T4>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4>) &
        (<T, T2, T3, T4, T5>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
        (<T, T2, T3, T4, T5, T6>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
        (<T>(
          ...observables: (rxjs$ObservableInput<T> | rxjs$SchedulerLike)[]
        ) => rxjs$Observable<T>) &
        (<T, R>(
          ...observables: (rxjs$ObservableInput<any> | rxjs$SchedulerLike)[]
        ) => rxjs$Observable<R>),
      defer<T>(
        observableFactory: () => rxjs$SubscribableOrPromise<T> | null
      ): rxjs$Observable<T>,
      forkJoin: (<T>(
        sources: [rxjs$ObservableInput<T>]
      ) => rxjs$Observable<T[]>) &
        (<T, T2>(
          sources: [rxjs$ObservableInput<T>, rxjs$ObservableInput<T2>]
        ) => rxjs$Observable<[T, T2]>) &
        (<T, T2, T3>(
          sources: [
            rxjs$ObservableInput<T>,
            rxjs$ObservableInput<T2>,
            rxjs$ObservableInput<T3>
          ]
        ) => rxjs$Observable<[T, T2, T3]>) &
        (<T, T2, T3, T4>(
          sources: [
            rxjs$ObservableInput<T>,
            rxjs$ObservableInput<T2>,
            rxjs$ObservableInput<T3>,
            rxjs$ObservableInput<T4>
          ]
        ) => rxjs$Observable<[T, T2, T3, T4]>) &
        (<T, T2, T3, T4, T5>(
          sources: [
            rxjs$ObservableInput<T>,
            rxjs$ObservableInput<T2>,
            rxjs$ObservableInput<T3>,
            rxjs$ObservableInput<T4>,
            rxjs$ObservableInput<T5>
          ]
        ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
        (<T, T2, T3, T4, T5, T6>(
          sources: [
            rxjs$ObservableInput<T>,
            rxjs$ObservableInput<T2>,
            rxjs$ObservableInput<T3>,
            rxjs$ObservableInput<T4>,
            rxjs$ObservableInput<T5>,
            rxjs$ObservableInput<T6>
          ]
        ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
        (<T>(sources: Array<rxjs$ObservableInput<T>>) => rxjs$Observable<T[]>) &
        (<T>(v1: rxjs$ObservableInput<T>) => rxjs$Observable<T[]>) &
        (<T, T2>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>
        ) => rxjs$Observable<[T, T2]>) &
        (<T, T2, T3>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>
        ) => rxjs$Observable<[T, T2, T3]>) &
        (<T, T2, T3, T4>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>
        ) => rxjs$Observable<[T, T2, T3, T4]>) &
        (<T, T2, T3, T4, T5>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>
        ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
        (<T, T2, T3, T4, T5, T6>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>
        ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
        // @deprecated resultSelector is deprecated, pipe to map instead
        ((
          ...args: Array<rxjs$ObservableInput<any> | Function>
        ) => rxjs$Observable<any>) &
        (<T>(...sources: rxjs$ObservableInput<T>[]) => rxjs$Observable<T[]>),
      from<T>(
        input:
          | rxjs$ObservableInput<T>
          | rxjs$ObservableInput<rxjs$ObservableInput<T>>,
        scheduler?: rxjs$SchedulerLike
      ): rxjs$Observable<T>,
      ArgumentOutOfRangeError: ArgumentOutOfRangeError,
      EmptyError: EmptyError,
      ObjectUnsubscribedError: ObjectUnsubscribedError,
      UnsubscriptionError: UnsubscriptionError,
      TimeoutError: TimeoutError,
      fromEvent: <T>(
        target: mixed,
        eventName: string,
        options?: rxjs$EventListenerOptions | ((...args: any[]) => T),
        // @deprecated resultSelector no longer supported, pipe to map instead
        resultSelector?: (...args: any[]) => T
      ) => rxjs$Observable<T>,
      fromEventPattern: (<T>(
        addHandler: (handler: Function) => any,
        removeHandler?: (handler: Function, signal?: any) => void
      ) => rxjs$Observable<T>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<T>(
          addHandler: (handler: Function) => any,
          removeHandler?: (handler: Function, signal?: any) => void,
          resultSelector?: (...args: any[]) => T
        ) => rxjs$Observable<T>),
      generate<T, S>(
        initialState: S,
        condition: ConditionFunc<S>,
        iterate: IterateFunc<S>,
        resultSelector: ResultFunc<S, T>,
        scheduler?: rxjs$SchedulerLike
      ): rxjs$Observable<T>,
      interval(
        period?: number,
        scheduler?: rxjs$SchedulerLike
      ): rxjs$Observable<number>,
      merge: (<T>(
        ...observables: (rxjs$ObservableInput<T> | rxjs$SchedulerLike | number)[]
      ) => rxjs$Observable<T>) &
        (<T, R>(
          ...observables: (
            | rxjs$ObservableInput<any>
            | rxjs$SchedulerLike
            | number
          )[]
        ) => rxjs$Observable<R>) &
        (<T>(
          v1: rxjs$ObservableInput<T>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T>) &
        (<T>(
          v1: rxjs$ObservableInput<T>,
          concurrent?: number,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T>) &
        (<T, T2>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2>) &
        (<T, T2>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          concurrent?: number,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2>) &
        (<T, T2, T3>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3>) &
        (<T, T2, T3>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          concurrent?: number,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3>) &
        (<T, T2, T3, T4>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4>) &
        (<T, T2, T3, T4>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          concurrent?: number,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4>) &
        (<T, T2, T3, T4, T5>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
        (<T, T2, T3, T4, T5>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          concurrent?: number,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
        (<T, T2, T3, T4, T5, T6>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
        (<T, T2, T3, T4, T5, T6>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>,
          concurrent?: number,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>),
      of: (<T>(a: T, scheduler?: rxjs$SchedulerLike) => rxjs$Observable<T>) &
        (<T, T2>(
          a: T,
          b: T2,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2>) &
        (<T, T2, T3>(
          a: T,
          b: T2,
          c: T3,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3>) &
        (<T, T2, T3, T4>(
          a: T,
          b: T2,
          c: T3,
          d: T4,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4>) &
        (<T, T2, T3, T4, T5>(
          a: T,
          b: T2,
          c: T3,
          d: T4,
          e: T5,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5>) &
        (<T, T2, T3, T4, T5, T6>(
          a: T,
          b: T2,
          c: T3,
          d: T4,
          e: T5,
          f: T6,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6>) &
        (<T, T2, T3, T4, T5, T6, T7>(
          a: T,
          b: T2,
          c: T3,
          d: T4,
          e: T5,
          f: T6,
          g: T7,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7>) &
        (<T, T2, T3, T4, T5, T6, T7, T8>(
          a: T,
          b: T2,
          c: T3,
          d: T4,
          e: T5,
          f: T6,
          g: T7,
          h: T8,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8>) &
        (<T, T2, T3, T4, T5, T6, T7, T8, T9>(
          a: T,
          b: T2,
          c: T3,
          d: T4,
          e: T5,
          f: T6,
          g: T7,
          h: T8,
          i: T9,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>) &
        (<T>(...args: Array<T | rxjs$SchedulerLike>) => rxjs$Observable<T>),
      onErrorResumeNext: (<R>(v: rxjs$ObservableInput<R>) => rxjs$Observable<R>) &
        (<T2, T3, R>(
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>
        ) => rxjs$Observable<R>) &
        (<T2, T3, T4, R>(
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>
        ) => rxjs$Observable<R>) &
        (<T2, T3, T4, T5, R>(
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>
        ) => rxjs$Observable<R>) &
        (<T2, T3, T4, T5, T6, R>(
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>
        ) => rxjs$Observable<R>) &
        (<R>(
          ...observables: Array<
            rxjs$ObservableInput<any> | ((...values: Array<any>) => R)
          >
        ) => rxjs$Observable<R>) &
        (<R>(array: rxjs$ObservableInput<any>[]) => rxjs$Observable<R>),
      pairs<T>(
        obj: Object,
        scheduler?: rxjs$SchedulerLike
      ): rxjs$Observable<[string, T]>,
      race: (<T>(observables: Array<rxjs$Observable<T>>) => rxjs$Observable<T>) &
        (<T>(observables: Array<rxjs$Observable<any>>) => rxjs$Observable<T>) &
        (<T>(
          ...observables: Array<rxjs$Observable<T> | Array<rxjs$Observable<T>>>
        ) => rxjs$Observable<T>),
      range(
        start?: number,
        count?: number,
        scheduler?: rxjs$SchedulerLike
      ): rxjs$Observable<number>,
      timer(
        dueTime?: number | Date,
        periodOrScheduler?: number | rxjs$SchedulerLike,
        scheduler?: rxjs$SchedulerLike
      ): rxjs$Observable<number>,
      using<T>(
        resourceFactory: () => rxjs$Unsubscribable | void,
        observableFactory: (
          resource: rxjs$Unsubscribable | void
        ) => rxjs$ObservableInput<T> | void
      ): rxjs$Observable<T>,
      config: {
        Promise: Promise.constructor,
        useDeprecatedSynchronousErrorHandling: boolean,
        ...
      },
      // @deprecated  resultSelector is no longer supported, pipe to map instead
      zip: (<T, R>(
        v1: rxjs$ObservableInput<T>,
        resultSelector: (v1: T) => R
      ) => rxjs$Observable<R>) &
        // @deprecated resultSelector is no longer supported, pipe to map instead
        (<T, T2, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          resultSelector: (v1: T, v2: T2) => R
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector is no longer supported, pipe to map instead
        (<T, T2, T3, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          resultSelector: (v1: T, v2: T2, v3: T3) => R
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector is no longer supported, pipe to map instead
        (<T, T2, T3, T4, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => R
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector is no longer supported, pipe to map instead
        (<T, T2, T3, T4, T5, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector is no longer supported, pipe to map instead
        (<T, T2, T3, T4, T5, T6, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>,
          resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
        ) => rxjs$Observable<R>) &
        (<T, T2>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>
        ) => rxjs$Observable<[T, T2]>) &
        (<T, T2, T3>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>
        ) => rxjs$Observable<[T, T2, T3]>) &
        (<T, T2, T3, T4>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>
        ) => rxjs$Observable<[T, T2, T3, T4]>) &
        (<T, T2, T3, T4, T5>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>
        ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
        (<T, T2, T3, T4, T5, T6>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>
        ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
        (<T>(array: rxjs$ObservableInput<T>[]) => rxjs$Observable<T[]>) &
        (<R>(array: rxjs$ObservableInput<any>[]) => rxjs$Observable<R>) &
        // @deprecated resultSelector is no longer supported, pipe to map instead
        (<T, R>(
          array: rxjs$ObservableInput<T>[],
          resultSelector: (...values: Array<T>) => R
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector is no longer supported, pipe to map instead
        (<R>(
          array: rxjs$ObservableInput<any>[],
          resultSelector: (...values: Array<any>) => R
        ) => rxjs$Observable<R>) &
        (<T>(
          ...observables: Array<rxjs$ObservableInput<T>>
        ) => rxjs$Observable<T[]>) &
        (<T, R>(
          ...observables: Array<
            rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
          >
        ) => rxjs$Observable<R>) &
        (<R>(
          ...observables: Array<
            rxjs$ObservableInput<any> | ((...values: Array<any>) => R)
          >
        ) => rxjs$Observable<R>),
      // @deprecated  Deprecated in favor of using {@link  NEVER} constant.
      never(): rxjs$Observable<*>,
      NEVER: rxjs$Observable<*>,
      // @deprecated Deprecated in favor of using {@link EMPTY} constant.
      empty(scheduler?: rxjs$SchedulerLike): rxjs$Observable<*>,
      EMPTY: rxjs$Observable<*>,
      // @deprecated resultSelector is no longer supported, use a mapping function.
      bindCallback: ((
        callbackFunc: Function,
        resultSelector: Function,
        scheduler?: rxjs$SchedulerLike
      ) => (...args: any[]) => rxjs$Observable<any>) &
        (<R1, R2, R3, R4>(
          callbackFunc: (
            callback: (
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<mixed[]>) &
        (<R1, R2, R3>(
          callbackFunc: (callback: (res1: R1, res2: R2, res3: R3) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<[R1, R2, R3]>) &
        (<R1, R2>(
          callbackFunc: (callback: (res1: R1, res2: R2) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<[R1, R2]>) &
        (<R1>(
          callbackFunc: (callback: (res1: R1) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<R1>) &
        ((
          callbackFunc: (callback: () => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<void>) &
        (<A1, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            callback: (
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<mixed[]>) &
        (<A1, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            callback: (res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, R1, R2>(
          callbackFunc: (arg1: A1, callback: (res1: R1, res2: R2) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<[R1, R2]>) &
        (<A1, R1>(
          callbackFunc: (arg1: A1, callback: (res1: R1) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<R1>) &
        (<A1>(
          callbackFunc: (arg1: A1, callback: () => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<void>) &
        (<A1, A2, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            callback: (
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<mixed[]>) &
        (<A1, A2, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            callback: (res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            callback: (res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, R1>(
          callbackFunc: (arg1: A1, arg2: A2, callback: (res1: R1) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<R1>) &
        (<A1, A2>(
          callbackFunc: (arg1: A1, arg2: A2, callback: () => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<void>) &
        (<A1, A2, A3, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<mixed[]>) &
        (<A1, A2, A3, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, A3, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, A3, R1>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (res1: R1) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<R1>) &
        (<A1, A2, A3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: () => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<void>) &
        (<A1, A2, A3, A4, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4
        ) => rxjs$Observable<mixed[]>) &
        (<A1, A2, A3, A4, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4
        ) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, A3, A4, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4
        ) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, A3, A4, R1>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (res1: R1) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<R1>) &
        (<A1, A2, A3, A4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: () => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<void>) &
        (<A1, A2, A3, A4, A5, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<mixed[]>) &
        (<A1, A2, A3, A4, A5, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, A3, A4, A5, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, A3, A4, A5, R1>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (res1: R1) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<R1>) &
        (<A1, A2, A3, A4, A5>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: () => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<void>) &
        (<A, R>(
          callbackFunc: (...args: Array<A | ((result: R) => any)>) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: A[]) => rxjs$Observable<R>) &
        (<A, R>(
          callbackFunc: (...args: Array<A | ((...results: R[]) => any)>) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: A[]) => rxjs$Observable<R[]>) &
        ((
          callbackFunc: Function,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<any>),
      // @deprecated resultSelector is deprecated, pipe to map instead
      bindNodeCallback: ((
        callbackFunc: Function,
        resultSelector: Function,
        scheduler?: rxjs$SchedulerLike
      ) => (...args: any[]) => rxjs$Observable<*>) &
        (<R1, R2, R3, R4>(
          callbackFunc: (
            callback: (
              err: any,
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
        (<R1, R2, R3>(
          callbackFunc: (
            callback: (err: any, res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<[R1, R2, R3]>) &
        (<R1, R2>(
          callbackFunc: (callback: (err: any, res1: R1, res2: R2) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<[R1, R2]>) &
        (<R1>(
          callbackFunc: (callback: (err: any, res1: R1) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<R1>) &
        ((
          callbackFunc: (callback: (err: any) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => () => rxjs$Observable<void>) &
        (<T, A1, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            callback: (
              err: any,
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<T>) &
        (<A1, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            callback: (err: any, res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, R1, R2>(
          callbackFunc: (
            arg1: A1,
            callback: (err: any, res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<[R1, R2]>) &
        (<A1, R1>(
          callbackFunc: (arg1: A1, callback: (err: any, res1: R1) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<R1>) &
        (<A1>(
          callbackFunc: (arg1: A1, callback: (err: any) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1) => rxjs$Observable<void>) &
        (<A1, A2, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            callback: (
              err: any,
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
        (<A1, A2, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            callback: (err: any, res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            callback: (err: any, res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, R1>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            callback: (err: any, res1: R1) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<R1>) &
        (<A1, A2>(
          callbackFunc: (arg1: A1, arg2: A2, callback: (err: any) => any) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2) => rxjs$Observable<void>) &
        (<T, A1, A2, A3, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (
              err: any,
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<T>) &
        (<A1, A2, A3, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (err: any, res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, A3, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (err: any, res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, A3, R1>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (err: any, res1: R1) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<R1>) &
        (<A1, A2, A3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            callback: (err: any) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3) => rxjs$Observable<void>) &
        (<A1, A2, A3, A4, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (
              err: any,
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
        (<A1, A2, A3, A4, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (err: any, res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4
        ) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, A3, A4, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (err: any, res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4
        ) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, A3, A4, R1>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (err: any, res1: R1) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<R1>) &
        (<A1, A2, A3, A4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            callback: (err: any) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => rxjs$Observable<void>) &
        (<A1, A2, A3, A4, A5, R1, R2, R3, R4>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (
              err: any,
              res1: R1,
              res2: R2,
              res3: R3,
              res4: R4,
              ...args: any[]
            ) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<mixed[]>) &
        (<A1, A2, A3, A4, A5, R1, R2, R3>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (err: any, res1: R1, res2: R2, res3: R3) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<[R1, R2, R3]>) &
        (<A1, A2, A3, A4, A5, R1, R2>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (err: any, res1: R1, res2: R2) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<[R1, R2]>) &
        (<A1, A2, A3, A4, A5, R1>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (err: any, res1: R1) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<R1>) &
        (<A1, A2, A3, A4, A5>(
          callbackFunc: (
            arg1: A1,
            arg2: A2,
            arg3: A3,
            arg4: A4,
            arg5: A5,
            callback: (err: any) => any
          ) => any,
          scheduler?: rxjs$SchedulerLike
        ) => (
          arg1: A1,
          arg2: A2,
          arg3: A3,
          arg4: A4,
          arg5: A5
        ) => rxjs$Observable<void>) &
        ((
          callbackFunc: Function,
          scheduler?: rxjs$SchedulerLike
        ) => (...args: any[]) => rxjs$Observable<mixed[]>),
      // @deprecated resultSelector no longer supported, pipe to map instead
      combineLatest: (<T, R>(
        v1: rxjs$ObservableInput<T>,
        resultSelector: (v1: T) => R,
        scheduler?: rxjs$SchedulerLike
      ) => rxjs$Observable<R>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<T, T2, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          resultSelector: (v1: T, v2: T2) => R,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<T, T2, T3, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          resultSelector: (v1: T, v2: T2, v3: T3) => R,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<T, T2, T3, T4, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => R,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<T, T2, T3, T4, T5, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<T, T2, T3, T4, T5, T6, R>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>,
          resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        (<T, T2>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<[T, T2]>) &
        (<T, T2, T3>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<[T, T2, T3]>) &
        (<T, T2, T3, T4>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<[T, T2, T3, T4]>) &
        (<T, T2, T3, T4, T5>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<[T, T2, T3, T4, T5]>) &
        (<T, T2, T3, T4, T5, T6>(
          v1: rxjs$ObservableInput<T>,
          v2: rxjs$ObservableInput<T2>,
          v3: rxjs$ObservableInput<T3>,
          v4: rxjs$ObservableInput<T4>,
          v5: rxjs$ObservableInput<T5>,
          v6: rxjs$ObservableInput<T6>,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<[T, T2, T3, T4, T5, T6]>) &
        (<T>(
          array: rxjs$ObservableInput<T>[],
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<T[]>) &
        (<R>(
          array: rxjs$ObservableInput<any>[],
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<T, R>(
          array: rxjs$ObservableInput<T>[],
          resultSelector: (...values: Array<T>) => R,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        // @deprecated resultSelector no longer supported, pipe to map instead
        (<R>(
          array: rxjs$ObservableInput<any>[],
          resultSelector: (...values: Array<any>) => R,
          scheduler?: rxjs$SchedulerLike
        ) => rxjs$Observable<R>) &
        (<T>(
          ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike>
        ) => rxjs$Observable<T[]>) &
        (<T, R>(
          ...observables: Array<
            | rxjs$ObservableInput<T>
            | ((...values: Array<T>) => R)
            | rxjs$SchedulerLike
          >
        ) => rxjs$Observable<R>) &
        (<R>(
          ...observables: Array<
            | rxjs$ObservableInput<any>
            | ((...values: Array<any>) => R)
            | rxjs$SchedulerLike
          >
        ) => rxjs$Observable<R>),
      ...
    };
  
    declare class BehaviorSubject<T> extends rxjs$Subject<T> {
      constructor(_value: T): void;
      +value: T;
      // @deprecated  This is an internal implementation detail, do not use.
      _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
      getValue(): T;
      next(value?: T): void;
    }
  
    declare class ReplaySubject<T> extends rxjs$Subject<T> {
      constructor(
        bufferSize?: number,
        windowTime?: number,
        scheduler?: rxjs$SchedulerLike
      ): void;
      // @deprecated  This is an internal implementation detail, do not use.
      _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
      _getNow(): number;
    }
  
    declare class AsyncSubject<T> extends rxjs$Subject<T> {
      // @deprecated  This is an internal implementation detail, do not use.
      _subscribe(subscriber: rxjs$Subscriber<*>): rxjs$Subscription;
      next(value?: T): void;
      error(error: any): void;
      complete(): void;
    }
  
    declare class VirtualTimeScheduler extends AsyncScheduler {
      maxFrames: number;
      static frameTimeFactor: number;
      frame: number;
      index: number;
      constructor(SchedulerAction?: typeof AsyncAction, maxFrames?: number): void;
      flush(): void;
    }
  
    declare class VirtualAction<T> extends AsyncAction<T> {
      scheduler: AsyncScheduler | VirtualTimeScheduler;
      work: (state?: T) => void;
      index: number;
      active: boolean;
      constructor(
        scheduler: AsyncScheduler | VirtualTimeScheduler,
        work: (state?: T) => void,
        index?: number
      ): void;
      schedule(state?: T, delay?: number): rxjs$Subscription;
      requestAsyncId(
        scheduler: AsyncScheduler | VirtualTimeScheduler,
        id?: any,
        delay?: number
      ): any;
      recycleAsyncId(
        scheduler: AsyncScheduler | VirtualTimeScheduler,
        id?: any,
        delay?: number
      ): any;
      _execute(state: T, delay: number): any;
      static sortActions<T>(a: VirtualAction<T>, b: VirtualAction<T>): 1 | -1 | 0;
    }
  
    declare class Scheduler implements rxjs$SchedulerLike {
      static now: () => number;
      constructor(SchedulerAction: typeof Action, now?: () => number): void;
      now: () => number;
      schedule<T>(
        work: (state?: T) => void,
        delay?: number,
        state?: T
      ): rxjs$Subscription;
    }
  
    declare interface ArgumentOutOfRangeError extends Error {}
  
    declare interface EmptyError extends Error {}
  
    declare interface ObjectUnsubscribedError extends Error {}
  
    declare interface UnsubscriptionError extends Error {
      +errors: any[];
    }
  
    declare interface TimeoutError extends Error {}
  
    declare type ConditionFunc<S> = (state: S) => boolean;
    declare type IterateFunc<S> = (state: S) => S;
    declare type ResultFunc<S, T> = (state: S) => T;
    declare interface GenerateBaseOptions<S> {
      initialState: S;
      condition?: ConditionFunc<S>;
      iterate: IterateFunc<S>;
      scheduler?: rxjs$SchedulerLike;
    }
    declare interface GenerateOptions<T, S> extends GenerateBaseOptions<S> {
      resultSelector: ResultFunc<S, T>;
    }
  
    declare class AsapScheduler extends AsyncScheduler {
      flush(action?: AsyncAction<mixed>): void;
    }
  
    declare class AsyncScheduler extends Scheduler {
      static delegate: Scheduler;
      actions: Array<AsyncAction<mixed>>;
      // @deprecated  internal use only
      active: boolean;
      // @deprecated  internal use only
      scheduled: any;
      constructor(SchedulerAction: typeof Action, now?: () => number): void;
      schedule<T>(
        work: (state?: T) => void,
        delay?: number,
        state?: T
      ): rxjs$Subscription;
      flush(action: AsyncAction<mixed>): void;
    }
  
    declare class QueueScheduler extends AsyncScheduler {}
  
    declare class AnimationFrameScheduler extends AsyncScheduler {
      flush(action?: AsyncAction<mixed>): void;
    }
  
    declare class AsyncAction<T> extends Action<T> {
      scheduler: AsyncScheduler;
      work: (state?: T) => void;
      id: mixed;
      state: T;
      delay: number;
      pending: boolean;
      constructor(scheduler: AsyncScheduler, work: (state?: T) => void): void;
      schedule(state?: T, delay?: number): rxjs$Subscription;
      requestAsyncId(scheduler: AsyncScheduler, id?: mixed, delay?: number): any;
      recycleAsyncId(scheduler: AsyncScheduler, id: mixed, delay?: number): any;
      execute(state: T, delay: number): any;
      _execute(state: T, delay: number): any;
      // @deprecated  This is an internal implementation detail, do not use.
      _unsubscribe(): void;
    }
  
    declare class Action<T> extends rxjs$Subscription {
      constructor(scheduler: Scheduler, work: (state?: T) => void): void;
      schedule(state?: T, delay?: number): rxjs$Subscription;
    }
  }
  
  declare module "rxjs/operators" {
    declare export function audit<T>(
      durationSelector: (value: T) => rxjs$SubscribableOrPromise<mixed>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function auditTime<T>(
      duration: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function buffer<T>(
      closingNotifier: rxjs$Observable<any>
    ): rxjs$OperatorFunction<T, T[]>;
  
    declare export function bufferCount<T>(
      bufferSize: number,
      startBufferEvery?: number
    ): rxjs$OperatorFunction<T, T[]>;
  
    declare export function bufferTime<T>(
      bufferTimeSpan: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T[]>;
  
    declare export function bufferTime<T>(
      bufferTimeSpan: number,
      bufferCreationInterval: ?number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T[]>;
  
    declare export function bufferTime<T>(
      bufferTimeSpan: number,
      bufferCreationInterval: ?number,
      maxBufferSize: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T[]>;
  
    declare export function bufferToggle<T, O>(
      openings: rxjs$SubscribableOrPromise<O>,
      closingSelector: (value: O) => rxjs$SubscribableOrPromise<mixed>
    ): rxjs$OperatorFunction<T, T[]>;
  
    declare export function bufferWhen<T>(
      closingSelector: () => rxjs$Observable<mixed>
    ): rxjs$OperatorFunction<T, T[]>;
  
    // declare export function catchError<T>(selector: (err: any, caught: rxjs$Observable<T>) => empty): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function catchError<T, R>(
      selector: (err: any, caught: rxjs$Observable<T>) => rxjs$ObservableInput<R>
    ): rxjs$OperatorFunction<T, T | R>;
  
    declare export function combineAll<T>(): rxjs$OperatorFunction<
      rxjs$ObservableInput<T>,
      T[]
    >;
  
    declare export function combineAll<T>(): rxjs$OperatorFunction<mixed, T[]>;
  
    declare export function combineAll<T, R>(
      project: (...values: T[]) => R
    ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, R>;
  
    declare export function combineAll<R>(
      project: (...values: Array<mixed>) => R
    ): rxjs$OperatorFunction<mixed, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, R>(
      project: (v1: T) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, R>(
      v2: rxjs$ObservableInput<T2>,
      project: (v1: T, v2: T2) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      project: (v1: T, v2: T2, v3: T3) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3, T4, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      project: (v1: T, v2: T2, v3: T3, v4: T4) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3, T4, T5, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3, T4, T5, T6, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>,
      project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2>(
      v2: rxjs$ObservableInput<T2>
    ): rxjs$OperatorFunction<T, [T, T2]>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>
    ): rxjs$OperatorFunction<T, [T, T2, T3]>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3, T4>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3, T4, T5>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, T2, T3, T4, T5, T6>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, R>(
      ...observables: Array<
        rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
      >
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, R>(
      array: rxjs$ObservableInput<T>[]
    ): rxjs$OperatorFunction<T, Array<T>>;
  
    // @deprecated Deprecated in favor of static combineLatest.
    declare export function combineLatest<T, TOther, R>(
      array: rxjs$ObservableInput<TOther>[],
      project: (v1: T, ...values: Array<TOther>) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated  Deprecated in favor of static concat.
    declare export function concat<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated Deprecated in favor of static concat.
    declare export function concat<T, T2>(
      v2: rxjs$ObservableInput<T2>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2>;
  
    // @deprecated Deprecated in favor of static concat.
    declare export function concat<T, T2, T3>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3>;
  
    // @deprecated Deprecated in favor of static concat.
    declare export function concat<T, T2, T3, T4>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
  
    // @deprecated Deprecated in favor of static concat.
    declare export function concat<T, T2, T3, T4, T5>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
    // @deprecated Deprecated in favor of static concat.
    declare export function concat<T, T2, T3, T4, T5, T6>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
    // @deprecated Deprecated in favor of static concat.
    declare export function concat<T>(
      ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike>
    ): rxjs$MonoTypeOperatorFunction<T>;
    // @deprecated Deprecated in favor of static concat.
    declare export function concat<T, R>(
      ...observables: Array<rxjs$ObservableInput<mixed> | rxjs$SchedulerLike>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function concatAll<T>(): rxjs$OperatorFunction<
      rxjs$ObservableInput<T>,
      T
    >;
  
    declare export function concatAll<R>(): rxjs$OperatorFunction<mixed, R>;
  
    declare export function concatMap<T, I, R>(
      project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
      resultSelector?: (
        outerValue: T,
        innerValue: I,
        outerIndex: number,
        innerIndex: number
      ) => R
    ): rxjs$OperatorFunction<T, I | R>;
  
    declare export function concatMapTo<T>(
      observable: rxjs$ObservableInput<T>
    ): rxjs$OperatorFunction<mixed, T>;
  
    // @deprecated
    declare export function concatMapTo<T>(
      observable: rxjs$ObservableInput<T>,
      resultSelector: void
    ): rxjs$OperatorFunction<mixed, T>;
    // @deprecated
    declare export function concatMapTo<T, I, R>(
      observable: rxjs$ObservableInput<I>,
      resultSelector: (
        outerValue: T,
        innerValue: I,
        outerIndex: number,
        innerIndex: number
      ) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function count<T>(
      predicate?: (value: T, index: number, source: rxjs$Observable<T>) => boolean
    ): rxjs$OperatorFunction<T, number>;
  
    declare export function debounce<T>(
      durationSelector: (value: T) => rxjs$SubscribableOrPromise<mixed>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function debounceTime<T>(
      dueTime: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function defaultIfEmpty<T>(
      defaultValue?: T
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function delay<T>(
      delay: number | Date,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function delayWhen<T>(
      delayDurationSelector: (value: T, index: number) => rxjs$Observable<mixed>,
      subscriptionDelay?: rxjs$Observable<mixed>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function dematerialize<T>(): rxjs$OperatorFunction<
      rxjs$Notification<T>,
      T
    >;
  
    declare export function distinct<T, K>(
      keySelector?: (value: T) => K,
      flushes?: rxjs$Observable<mixed>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function distinctUntilChanged<T>(
      compare?: (x: T, y: T) => boolean
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function distinctUntilChanged<T, K>(
      compare: (x: K, y: K) => boolean,
      keySelector: (x: T) => K
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function distinctUntilKeyChanged<T>(
      key: $Keys<T>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function distinctUntilKeyChanged<T, K: $Keys<T>>(
      key: K,
      compare: (x: mixed, y: mixed) => boolean
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function elementAt<T>(
      index: number,
      defaultValue?: T
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function endWith<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function endWith<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
    declare export function endWith<T>(
      v1: T,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
    declare export function endWith<T>(
      v1: T,
      v2: T,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
    declare export function endWith<T>(
      v1: T,
      v2: T,
      v3: T,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
    declare export function endWith<T>(
      v1: T,
      v2: T,
      v3: T,
      v4: T,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
    declare export function endWith<T>(
      v1: T,
      v2: T,
      v3: T,
      v4: T,
      v5: T,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
    declare export function endWith<T>(
      v1: T,
      v2: T,
      v3: T,
      v4: T,
      v5: T,
      v6: T,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
    declare export function endWith<T>(
      ...array: Array<T | rxjs$SchedulerLike>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function every<T>(
      predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
      thisArg?: any
    ): rxjs$OperatorFunction<T, boolean>;
  
    declare export function exhaust<T>(): rxjs$OperatorFunction<
      rxjs$ObservableInput<T>,
      T
    >;
  
    declare export function exhaust<R>(): rxjs$OperatorFunction<mixed, R>;
  
    declare export function exhaustMap<T, I, R>(
      project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
      // @deprecated resultSelector is no longer supported. Use inner map instead.
      resultSelector?: (
        outerValue: T,
        innerValue: I,
        outerIndex: number,
        innerIndex: number
      ) => R
    ): rxjs$OperatorFunction<T, I | R>;
  
    declare export function expand<T, R>(
      project: (value: T, index: number) => rxjs$ObservableInput<R>,
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function expand<T>(
      project: (value: T, index: number) => rxjs$ObservableInput<T>,
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function filter<T, S: T>(
      predicate: (value: T, index: number) => boolean,
      thisArg?: any
    ): rxjs$OperatorFunction<T, S>;
  
    declare export function filter<T>(
      predicate: (value: T, index: number) => boolean,
      thisArg?: any
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function finalize<T>(
      callback: () => void
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function find<T, S: T>(
      predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
      thisArg?: any
    ): rxjs$OperatorFunction<T, T | S | void>;
  
    declare export function findIndex<T>(
      predicate: (value: T, index: number, source: rxjs$Observable<T>) => boolean,
      thisArg?: any
    ): rxjs$OperatorFunction<T, number>;
  
    declare export function first<T>(
      predicate?: ?(
        value: T,
        index: number,
        source: rxjs$Observable<T>
      ) => boolean
    ): rxjs$OperatorFunction<T, T>;
  
    declare export function first<T, D>(
      predicate?: ?(
        value: T,
        index: number,
        source: rxjs$Observable<T>
      ) => boolean,
      defaultValue?: D
    ): rxjs$OperatorFunction<T, T | D>;
  
    declare export function groupBy<T, K>(
      keySelector: (value: T) => K
    ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, T>>;
  
    declare export function groupBy<T, K>(
      keySelector: (value: T) => K,
      elementSelector: void,
      durationSelector: (
        grouped: rxjs$GroupedObservable<K, T>
      ) => rxjs$Observable<mixed>
    ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, T>>;
  
    declare export function groupBy<T, K, R>(
      keySelector: (value: T) => K,
      elementSelector?: (value: T) => R,
      durationSelector?: (
        grouped: rxjs$GroupedObservable<K, R>
      ) => rxjs$Observable<mixed>,
      subjectSelector?: () => rxjs$Subject<R>
    ): rxjs$OperatorFunction<T, rxjs$GroupedObservable<K, R>>;
  
    declare export function ignoreElements<T, U>(): rxjs$OperatorFunction<T, U>;
  
    declare export function isEmpty<T>(): rxjs$OperatorFunction<T, boolean>;
  
    declare export function last<T>(
      predicate?: ?(
        value: T,
        index: number,
        source: rxjs$Observable<T>
      ) => boolean
    ): rxjs$OperatorFunction<T, T>;
  
    declare export function last<T, D>(
      predicate?: ?(
        value: T,
        index: number,
        source: rxjs$Observable<T>
      ) => boolean,
      defaultValue?: D
    ): rxjs$OperatorFunction<T, T | D>;
  
    declare export function map<T, R>(
      project: (value: T, index: number) => R,
      thisArg?: any
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function mapTo<T, R>(value: R): rxjs$OperatorFunction<T, R>;
  
    declare export function materialize<T>(): rxjs$OperatorFunction<
      T,
      rxjs$Notification<T>
    >;
  
    declare export function max<T>(
      comparer?: (x: T, y: T) => number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated  Deprecated in favor of static merge.
    declare export function merge<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T>(
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2>(
      v2: rxjs$ObservableInput<T2>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2>(
      v2: rxjs$ObservableInput<T2>,
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3, T4>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3, T4>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3, T4, T5>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3, T4, T5>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3, T4, T5, T6>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, T2, T3, T4, T5, T6>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>,
      concurrent?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T>(
      ...observables: Array<rxjs$ObservableInput<T> | rxjs$SchedulerLike | number>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated Deprecated in favor of static merge.
    declare export function merge<T, R>(
      ...observables: Array<
        rxjs$ObservableInput<mixed> | rxjs$SchedulerLike | number
      >
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function mergeAll<T>(
      concurrent?: number
    ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, T>;
  
    declare export function mergeMap<T, I, R>(
      project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
      // @deprecated resultSelector no longer supported, use inner map instead
      resultSelector?:
        | ((
            outerValue: T,
            innerValue: I,
            outerIndex: number,
            innerIndex: number
          ) => R)
        | number,
      concurrent?: number
    ): rxjs$OperatorFunction<T, I | R>;
  
    declare export function flatMap<T, R>(
      project: (value: T, index: number) => rxjs$ObservableInput<R>,
      concurrent?: number
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function mergeMapTo<T>(
      innerObservable: rxjs$ObservableInput<T>,
      concurrent?: number
    ): rxjs$OperatorFunction<mixed, T>;
  
    // @deprecated
    declare export function mergeMapTo<T, I, R>(
      innerObservable: rxjs$ObservableInput<I>,
      resultSelector: (
        outerValue: T,
        innerValue: I,
        outerIndex: number,
        innerIndex: number
      ) => R,
      concurrent?: number
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function mergeScan<T, R>(
      accumulator: (acc: R, value: T) => rxjs$ObservableInput<R>,
      seed: R,
      concurrent?: number
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function min<T>(
      comparer?: (x: T, y: T) => number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function multicast<T>(
      subjectOrSubjectFactory: rxjs$FactoryOrValue<rxjs$Subject<T>>
    ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
  
    declare export function multicast<T>(
      rxjs$SubjectFactory: () => rxjs$Subject<T>
    ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
  
    declare export function multicast<T>(
      rxjs$SubjectFactory: () => rxjs$Subject<T>,
      selector?: rxjs$MonoTypeOperatorFunction<T>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function multicast<T, R>(
      rxjs$SubjectFactory: () => rxjs$Subject<T>
    ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<R>>;
  
    declare export function multicast<T, R>(
      rxjs$SubjectFactory: () => rxjs$Subject<T>,
      selector?: rxjs$OperatorFunction<T, R>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function observeOn<T>(
      scheduler: rxjs$SchedulerLike,
      delay?: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function onErrorResumeNext<T, R>(
      v: rxjs$ObservableInput<R>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function onErrorResumeNext<T, T2, T3, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function onErrorResumeNext<T, T2, T3, T4, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function onErrorResumeNext<T, T2, T3, T4, T5, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function onErrorResumeNext<T, T2, T3, T4, T5, T6, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function onErrorResumeNext<T, R>(
      ...observables: Array<
        rxjs$ObservableInput<mixed> | ((...values: Array<mixed>) => R)
      >
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function onErrorResumeNext<T, R>(
      array: rxjs$ObservableInput<mixed>[]
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function onErrorResumeNextStatic<R>(
      v: rxjs$ObservableInput<R>
    ): rxjs$Observable<R>;
  
    declare export function onErrorResumeNextStatic<T2, T3, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>
    ): rxjs$Observable<R>;
  
    declare export function onErrorResumeNextStatic<T2, T3, T4, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>
    ): rxjs$Observable<R>;
  
    declare export function onErrorResumeNextStatic<T2, T3, T4, T5, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>
    ): rxjs$Observable<R>;
  
    declare export function onErrorResumeNextStatic<T2, T3, T4, T5, T6, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>
    ): rxjs$Observable<R>;
  
    declare export function onErrorResumeNextStatic<R>(
      ...observables: Array<
        rxjs$ObservableInput<mixed> | ((...values: Array<any>) => R)
      >
    ): rxjs$Observable<R>;
  
    declare export function onErrorResumeNextStatic<R>(
      array: rxjs$ObservableInput<mixed>[]
    ): rxjs$Observable<R>;
  
    declare export function pairwise<T>(): rxjs$OperatorFunction<T, [T, T]>;
  
    declare export function partition<T>(
      predicate: (value: T, index: number) => boolean,
      thisArg?: any
    ): rxjs$UnaryFunction<
      rxjs$Observable<T>,
      [rxjs$Observable<T>, rxjs$Observable<T>]
    >;
  
    declare export function pluck<T, R>(
      ...properties: string[]
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function publish<T>(): rxjs$UnaryFunction<
      rxjs$Observable<T>,
      rxjs$ConnectableObservable<T>
    >;
  
    declare export function publish<T, R>(
      selector: rxjs$OperatorFunction<T, R>
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function publish<T>(
      selector: rxjs$MonoTypeOperatorFunction<T>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function publishBehavior<T>(
      value: T
    ): rxjs$UnaryFunction<rxjs$Observable<T>, rxjs$ConnectableObservable<T>>;
  
    declare export function publishLast<T>(): rxjs$UnaryFunction<
      rxjs$Observable<T>,
      rxjs$ConnectableObservable<T>
    >;
  
    declare export function publishReplay<T>(
      bufferSize?: number,
      windowTime?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function publishReplay<T, R>(
      bufferSize?: number,
      windowTime?: number,
      selector?: rxjs$OperatorFunction<T, R>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function publishReplay<T>(
      bufferSize?: number,
      windowTime?: number,
      selector?: rxjs$MonoTypeOperatorFunction<T>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated  Deprecated in favor of static race.
    declare export function race<T>(
      observables: Array<rxjs$Observable<T>>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated Deprecated in favor of static race.
    declare export function race<T, R>(
      observables: Array<rxjs$Observable<T>>
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static race.
    declare export function race<T>(
      ...observables: Array<rxjs$Observable<T> | Array<rxjs$Observable<T>>>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    // @deprecated Deprecated in favor of static race.
    declare export function race<T, R>(
      ...observables: Array<
        rxjs$Observable<mixed> | Array<rxjs$Observable<mixed>>
      >
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function reduce<T>(
      accumulator: (acc: T, value: T, index: number) => T,
      seed?: T
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function reduce<T>(
      accumulator: (acc: T[], value: T, index: number) => T[],
      seed: T[]
    ): rxjs$OperatorFunction<T, T[]>;
    declare export function reduce<T, R>(
      accumulator: (acc: R, value: T, index: number) => R,
      seed?: R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function repeat<T>(
      count?: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function repeatWhen<T>(
      notifier: (notifications: rxjs$Observable<any>) => rxjs$Observable<mixed>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function retry<T>(
      count?: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function retryWhen<T>(
      notifier: (errors: rxjs$Observable<any>) => rxjs$Observable<mixed>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function refCount<T>(): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function sample<T>(
      notifier: rxjs$Observable<any>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function sampleTime<T>(
      period: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function scan<T>(
      accumulator: (acc: T, value: T, index: number) => T,
      seed?: T
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function scan<T>(
      accumulator: (acc: T[], value: T, index: number) => T[],
      seed?: T[]
    ): rxjs$OperatorFunction<T, T[]>;
  
    declare export function scan<T, R>(
      accumulator: (acc: R, value: T, index: number) => R,
      seed?: R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function sequenceEqual<T>(
      compareTo: rxjs$Observable<T>,
      comparor?: (a: T, b: T) => boolean
    ): rxjs$OperatorFunction<T, boolean>;
  
    declare export function share<T>(): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function shareReplay<T>(
      bufferSize?: number,
      windowTime?: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function single<T>(
      predicate?: (value: T, index: number, source: rxjs$Observable<T>) => boolean
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function skip<T>(
      count: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function skipLast<T>(
      count: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function skipUntil<T>(
      notifier: rxjs$Observable<any>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function skipWhile<T>(
      predicate: (value: T, index: number) => boolean
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function startWith<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function startWith<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function startWith<T, D>(
      v1: D,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | D>;
  
    declare export function startWith<T, D, E>(
      v1: D,
      v2: E,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | D | E>;
  
    declare export function startWith<T, D, E, F>(
      v1: D,
      v2: E,
      v3: F,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | D | E | F>;
  
    declare export function startWith<T, D, E, F, G>(
      v1: D,
      v2: E,
      v3: F,
      v4: G,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | D | E | F | G>;
  
    declare export function startWith<T, D, E, F, G, H>(
      v1: D,
      v2: E,
      v3: F,
      v4: G,
      v5: H,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | D | E | F | G | H>;
  
    declare export function startWith<T, D, E, F, G, H, I>(
      v1: D,
      v2: E,
      v3: F,
      v4: G,
      v5: H,
      v6: I,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | D | E | F | G | H | I>;
  
    declare export function startWith<T, D>(
      ...array: Array<D | rxjs$SchedulerLike>
    ): rxjs$OperatorFunction<T, D>;
  
    declare export function subscribeOn<T>(
      scheduler: rxjs$SchedulerLike,
      delay?: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function switchAll<T>(): rxjs$OperatorFunction<
      rxjs$ObservableInput<T>,
      T
    >;
  
    declare export function switchMap<T, I, R>(
      project: (value: T, index: number) => rxjs$ObservableInput<I | R>,
      // @deprecated resultSelector is no longer supported, use inner map instead
      resultSelector?: (
        outerValue: T,
        innerValue: I,
        outerIndex: number,
        innerIndex: number
      ) => R
    ): rxjs$OperatorFunction<T, I | R>;
  
    declare export function switchMapTo<R>(
      observable: rxjs$ObservableInput<R>
    ): rxjs$OperatorFunction<mixed, R>;
  
    // @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map
    declare export function switchMapTo<T, R>(
      observable: rxjs$ObservableInput<R>,
      resultSelector: void
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map
    declare export function switchMapTo<T, I, R>(
      observable: rxjs$ObservableInput<I>,
      resultSelector: (
        outerValue: T,
        innerValue: I,
        outerIndex: number,
        innerIndex: number
      ) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function take<T>(
      count: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function takeLast<T>(
      count: number
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function takeUntil<T>(
      notifier: rxjs$Observable<any>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function takeWhile<T, S: T>(
      predicate: (value: T, index: number) => S,
      inclusive?: boolean
    ): rxjs$OperatorFunction<T, S>;
  
    declare export function takeWhile<T>(
      predicate: (value: T, index: number) => boolean,
      inclusive?: boolean
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function tap<T>(
      next?: (x: T) => mixed,
      error?: (e: any) => mixed,
      complete?: () => mixed
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function tap<T>(
      observer: rxjs$PartialObserver<T>
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare interface ThrottleConfig {
      leading?: boolean;
      trailing?: boolean;
    }
  
    declare export function throttle<T>(
      durationSelector: (value: T) => rxjs$SubscribableOrPromise<mixed>,
      config?: ThrottleConfig
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function throttleTime<T>(
      duration: number,
      scheduler?: rxjs$SchedulerLike,
      config?: ThrottleConfig
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export var throwIfEmpty: <T>(
      errorFactory?: () => any
    ) => rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function timeInterval<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, rxjs$TimeInterval<T>>;
  
    declare export function timeout<T>(
      due: number | Date,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$MonoTypeOperatorFunction<T>;
  
    declare export function timeoutWith<T, R>(
      due: number | Date,
      withObservable: rxjs$ObservableInput<R>,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, T | R>;
  
    declare export function timestamp<T>(
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, rxjs$Timestamp<T>>;
  
    declare export function toArray<T>(): rxjs$OperatorFunction<T, T[]>;
  
    declare export function window<T>(
      windowBoundaries: rxjs$Observable<mixed>
    ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
  
    declare export function windowCount<T>(
      windowSize: number,
      startWindowEvery?: number
    ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
  
    declare export function windowTime<T>(
      windowTimeSpan: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
  
    declare export function windowTime<T>(
      windowTimeSpan: number,
      windowCreationInterval: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
  
    declare export function windowTime<T>(
      windowTimeSpan: number,
      windowCreationInterval: number,
      maxWindowSize: number,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
  
    declare export function windowToggle<T, O>(
      openings: rxjs$Observable<O>,
      closingSelector: (openValue: O) => rxjs$Observable<mixed>
    ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
  
    declare export function windowWhen<T>(
      closingSelector: () => rxjs$Observable<mixed>
    ): rxjs$OperatorFunction<T, rxjs$Observable<T>>;
  
    declare export function withLatestFrom<T, R>(
      project: (v1: T) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, T2, R>(
      v2: rxjs$ObservableInput<T2>,
      project: (v1: T, v2: T2) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, T2, T3, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      project: (v1: T, v2: T2, v3: T3) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, T2, T3, T4, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      project: (v1: T, v2: T2, v3: T3, v4: T4) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, T2, T3, T4, T5, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, T2, T3, T4, T5, T6, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>,
      project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, T2>(
      v2: rxjs$ObservableInput<T2>
    ): rxjs$OperatorFunction<T, [T, T2]>;
  
    declare export function withLatestFrom<T, T2, T3>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>
    ): rxjs$OperatorFunction<T, [T, T2, T3]>;
  
    declare export function withLatestFrom<T, T2, T3, T4>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
  
    declare export function withLatestFrom<T, T2, T3, T4, T5>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
  
    declare export function withLatestFrom<T, T2, T3, T4, T5, T6>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
  
    declare export function withLatestFrom<T, R>(
      ...observables: Array<
        rxjs$ObservableInput<mixed> | ((...values: Array<any>) => R)
      >
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, R>(
      array: rxjs$ObservableInput<mixed>[]
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function withLatestFrom<T, R>(
      array: rxjs$ObservableInput<mixed>[],
      project: (...values: Array<any>) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated  Deprecated in favor of static zip.
    declare export function zip<T, R>(
      project: (v1: T) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, R>(
      v2: rxjs$ObservableInput<T2>,
      project: (v1: T, v2: T2) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      project: (v1: T, v2: T2, v3: T3) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3, T4, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      project: (v1: T, v2: T2, v3: T3, v4: T4) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3, T4, T5, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3, T4, T5, T6, R>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>,
      project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2>(
      v2: rxjs$ObservableInput<T2>
    ): rxjs$OperatorFunction<T, [T, T2]>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>
    ): rxjs$OperatorFunction<T, [T, T2, T3]>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3, T4>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4]>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3, T4, T5>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5]>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, T2, T3, T4, T5, T6>(
      v2: rxjs$ObservableInput<T2>,
      v3: rxjs$ObservableInput<T3>,
      v4: rxjs$ObservableInput<T4>,
      v5: rxjs$ObservableInput<T5>,
      v6: rxjs$ObservableInput<T6>
    ): rxjs$OperatorFunction<T, [T, T2, T3, T4, T5, T6]>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, R>(
      ...observables: Array<
        rxjs$ObservableInput<T> | ((...values: Array<T>) => R)
      >
    ): rxjs$OperatorFunction<T, R>;
  
    // @deprecated Deprecated in favor of static zip.
    declare export function zip<T, R>(
      array: Array<rxjs$ObservableInput<T>>
    ): rxjs$OperatorFunction<T, R>;
    // @deprecated Deprecated in favor of static zip.
  
    declare export function zip<T, TOther, R>(
      array: Array<rxjs$ObservableInput<TOther>>,
      project: (v1: T, ...values: Array<TOther>) => R
    ): rxjs$OperatorFunction<T, R>;
  
    declare export function zipAll<T>(): rxjs$OperatorFunction<
      rxjs$ObservableInput<T>,
      T[]
    >;
  
    declare export function zipAll<T>(): rxjs$OperatorFunction<mixed, T[]>;
  
    declare export function zipAll<T, R>(
      project: (...values: T[]) => R
    ): rxjs$OperatorFunction<rxjs$ObservableInput<T>, R>;
  
    declare export function zipAll<R>(
      project: (...values: Array<any>) => R
    ): rxjs$OperatorFunction<mixed, R>;
  
    declare export function iif<T, F>(
      condition: () => boolean,
      trueResult?: rxjs$SubscribableOrPromise<T>,
      falseResult?: rxjs$SubscribableOrPromise<F>
    ): rxjs$Observable<T | F>;
  
    declare export function throwError(
      error: any,
      scheduler?: rxjs$SchedulerLike
    ): rxjs$Observable<mixed>;
  }
  
  declare module "rxjs/ajax" {
    declare export interface AjaxRequest {
      url?: string;
      body?: any;
      user?: string;
      async?: boolean;
      method?: string;
      headers?: Object;
      timeout?: number;
      password?: string;
      hasContent?: boolean;
      crossDomain?: boolean;
      withCredentials?: boolean;
      createXHR?: () => XMLHttpRequest;
      progressSubscriber?: rxjs$Subscriber<mixed>;
      responseType?: string;
    }
  
    declare export class AjaxResponse {
      originalEvent: Event;
      xhr: XMLHttpRequest;
      request: AjaxRequest;
      status: number;
      response: any;
      responseText: string;
      responseType: string;
      constructor(
        originalEvent: Event,
        xhr: XMLHttpRequest,
        request: AjaxRequest
      ): void;
    }
  
    declare export interface AjaxError extends Error {
      xhr: XMLHttpRequest;
      request: AjaxRequest;
      status: number;
      responseType: string;
      response: any;
    }
  
    declare export interface AjaxTimeoutError extends AjaxError {}
  
    declare interface AjaxCreationMethod {
      (urlOrRequest: string | AjaxRequest): rxjs$Observable<AjaxResponse>;
      get(url: string, headers?: Object): rxjs$Observable<AjaxResponse>;
      post(
        url: string,
        body?: any,
        headers?: Object
      ): rxjs$Observable<AjaxResponse>;
      put(
        url: string,
        body?: any,
        headers?: Object
      ): rxjs$Observable<AjaxResponse>;
      patch(
        url: string,
        body?: any,
        headers?: Object
      ): rxjs$Observable<AjaxResponse>;
      delete(url: string, headers?: Object): rxjs$Observable<AjaxResponse>;
      getJSON<T>(url: string, headers?: Object): rxjs$Observable<T>;
    }
  
    declare export var ajax: AjaxCreationMethod;
  }
  
  declare module "rxjs/webSocket" {
    declare type WebSocketMessage = string | ArrayBuffer | Blob;
  
    declare export interface WebSocketSubjectConfig<T> {
      url: string;
      protocol?: string | Array<string>;
      // @deprecated use {@link deserializer}
      resultSelector?: (e: MessageEvent) => T;
      serializer?: (value: T) => WebSocketMessage;
      deserializer?: (e: MessageEvent) => T;
      openObserver?: rxjs$NextObserver<Event>;
      closeObserver?: rxjs$NextObserver<CloseEvent>;
      closingObserver?: rxjs$NextObserver<void>;
      WebSocketCtor?: { new(url: string, protocols?: string | string[]): WebSocket, ... };
      binaryType?: "blob" | "arraybuffer";
    }
  
    declare class AnonymousSubject<T> extends rxjs$Subject<T> {
      constructor(
        destination?: rxjs$Observer<T>,
        source?: rxjs$Observable<T>
      ): void;
      next(value: ?T): void;
      error(err: any): void;
      complete(): void;
      // @deprecated This is an internal implementation detail, do not use.
      _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
    }
  
    declare export class WebSocketSubject<T> extends AnonymousSubject<T> {
      // @deprecated This is an internal implementation detail, do not use.
      _output: rxjs$Subject<T>;
      constructor(
        urlConfigOrSource:
          | string
          | WebSocketSubjectConfig<T>
          | rxjs$Observable<T>,
        destination?: rxjs$Observer<T>
      ): void;
      lift<R>(operator: rxjs$Operator<T, R>): WebSocketSubject<R>;
      multiplex(
        subMsg: () => any,
        unsubMsg: () => any,
        messageFilter: (value: T) => boolean
      ): rxjs$Observable<mixed>;
      // @deprecated This is an internal implementation detail, do not use.
      _subscribe(subscriber: rxjs$Subscriber<T>): rxjs$Subscription;
      unsubscribe(): void;
    }
  
    declare export function webSocket<T>(
      urlConfigOrSource: string | WebSocketSubjectConfig<T>
    ): WebSocketSubject<T>;
  }
  