@mastra/nestjs 0.1.8-alpha.0 → 0.1.8-alpha.2

package/dist/_types/rxjs/dist/types/internal/operators/startWith.d.ts

@@ -0,0 +1,7 @@
+import { OperatorFunction, SchedulerLike, ValueFromArray } from '../types';
+export declare function startWith<T>(value: null): OperatorFunction<T, T | null>;
+export declare function startWith<T>(value: undefined): OperatorFunction<T, T | undefined>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function startWith<T, A extends readonly unknown[] = T[]>(...valuesAndScheduler: [...A, SchedulerLike]): OperatorFunction<T, T | ValueFromArray<A>>;
+export declare function startWith<T, A extends readonly unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>;
+//# sourceMappingURL=startWith.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/subscribeOn.d.ts

@@ -0,0 +1,62 @@
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+/**
+ * Asynchronously subscribes Observers to this Observable on the specified {@link SchedulerLike}.
+ *
+ * With `subscribeOn` you can decide what type of scheduler a specific Observable will be using when it is subscribed to.
+ *
+ * Schedulers control the speed and order of emissions to observers from an Observable stream.
+ *
+ * ![](subscribeOn.png)
+ *
+ * ## Example
+ *
+ * Given the following code:
+ *
+ * ```ts
+ * import { of, merge } from 'rxjs';
+ *
+ * const a = of(1, 2, 3);
+ * const b = of(4, 5, 6);
+ *
+ * merge(a, b).subscribe(console.log);
+ *
+ * // Outputs
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * // 6
+ * ```
+ *
+ * Both Observable `a` and `b` will emit their values directly and synchronously once they are subscribed to.
+ *
+ * If we instead use the `subscribeOn` operator declaring that we want to use the {@link asyncScheduler} for values emitted by Observable `a`:
+ *
+ * ```ts
+ * import { of, subscribeOn, asyncScheduler, merge } from 'rxjs';
+ *
+ * const a = of(1, 2, 3).pipe(subscribeOn(asyncScheduler));
+ * const b = of(4, 5, 6);
+ *
+ * merge(a, b).subscribe(console.log);
+ *
+ * // Outputs
+ * // 4
+ * // 5
+ * // 6
+ * // 1
+ * // 2
+ * // 3
+ * ```
+ *
+ * The reason for this is that Observable `b` emits its values directly and synchronously like before
+ * but the emissions from `a` are scheduled on the event loop because we are now using the {@link asyncScheduler} for that specific Observable.
+ *
+ * @param scheduler The {@link SchedulerLike} to perform subscription actions on.
+ * @param delay A delay to pass to the scheduler to delay subscriptions
+ * @return A function that returns an Observable modified so that its
+ * subscriptions happen on the specified {@link SchedulerLike}.
+ */
+export declare function subscribeOn<T>(scheduler: SchedulerLike, delay?: number): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=subscribeOn.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/switchAll.d.ts

@@ -0,0 +1,61 @@
+import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
+/**
+ * Converts a higher-order Observable into a first-order Observable
+ * producing values only from the most recent observable sequence
+ *
+ * <span class="informal">Flattens an Observable-of-Observables.</span>
+ *
+ * ![](switchAll.png)
+ *
+ * `switchAll` subscribes to a source that is an observable of observables, also known as a
+ * "higher-order observable" (or `Observable<Observable<T>>`). It subscribes to the most recently
+ * provided "inner observable" emitted by the source, unsubscribing from any previously subscribed
+ * to inner observable, such that only the most recent inner observable may be subscribed to at
+ * any point in time. The resulting observable returned by `switchAll` will only complete if the
+ * source observable completes, *and* any currently subscribed to inner observable also has completed,
+ * if there are any.
+ *
+ * ## Examples
+ *
+ * Spawn a new interval observable for each click event, but for every new
+ * click, cancel the previous interval and subscribe to the new one
+ *
+ * ```ts
+ * import { fromEvent, tap, map, interval, switchAll } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click').pipe(tap(() => console.log('click')));
+ * const source = clicks.pipe(map(() => interval(1000)));
+ *
+ * source
+ *   .pipe(switchAll())
+ *   .subscribe(x => console.log(x));
+ *
+ * // Output
+ * // click
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // ...
+ * // click
+ * // 0
+ * // 1
+ * // 2
+ * // ...
+ * // click
+ * // ...
+ * ```
+ *
+ * @see {@link combineLatestAll}
+ * @see {@link concatAll}
+ * @see {@link exhaustAll}
+ * @see {@link switchMap}
+ * @see {@link switchMapTo}
+ * @see {@link mergeAll}
+ *
+ * @return A function that returns an Observable that converts a higher-order
+ * Observable into a first-order Observable producing values only from the most
+ * recent Observable sequence.
+ */
+export declare function switchAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>>;
+//# sourceMappingURL=switchAll.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/switchMap.d.ts

