message: docs(timeoutWith): create documentation for the operator
  Create documentation for timeoutWith operator, comparing it
  to timeout operator, describing what fallback Observable is
  needed for, showing example of usage and providing descriptions
  for all parameters of the operator.
diff: @@ -15,10 +15,49 @@ export function timeoutWith<T, R>(this: Observable<T>, due: number | Date, withO
  /* tslint:enable:max-line-length */
  /**
  - * @param due
  - * @param withObservable
  - * @param scheduler
  - * @return {Observable<R>|WebSocketSubject<T>|Observable<T>}
  + *
  + * Errors if Observable does not emit a value in given time span, in case of which
  + * subscribes to the second Observable.
  + *
  + * <span class="informal">It's a version of `timeout` operator that let's you specify fallback Observable.</span>
  + *
  + * <img src="./img/timeoutWith.png" width="100%">
  + *
  + * `timeoutWith` is a variation of `timeout` operator. It behaves exactly the same,
  + * still accepting as a first argument either a number or a Date, which control - respectively -
  + * when values of source Observable should be emitted or when it should complete.
  + *
  + * The only difference is that it accepts a second, required parameter. This parameter
  + * should be an Observable which will be subscribed when source Observable fails any timeout check.
  + * So whenever regular `timeout` would emit an error, `timeoutWith` will instead start re-emitting
  + * values from second Observable. Note that this fallback Observable is not checked for timeouts
  + * itself, so it can emit values and complete at arbitrary points in time. From the moment of a second
  + * subscription, Observable returned from `timeoutWith` simply mirrors fallback stream. When that
  + * stream completes, it completes as well.
  + *
  + * Scheduler, which in case of `timeout` is provided as as second argument, can be still provided
  + * here - as a third, optional parameter. It still is used to schedule timeout checks and -
  + * as a consequence - when second Observable will be subscribed, since subscription happens
  + * immediately after failing check.
  + *
  + * @example <caption>Add fallback observable</caption>
  + * const seconds = Rx.Observable.interval(1000);
  + * const minutes = Rx.Observable.interval(60 * 1000);
  + *
  + * seconds.timeoutWith(900, minutes)
  + * .subscribe(
  + * value => console.log(value), // After 900ms, will start emitting `minutes`,
  + * // since first value of `seconds` will not arrive fast enough.
  + * err => console.log(err) // Would be called after 900ms in case of `timeout`,
  + * // but here will never be called.
  + * );
  + *
  + * @param {number|Date} due Number specifying period within which Observable must emit values
  + * or Date specifying before when Observable should complete
  + * @param {Observable<T>} withObservable Observable which will be subscribed if source fails timeout check.
  + * @param {Scheduler} [scheduler] Scheduler controlling when timeout checks occur.
  + * @return {Observable<T>} Observable that mirrors behaviour of source or, when timeout check fails, of an Observable
  + * passed as a second parameter.
  * @method timeoutWith
  * @owner Observable
  */
  