@@ -0,0 +1,7 @@
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+export declare function switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): OperatorFunction<T, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export declare function switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): OperatorFunction<T, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export declare function switchMap<T, R, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
+//# sourceMappingURL=switchMap.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/switchMapTo.d.ts

@@ -0,0 +1,8 @@
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+/** @deprecated Will be removed in v9. Use {@link switchMap} instead: `switchMap(() => result)` */
+export declare function switchMapTo<O extends ObservableInput<unknown>>(observable: O): OperatorFunction<unknown, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export declare function switchMapTo<O extends ObservableInput<unknown>>(observable: O, resultSelector: undefined): OperatorFunction<unknown, ObservedValueOf<O>>;
+/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
+export declare function switchMapTo<T, R, O extends ObservableInput<unknown>>(observable: O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
+//# sourceMappingURL=switchMapTo.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/switchScan.d.ts

@@ -0,0 +1,20 @@
+import { ObservableInput, ObservedValueOf, OperatorFunction } from '../types';
+/**
+ * Applies an accumulator function over the source Observable where the
+ * accumulator function itself returns an Observable, emitting values
+ * only from the most recently returned Observable.
+ *
+ * <span class="informal">It's like {@link mergeScan}, but only the most recent
+ * Observable returned by the accumulator is merged into the outer Observable.</span>
+ *
+ * @see {@link scan}
+ * @see {@link mergeScan}
+ * @see {@link switchMap}
+ *
+ * @param accumulator
+ * The accumulator function called on each source value.
+ * @param seed The initial accumulation value.
+ * @return A function that returns an observable of the accumulated values.
+ */
+export declare function switchScan<T, R, O extends ObservableInput<any>>(accumulator: (acc: R, value: T, index: number) => O, seed: R): OperatorFunction<T, ObservedValueOf<O>>;
+//# sourceMappingURL=switchScan.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/take.d.ts

@@ -0,0 +1,45 @@
+import { MonoTypeOperatorFunction } from '../types';
+/**
+ * Emits only the first `count` values emitted by the source Observable.
+ *
+ * <span class="informal">Takes the first `count` values from the source, then
+ * completes.</span>
+ *
+ * ![](take.png)
+ *
+ * `take` returns an Observable that emits only the first `count` values emitted
+ * by the source Observable. If the source emits fewer than `count` values then
+ * all of its values are emitted. After that, it completes, regardless if the
+ * source completes.
+ *
+ * ## Example
+ *
+ * Take the first 5 seconds of an infinite 1-second interval Observable
+ *
+ * ```ts
+ * import { interval, take } from 'rxjs';
+ *
+ * const intervalCount = interval(1000);
+ * const takeFive = intervalCount.pipe(take(5));
+ * takeFive.subscribe(x => console.log(x));
+ *
+ * // Logs:
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * ```
+ *
+ * @see {@link takeLast}
+ * @see {@link takeUntil}
+ * @see {@link takeWhile}
+ * @see {@link skip}
+ *
+ * @param count The maximum number of `next` values to emit.
+ * @return A function that returns an Observable that emits only the first
+ * `count` values emitted by the source Observable, or all of the values from
+ * the source if the source emits fewer than `count` values.
+ */
+export declare function take<T>(count: number): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=take.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/takeLast.d.ts

@@ -0,0 +1,42 @@
+import { MonoTypeOperatorFunction } from '../types';
+/**
+ * Waits for the source to complete, then emits the last N values from the source,
+ * as specified by the `count` argument.
+ *
+ * ![](takeLast.png)
+ *
+ * `takeLast` results in an observable that will hold values up to `count` values in memory,
+ * until the source completes. It then pushes all values in memory to the consumer, in the
+ * order they were received from the source, then notifies the consumer that it is
+ * complete.
+ *
+ * If for some reason the source completes before the `count` supplied to `takeLast` is reached,
+ * all values received until that point are emitted, and then completion is notified.
+ *
+ * **Warning**: Using `takeLast` with an observable that never completes will result
+ * in an observable that never emits a value.
+ *
+ * ## Example
+ *
+ * Take the last 3 values of an Observable with many values
+ *
+ * ```ts
+ * import { range, takeLast } from 'rxjs';
+ *
+ * const many = range(1, 100);
+ * const lastThree = many.pipe(takeLast(3));
+ * lastThree.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link take}
+ * @see {@link takeUntil}
+ * @see {@link takeWhile}
+ * @see {@link skip}
+ *
+ * @param count The maximum number of values to emit from the end of
+ * the sequence of values emitted by the source Observable.
+ * @return A function that returns an Observable that emits at most the last
+ * `count` values emitted by the source Observable.
+ */
+export declare function takeLast<T>(count: number): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=takeLast.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/takeUntil.d.ts

@@ -0,0 +1,42 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Emits the values emitted by the source Observable until a `notifier`
+ * Observable emits a value.
+ *
+ * <span class="informal">Lets values pass until a second Observable,
+ * `notifier`, emits a value. Then, it completes.</span>
+ *
+ * ![](takeUntil.png)
+ *
+ * `takeUntil` subscribes and begins mirroring the source Observable. It also
+ * monitors a second Observable, `notifier` that you provide. If the `notifier`
+ * emits a value, the output Observable stops mirroring the source Observable
+ * and completes. If the `notifier` doesn't emit any value and completes
+ * then `takeUntil` will pass all values.
+ *
+ * ## Example
+ *
+ * Tick every second until the first click happens
+ *
+ * ```ts
+ * import { interval, fromEvent, takeUntil } from 'rxjs';
+ *
+ * const source = interval(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const result = source.pipe(takeUntil(clicks));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link take}
+ * @see {@link takeLast}
+ * @see {@link takeWhile}
+ * @see {@link skip}
+ *
+ * @param {Observable} notifier The Observable whose first emitted value will
+ * cause the output Observable of `takeUntil` to stop emitting values from the
+ * source Observable.
+ * @return A function that returns an Observable that emits the values from the
+ * source Observable until `notifier` emits its first value.
+ */
+export declare function takeUntil<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=takeUntil.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/takeWhile.d.ts

@@ -0,0 +1,8 @@
+import { OperatorFunction, MonoTypeOperatorFunction, TruthyTypesOf } from '../types';
+export declare function takeWhile<T>(predicate: BooleanConstructor, inclusive: true): MonoTypeOperatorFunction<T>;
+export declare function takeWhile<T>(predicate: BooleanConstructor, inclusive: false): OperatorFunction<T, TruthyTypesOf<T>>;
+export declare function takeWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
+export declare function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>;
+export declare function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S, inclusive: false): OperatorFunction<T, S>;
+export declare function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive?: boolean): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=takeWhile.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/tap.d.ts

@@ -0,0 +1,72 @@
+import { MonoTypeOperatorFunction, Observer } from '../types';
+/**
+ * An extension to the {@link Observer} interface used only by the {@link tap} operator.
+ *
+ * It provides a useful set of callbacks a user can register to do side-effects in
+ * cases other than what the usual {@link Observer} callbacks are
+ * ({@link guide/glossary-and-semantics#next next},
+ * {@link guide/glossary-and-semantics#error error} and/or
+ * {@link guide/glossary-and-semantics#complete complete}).
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { fromEvent, switchMap, tap, interval, take } from 'rxjs';
+ *
+ * const source$ = fromEvent(document, 'click');
+ * const result$ = source$.pipe(
+ *   switchMap((_, i) => i % 2 === 0
+ *     ? fromEvent(document, 'mousemove').pipe(
+ *         tap({
+ *           subscribe: () => console.log('Subscribed to the mouse move events after click #' + i),
+ *           unsubscribe: () => console.log('Mouse move events #' + i + ' unsubscribed'),
+ *           finalize: () => console.log('Mouse move events #' + i + ' finalized')
+ *         })
+ *       )
+ *     : interval(1_000).pipe(
+ *         take(5),
+ *         tap({
+ *           subscribe: () => console.log('Subscribed to the 1-second interval events after click #' + i),
+ *           unsubscribe: () => console.log('1-second interval events #' + i + ' unsubscribed'),
+ *           finalize: () => console.log('1-second interval events #' + i + ' finalized')
+ *         })
+ *       )
+ *   )
+ * );
+ *
+ * const subscription = result$.subscribe({
+ *   next: console.log
+ * });
+ *
+ * setTimeout(() => {
+ *   console.log('Unsubscribe after 60 seconds');
+ *   subscription.unsubscribe();
+ * }, 60_000);
+ * ```
+ */
+export interface TapObserver<T> extends Observer<T> {
+    /**
+     * The callback that `tap` operator invokes at the moment when the source Observable
+     * gets subscribed to.
+     */
+    subscribe: () => void;
+    /**
+     * The callback that `tap` operator invokes when an explicit
+     * {@link guide/glossary-and-semantics#unsubscription unsubscribe} happens. It won't get invoked on
+     * `error` or `complete` events.
+     */
+    unsubscribe: () => void;
+    /**
+     * The callback that `tap` operator invokes when any kind of
+     * {@link guide/glossary-and-semantics#finalization finalization} happens - either when
+     * the source Observable `error`s or `complete`s or when it gets explicitly unsubscribed
+     * by the user. There is no difference in using this callback or the {@link finalize}
+     * operator, but if you're already using `tap` operator, you can use this callback
+     * instead. You'd get the same result in either case.
+     */
+    finalize: () => void;
+}
+export declare function tap<T>(observerOrNext?: Partial<TapObserver<T>> | ((value: T) => void)): MonoTypeOperatorFunction<T>;
+/** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
+export declare function tap<T>(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=tap.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/throttle.d.ts

@@ -0,0 +1,78 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * An object interface used by {@link throttle} or {@link throttleTime} that ensure
+ * configuration options of these operators.
+ *
+ * @see {@link throttle}
+ * @see {@link throttleTime}
+ */
+export interface ThrottleConfig {
+    /**
+     * If `true`, the resulting Observable will emit the first value from the source
+     * Observable at the **start** of the "throttling" process (when starting an
+     * internal timer that prevents other emissions from the source to pass through).
+     * If `false`, it will not emit the first value from the source Observable at the
+     * start of the "throttling" process.
+     *
+     * If not provided, defaults to: `true`.
+     */
+    leading?: boolean;
+    /**
+     * If `true`, the resulting Observable will emit the last value from the source
+     * Observable at the **end** of the "throttling" process (when ending an internal
+     * timer that prevents other emissions from the source to pass through).
+     * If `false`, it will not emit the last value from the source Observable at the
+     * end of the "throttling" process.
+     *
+     * If not provided, defaults to: `false`.
+     */
+    trailing?: boolean;
+}
+/**
+ * Emits a value from the source Observable, then ignores subsequent source
+ * values for a duration determined by another Observable, then repeats this
+ * process.
+ *
+ * <span class="informal">It's like {@link throttleTime}, but the silencing
+ * duration is determined by a second Observable.</span>
+ *
+ * ![](throttle.svg)
+ *
+ * `throttle` emits the source Observable values on the output Observable
+ * when its internal timer is disabled, and ignores source values when the timer
+ * is enabled. Initially, the timer is disabled. As soon as the first source
+ * value arrives, it is forwarded to the output Observable, and then the timer
+ * is enabled by calling the `durationSelector` function with the source value,
+ * which returns the "duration" Observable. When the duration Observable emits a
+ * value, the timer is disabled, and this process repeats for the
+ * next source value.
+ *
+ * ## Example
+ *
+ * Emit clicks at a rate of at most one click per second
+ *
+ * ```ts
+ * import { fromEvent, throttle, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(throttle(() => interval(1000)));
+ *
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link audit}
+ * @see {@link debounce}
+ * @see {@link delayWhen}
+ * @see {@link sample}
+ * @see {@link throttleTime}
+ *
+ * @param durationSelector A function that receives a value from the source
+ * Observable, for computing the silencing duration for each source value,
+ * returned as an `ObservableInput`.
+ * @param config A configuration object to define `leading` and `trailing`
+ * behavior. Defaults to `{ leading: true, trailing: false }`.
+ * @return A function that returns an Observable that performs the throttle
+ * operation to limit the rate of emissions from the source.
+ */
+export declare function throttle<T>(durationSelector: (value: T) => ObservableInput<any>, config?: ThrottleConfig): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=throttle.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/throttleTime.d.ts

@@ -0,0 +1,53 @@
+import { ThrottleConfig } from './throttle';
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+/**
+ * Emits a value from the source Observable, then ignores subsequent source
+ * values for `duration` milliseconds, then repeats this process.
+ *
+ * <span class="informal">Lets a value pass, then ignores source values for the
+ * next `duration` milliseconds.</span>
+ *
+ * ![](throttleTime.png)
+ *
+ * `throttleTime` emits the source Observable values on the output Observable
+ * when its internal timer is disabled, and ignores source values when the timer
+ * is enabled. Initially, the timer is disabled. As soon as the first source
+ * value arrives, it is forwarded to the output Observable, and then the timer
+ * is enabled. After `duration` milliseconds (or the time unit determined
+ * internally by the optional `scheduler`) has passed, the timer is disabled,
+ * and this process repeats for the next source value. Optionally takes a
+ * {@link SchedulerLike} for managing timers.
+ *
+ * ## Examples
+ *
+ * ### Limit click rate
+ *
+ * Emit clicks at a rate of at most one click per second
+ *
+ * ```ts
+ * import { fromEvent, throttleTime } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(throttleTime(1000));
+ *
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link auditTime}
+ * @see {@link debounceTime}
+ * @see {@link delay}
+ * @see {@link sampleTime}
+ * @see {@link throttle}
+ *
+ * @param duration Time to wait before emitting another value after
+ * emitting the last value, measured in milliseconds or the time unit determined
+ * internally by the optional `scheduler`.
+ * @param scheduler The {@link SchedulerLike} to use for
+ * managing the timers that handle the throttling. Defaults to {@link asyncScheduler}.
+ * @param config A configuration object to define `leading` and
+ * `trailing` behavior. Defaults to `{ leading: true, trailing: false }`.
+ * @return A function that returns an Observable that performs the throttle
+ * operation to limit the rate of emissions from the source.
+ */
+export declare function throttleTime<T>(duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=throttleTime.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/throwIfEmpty.d.ts

@@ -0,0 +1,39 @@
+import { MonoTypeOperatorFunction } from '../types';
+/**
+ * If the source observable completes without emitting a value, it will emit
+ * an error. The error will be created at that time by the optional
+ * `errorFactory` argument, otherwise, the error will be {@link EmptyError}.
+ *
+ * ![](throwIfEmpty.png)
+ *
+ * ## Example
+ *
+ * Throw an error if the document wasn't clicked within 1 second
+ *
+ * ```ts
+ * import { fromEvent, takeUntil, timer, throwIfEmpty } from 'rxjs';
+ *
+ * const click$ = fromEvent(document, 'click');
+ *
+ * click$.pipe(
+ *   takeUntil(timer(1000)),
+ *   throwIfEmpty(() => new Error('The document was not clicked within 1 second'))
+ * )
+ * .subscribe({
+ *   next() {
+ *    console.log('The document was clicked');
+ *   },
+ *   error(err) {
+ *     console.error(err.message);
+ *   }
+ * });
+ * ```
+ *
+ * @param errorFactory A factory function called to produce the
+ * error to be thrown when the source observable completes without emitting a
+ * value.
+ * @return A function that returns an Observable that throws an error if the
+ * source Observable completed without emitting.
+ */
+export declare function throwIfEmpty<T>(errorFactory?: () => any): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=throwIfEmpty.d.ts.map

package/dist/_types/rxjs/dist/types/internal/operators/timeInterval.d.ts

@@ -0,0 +1,50 @@
+import { SchedulerLike, OperatorFunction } from '../types';
+/**
+ * Emits an object containing the current value, and the time that has
+ * passed between emitting the current value and the previous value, which is
+ * calculated by using the provided `scheduler`'s `now()` method to retrieve
+ * the current time at each emission, then calculating the difference. The `scheduler`
+ * defaults to {@link asyncScheduler}, so by default, the `interval` will be in
+ * milliseconds.
+ *
+ * <span class="informal">Convert an Observable that emits items into one that
+ * emits indications of the amount of time elapsed between those emissions.</span>
+ *
+ * ![](timeInterval.png)
+ *
+ * ## Example
+ *
+ * Emit interval between current value with the last value
+ *
+ * ```ts
+ * import { interval, timeInterval } from 'rxjs';
+ *
+ * const seconds = interval(1000);
+ *
+ * seconds
+ *   .pipe(timeInterval())
+ *   .subscribe(value => console.log(value));
+ *
+ * // NOTE: The values will never be this precise,
+ * // intervals created with `interval` or `setInterval`
+ * // are non-deterministic.
+ *
+ * // { value: 0, interval: 1000 }
+ * // { value: 1, interval: 1000 }
+ * // { value: 2, interval: 1000 }
+ * ```
+ *
+ * @param {SchedulerLike} [scheduler] Scheduler used to get the current time.
+ * @return A function that returns an Observable that emits information about
+ * value and interval.
+ */
+export declare function timeInterval<T>(scheduler?: SchedulerLike): OperatorFunction<T, TimeInterval<T>>;
+export declare class TimeInterval<T> {
+    value: T;
+    interval: number;
+    /**
+     * @deprecated Internal implementation detail, do not construct directly. Will be made an interface in v8.
+     */
+    constructor(value: T, interval: number);
+}
+//# sourceMappingURL=timeInterval.d.ts.map