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

package/dist/_types/rxjs/dist/types/internal/observable/pairs.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+/**
+ * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
+ */
+export declare function pairs<T>(arr: readonly T[], scheduler?: SchedulerLike): Observable<[string, T]>;
+/**
+ * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
+ */
+export declare function pairs<O extends Record<string, unknown>>(obj: O, scheduler?: SchedulerLike): Observable<[keyof O, O[keyof O]]>;
+/**
+ * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
+ */
+export declare function pairs<T>(iterable: Iterable<T>, scheduler?: SchedulerLike): Observable<[string, T]>;
+/**
+ * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8.
+ */
+export declare function pairs(n: number | bigint | boolean | ((...args: any[]) => any) | symbol, scheduler?: SchedulerLike): Observable<[never, never]>;
+//# sourceMappingURL=pairs.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/partition.d.ts

@@ -0,0 +1,9 @@
+import { ObservableInput } from '../types';
+import { Observable } from '../Observable';
+/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
+export declare function partition<T, U extends T, A>(source: ObservableInput<T>, predicate: (this: A, value: T, index: number) => value is U, thisArg: A): [Observable<U>, Observable<Exclude<T, U>>];
+export declare function partition<T, U extends T>(source: ObservableInput<T>, predicate: (value: T, index: number) => value is U): [Observable<U>, Observable<Exclude<T, U>>];
+/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
+export declare function partition<T, A>(source: ObservableInput<T>, predicate: (this: A, value: T, index: number) => boolean, thisArg: A): [Observable<T>, Observable<T>];
+export declare function partition<T>(source: ObservableInput<T>, predicate: (value: T, index: number) => boolean): [Observable<T>, Observable<T>];
+//# sourceMappingURL=partition.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/race.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from '../Observable';
+import { ObservableInput, ObservableInputTuple } from '../types';
+import { Subscriber } from '../Subscriber';
+export declare function race<T extends readonly unknown[]>(inputs: [...ObservableInputTuple<T>]): Observable<T[number]>;
+export declare function race<T extends readonly unknown[]>(...inputs: [...ObservableInputTuple<T>]): Observable<T[number]>;
+/**
+ * An observable initializer function for both the static version and the
+ * operator version of race.
+ * @param sources The sources to race
+ */
+export declare function raceInit<T>(sources: ObservableInput<T>[]): (subscriber: Subscriber<T>) => void;
+//# sourceMappingURL=race.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/range.d.ts

@@ -0,0 +1,8 @@
+import { SchedulerLike } from '../types';
+import { Observable } from '../Observable';
+export declare function range(start: number, count?: number): Observable<number>;
+/**
+ * @deprecated The `scheduler` parameter will be removed in v8. Use `range(start, count).pipe(observeOn(scheduler))` instead. Details: Details: https://rxjs.dev/deprecations/scheduler-argument
+ */
+export declare function range(start: number, count: number | undefined, scheduler: SchedulerLike): Observable<number>;
+//# sourceMappingURL=range.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/throwError.d.ts

@@ -0,0 +1,115 @@
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+/**
+ * Creates an observable that will create an error instance and push it to the consumer as an error
+ * immediately upon subscription.
+ *
+ * <span class="informal">Just errors and does nothing else</span>
+ *
+ * ![](throw.png)
+ *
+ * This creation function is useful for creating an observable that will create an error and error every
+ * time it is subscribed to. Generally, inside of most operators when you might want to return an errored
+ * observable, this is unnecessary. In most cases, such as in the inner return of {@link concatMap},
+ * {@link mergeMap}, {@link defer}, and many others, you can simply throw the error, and RxJS will pick
+ * that up and notify the consumer of the error.
+ *
+ * ## Example
+ *
+ * Create a simple observable that will create a new error with a timestamp and log it
+ * and the message every time you subscribe to it
+ *
+ * ```ts
+ * import { throwError } from 'rxjs';
+ *
+ * let errorCount = 0;
+ *
+ * const errorWithTimestamp$ = throwError(() => {
+ *   const error: any = new Error(`This is error number ${ ++errorCount }`);
+ *   error.timestamp = Date.now();
+ *   return error;
+ * });
+ *
+ * errorWithTimestamp$.subscribe({
+ *   error: err => console.log(err.timestamp, err.message)
+ * });
+ *
+ * errorWithTimestamp$.subscribe({
+ *   error: err => console.log(err.timestamp, err.message)
+ * });
+ *
+ * // Logs the timestamp and a new error message for each subscription
+ * ```
+ *
+ * ### Unnecessary usage
+ *
+ * Using `throwError` inside of an operator or creation function
+ * with a callback, is usually not necessary
+ *
+ * ```ts
+ * import { of, concatMap, timer, throwError } from 'rxjs';
+ *
+ * const delays$ = of(1000, 2000, Infinity, 3000);
+ *
+ * delays$.pipe(
+ *   concatMap(ms => {
+ *     if (ms < 10000) {
+ *       return timer(ms);
+ *     } else {
+ *       // This is probably overkill.
+ *       return throwError(() => new Error(`Invalid time ${ ms }`));
+ *     }
+ *   })
+ * )
+ * .subscribe({
+ *   next: console.log,
+ *   error: console.error
+ * });
+ * ```
+ *
+ * You can just throw the error instead
+ *
+ * ```ts
+ * import { of, concatMap, timer } from 'rxjs';
+ *
+ * const delays$ = of(1000, 2000, Infinity, 3000);
+ *
+ * delays$.pipe(
+ *   concatMap(ms => {
+ *     if (ms < 10000) {
+ *       return timer(ms);
+ *     } else {
+ *       // Cleaner and easier to read for most folks.
+ *       throw new Error(`Invalid time ${ ms }`);
+ *     }
+ *   })
+ * )
+ * .subscribe({
+ *   next: console.log,
+ *   error: console.error
+ * });
+ * ```
+ *
+ * @param errorFactory A factory function that will create the error instance that is pushed.
+ */
+export declare function throwError(errorFactory: () => any): Observable<never>;
+/**
+ * Returns an observable that will error with the specified error immediately upon subscription.
+ *
+ * @param error The error instance to emit
+ * @deprecated Support for passing an error value will be removed in v8. Instead, pass a factory function to `throwError(() => new Error('test'))`. This is
+ * because it will create the error at the moment it should be created and capture a more appropriate stack trace. If
+ * for some reason you need to create the error ahead of time, you can still do that: `const err = new Error('test'); throwError(() => err);`.
+ */
+export declare function throwError(error: any): Observable<never>;
+/**
+ * Notifies the consumer of an error using a given scheduler by scheduling it at delay `0` upon subscription.
+ *
+ * @param errorOrErrorFactory An error instance or error factory
+ * @param scheduler A scheduler to use to schedule the error notification
+ * @deprecated The `scheduler` parameter will be removed in v8.
+ * Use `throwError` in combination with {@link observeOn}: `throwError(() => new Error('test')).pipe(observeOn(scheduler));`.
+ * Details: https://rxjs.dev/deprecations/scheduler-argument
+ */
+export declare function throwError(errorOrErrorFactory: any, scheduler: SchedulerLike): Observable<never>;
+//# sourceMappingURL=throwError.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/timer.d.ts

@@ -0,0 +1,126 @@
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+/**
+ * Creates an observable that will wait for a specified time period, or exact date, before
+ * emitting the number 0.
+ *
+ * <span class="informal">Used to emit a notification after a delay.</span>
+ *
+ * This observable is useful for creating delays in code, or racing against other values
+ * for ad-hoc timeouts.
+ *
+ * The `delay` is specified by default in milliseconds, however providing a custom scheduler could
+ * create a different behavior.
+ *
+ * ## Examples
+ *
+ * Wait 3 seconds and start another observable
+ *
+ * You might want to use `timer` to delay subscription to an
+ * observable by a set amount of time. Here we use a timer with
+ * {@link concatMapTo} or {@link concatMap} in order to wait
+ * a few seconds and start a subscription to a source.
+ *
+ * ```ts
+ * import { of, timer, concatMap } from 'rxjs';
+ *
+ * // This could be any observable
+ * const source = of(1, 2, 3);
+ *
+ * timer(3000)
+ *   .pipe(concatMap(() => source))
+ *   .subscribe(console.log);
+ * ```
+ *
+ * Take all values until the start of the next minute
+ *
+ * Using a `Date` as the trigger for the first emission, you can
+ * do things like wait until midnight to fire an event, or in this case,
+ * wait until a new minute starts (chosen so the example wouldn't take
+ * too long to run) in order to stop watching a stream. Leveraging
+ * {@link takeUntil}.
+ *
+ * ```ts
+ * import { interval, takeUntil, timer } from 'rxjs';
+ *
+ * // Build a Date object that marks the
+ * // next minute.
+ * const currentDate = new Date();
+ * const startOfNextMinute = new Date(
+ *   currentDate.getFullYear(),
+ *   currentDate.getMonth(),
+ *   currentDate.getDate(),
+ *   currentDate.getHours(),
+ *   currentDate.getMinutes() + 1
+ * );
+ *
+ * // This could be any observable stream
+ * const source = interval(1000);
+ *
+ * const result = source.pipe(
+ *   takeUntil(timer(startOfNextMinute))
+ * );
+ *
+ * result.subscribe(console.log);
+ * ```
+ *
+ * ### Known Limitations
+ *
+ * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled.
+ *
+ * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and
+ * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission
+ * should occur will be incorrect. In this case, it would be best to do your own calculations
+ * ahead of time, and pass a `number` in as the `dueTime`.
+ *
+ * @param due If a `number`, the amount of time in milliseconds to wait before emitting.
+ * If a `Date`, the exact time at which to emit.
+ * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}.
+ */
+export declare function timer(due: number | Date, scheduler?: SchedulerLike): Observable<0>;
+/**
+ * Creates an observable that starts an interval after a specified delay, emitting incrementing numbers -- starting at `0` --
+ * on each interval after words.
+ *
+ * The `delay` and `intervalDuration` are specified by default in milliseconds, however providing a custom scheduler could
+ * create a different behavior.
+ *
+ * ## Example
+ *
+ * ### Start an interval that starts right away
+ *
+ * Since {@link interval} waits for the passed delay before starting,
+ * sometimes that's not ideal. You may want to start an interval immediately.
+ * `timer` works well for this. Here we have both side-by-side so you can
+ * see them in comparison.
+ *
+ * Note that this observable will never complete.
+ *
+ * ```ts
+ * import { timer, interval } from 'rxjs';
+ *
+ * timer(0, 1000).subscribe(n => console.log('timer', n));
+ * interval(1000).subscribe(n => console.log('interval', n));
+ * ```
+ *
+ * ### Known Limitations
+ *
+ * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled.
+ *
+ * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and
+ * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission
+ * should occur will be incorrect. In this case, it would be best to do your own calculations
+ * ahead of time, and pass a `number` in as the `startDue`.
+ * @param startDue If a `number`, is the time to wait before starting the interval.
+ * If a `Date`, is the exact time at which to start the interval.
+ * @param intervalDuration The delay between each value emitted in the interval. Passing a
+ * negative number here will result in immediate completion after the first value is emitted, as though
+ * no `intervalDuration` was passed at all.
+ * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}.
+ */
+export declare function timer(startDue: number | Date, intervalDuration: number, scheduler?: SchedulerLike): Observable<number>;
+/**
+ * @deprecated The signature allowing `undefined` to be passed for `intervalDuration` will be removed in v8. Use the `timer(dueTime, scheduler?)` signature instead.
+ */
+export declare function timer(dueTime: number | Date, unused: undefined, scheduler?: SchedulerLike): Observable<0>;
+//# sourceMappingURL=timer.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/using.d.ts

@@ -0,0 +1,32 @@
+import { Observable } from '../Observable';
+import { Unsubscribable, ObservableInput, ObservedValueOf } from '../types';
+/**
+ * Creates an Observable that uses a resource which will be disposed at the same time as the Observable.
+ *
+ * <span class="informal">Use it when you catch yourself cleaning up after an Observable.</span>
+ *
+ * `using` is a factory operator, which accepts two functions. First function returns a disposable resource.
+ * It can be an arbitrary object that implements `unsubscribe` method. Second function will be injected with
+ * that object and should return an Observable. That Observable can use resource object during its execution.
+ * Both functions passed to `using` will be called every time someone subscribes - neither an Observable nor
+ * resource object will be shared in any way between subscriptions.
+ *
+ * When Observable returned by `using` is subscribed, Observable returned from the second function will be subscribed
+ * as well. All its notifications (nexted values, completion and error events) will be emitted unchanged by the output
+ * Observable. If however someone unsubscribes from the Observable or source Observable completes or errors by itself,
+ * the `unsubscribe` method on resource object will be called. This can be used to do any necessary clean up, which
+ * otherwise would have to be handled by hand. Note that complete or error notifications are not emitted when someone
+ * cancels subscription to an Observable via `unsubscribe`, so `using` can be used as a hook, allowing you to make
+ * sure that all resources which need to exist during an Observable execution will be disposed at appropriate time.
+ *
+ * @see {@link defer}
+ *
+ * @param {function(): ISubscription} resourceFactory A function which creates any resource object
+ * that implements `unsubscribe` method.
+ * @param {function(resource: ISubscription): Observable<T>} observableFactory A function which
+ * creates an Observable, that can use injected resource object.
+ * @return {Observable<T>} An Observable that behaves the same as Observable returned by `observableFactory`, but
+ * which - when completed, errored or unsubscribed - will also call `unsubscribe` on created resource object.
+ */
+export declare function using<T extends ObservableInput<any>>(resourceFactory: () => Unsubscribable | void, observableFactory: (resource: Unsubscribable | void) => T | void): Observable<ObservedValueOf<T>>;
+//# sourceMappingURL=using.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/zip.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from '../Observable';
+import { ObservableInputTuple } from '../types';
+export declare function zip<A extends readonly unknown[]>(sources: [...ObservableInputTuple<A>]): Observable<A>;
+export declare function zip<A extends readonly unknown[], R>(sources: [...ObservableInputTuple<A>], resultSelector: (...values: A) => R): Observable<R>;
+export declare function zip<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;
+export declare function zip<A extends readonly unknown[], R>(...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R]): Observable<R>;
+//# sourceMappingURL=zip.d.ts.map

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

@@ -0,0 +1,48 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Ignores source values for a duration determined by another Observable, then
+ * emits the most recent value from the source Observable, then repeats this
+ * process.
+ *
+ * <span class="informal">It's like {@link auditTime}, but the silencing
+ * duration is determined by a second Observable.</span>
+ *
+ * ![](audit.svg)
+ *
+ * `audit` is similar to `throttle`, but emits the last value from the silenced
+ * time window, instead of the first value. `audit` emits the most recent value
+ * from the source Observable on the output Observable as soon as its internal
+ * timer becomes disabled, and ignores source values while the timer is enabled.
+ * Initially, the timer is disabled. As soon as the first source value arrives,
+ * 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, then the most
+ * recent source value is emitted on the output Observable, 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, audit, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(audit(ev => interval(1000)));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link auditTime}
+ * @see {@link debounce}
+ * @see {@link delayWhen}
+ * @see {@link sample}
+ * @see {@link throttle}
+ *
+ * @param durationSelector A function
+ * that receives a value from the source Observable, for computing the silencing
+ * duration, returned as an Observable or a Promise.
+ * @return A function that returns an Observable that performs rate-limiting of
+ * emissions from the source Observable.
+ */
+export declare function audit<T>(durationSelector: (value: T) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=audit.d.ts.map

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

@@ -0,0 +1,50 @@
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+/**
+ * Ignores source values for `duration` milliseconds, then emits the most recent
+ * value from the source Observable, then repeats this process.
+ *
+ * <span class="informal">When it sees a source value, it ignores that plus
+ * the next ones for `duration` milliseconds, and then it emits the most recent
+ * value from the source.</span>
+ *
+ * ![](auditTime.png)
+ *
+ * `auditTime` is similar to `throttleTime`, but emits the last value from the
+ * silenced time window, instead of the first value. `auditTime` emits the most
+ * recent value from the source Observable on the output Observable as soon as
+ * its internal timer becomes disabled, and ignores source values while the
+ * timer is enabled. Initially, the timer is disabled. As soon as the first
+ * source value arrives, the timer is enabled. After `duration` milliseconds (or
+ * the time unit determined internally by the optional `scheduler`) has passed,
+ * the timer is disabled, then the most recent source value is emitted on the
+ * output Observable, and this process repeats for the next source value.
+ * Optionally takes a {@link SchedulerLike} for managing timers.
+ *
+ * ## Example
+ *
+ * Emit clicks at a rate of at most one click per second
+ *
+ * ```ts
+ * import { fromEvent, auditTime } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(auditTime(1000));
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link audit}
+ * @see {@link debounceTime}
+ * @see {@link delay}
+ * @see {@link sampleTime}
+ * @see {@link throttleTime}
+ *
+ * @param {number} duration Time to wait before emitting the most recent source
+ * value, measured in milliseconds or the time unit determined internally
+ * by the optional `scheduler`.
+ * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
+ * managing the timers that handle the rate-limiting behavior.
+ * @return A function that returns an Observable that performs rate-limiting of
+ * emissions from the source Observable.
+ */
+export declare function auditTime<T>(duration: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=auditTime.d.ts.map

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

@@ -0,0 +1,41 @@
+import { OperatorFunction, ObservableInput } from '../types';
+/**
+ * Buffers the source Observable values until `closingNotifier` emits.
+ *
+ * <span class="informal">Collects values from the past as an array, and emits
+ * that array only when another Observable emits.</span>
+ *
+ * ![](buffer.png)
+ *
+ * Buffers the incoming Observable values until the given `closingNotifier`
+ * `ObservableInput` (that internally gets converted to an Observable)
+ * emits a value, at which point it emits the buffer on the output
+ * Observable and starts a new buffer internally, awaiting the next time
+ * `closingNotifier` emits.
+ *
+ * ## Example
+ *
+ * On every click, emit array of most recent interval events
+ *
+ * ```ts
+ * import { fromEvent, interval, buffer } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const intervalEvents = interval(1000);
+ * const buffered = intervalEvents.pipe(buffer(clicks));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link bufferCount}
+ * @see {@link bufferTime}
+ * @see {@link bufferToggle}
+ * @see {@link bufferWhen}
+ * @see {@link window}
+ *
+ * @param closingNotifier An `ObservableInput` that signals the
+ * buffer to be emitted on the output Observable.
+ * @return A function that returns an Observable of buffers, which are arrays
+ * of values.
+ */
+export declare function buffer<T>(closingNotifier: ObservableInput<any>): OperatorFunction<T, T[]>;
+//# sourceMappingURL=buffer.d.ts.map

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

@@ -0,0 +1,54 @@
+import { OperatorFunction } from '../types';
+/**
+ * Buffers the source Observable values until the size hits the maximum
+ * `bufferSize` given.
+ *
+ * <span class="informal">Collects values from the past as an array, and emits
+ * that array only when its size reaches `bufferSize`.</span>
+ *
+ * ![](bufferCount.png)
+ *
+ * Buffers a number of values from the source Observable by `bufferSize` then
+ * emits the buffer and clears it, and starts a new buffer each
+ * `startBufferEvery` values. If `startBufferEvery` is not provided or is
+ * `null`, then new buffers are started immediately at the start of the source
+ * and when each buffer closes and is emitted.
+ *
+ * ## Examples
+ *
+ * Emit the last two click events as an array
+ *
+ * ```ts
+ * import { fromEvent, bufferCount } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferCount(2));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * On every click, emit the last two click events as an array
+ *
+ * ```ts
+ * import { fromEvent, bufferCount } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferCount(2, 1));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link buffer}
+ * @see {@link bufferTime}
+ * @see {@link bufferToggle}
+ * @see {@link bufferWhen}
+ * @see {@link pairwise}
+ * @see {@link windowCount}
+ *
+ * @param {number} bufferSize The maximum size of the buffer emitted.
+ * @param {number} [startBufferEvery] Interval at which to start a new buffer.
+ * For example if `startBufferEvery` is `2`, then a new buffer will be started
+ * on every other value from the source. A new buffer is started at the
+ * beginning of the source by default.
+ * @return A function that returns an Observable of arrays of buffered values.
+ */
+export declare function bufferCount<T>(bufferSize: number, startBufferEvery?: number | null): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferCount.d.ts.map

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

@@ -0,0 +1,5 @@
+import { OperatorFunction, SchedulerLike } from '../types';
+export declare function bufferTime<T>(bufferTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
+export declare function bufferTime<T>(bufferTimeSpan: number, bufferCreationInterval: number | null | undefined, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
+export declare function bufferTime<T>(bufferTimeSpan: number, bufferCreationInterval: number | null | undefined, maxBufferSize: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferTime.d.ts.map

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

@@ -0,0 +1,46 @@
+import { OperatorFunction, ObservableInput } from '../types';
+/**
+ * Buffers the source Observable values starting from an emission from
+ * `openings` and ending when the output of `closingSelector` emits.
+ *
+ * <span class="informal">Collects values from the past as an array. Starts
+ * collecting only when `opening` emits, and calls the `closingSelector`
+ * function to get an Observable that tells when to close the buffer.</span>
+ *
+ * ![](bufferToggle.png)
+ *
+ * Buffers values from the source by opening the buffer via signals from an
+ * Observable provided to `openings`, and closing and sending the buffers when
+ * a Subscribable or Promise returned by the `closingSelector` function emits.
+ *
+ * ## Example
+ *
+ * Every other second, emit the click events from the next 500ms
+ *
+ * ```ts
+ * import { fromEvent, interval, bufferToggle, EMPTY } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const openings = interval(1000);
+ * const buffered = clicks.pipe(bufferToggle(openings, i =>
+ *   i % 2 ? interval(500) : EMPTY
+ * ));
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link buffer}
+ * @see {@link bufferCount}
+ * @see {@link bufferTime}
+ * @see {@link bufferWhen}
+ * @see {@link windowToggle}
+ *
+ * @param openings A Subscribable or Promise of notifications to start new
+ * buffers.
+ * @param closingSelector A function that takes
+ * the value emitted by the `openings` observable and returns a Subscribable or Promise,
+ * which, when it emits, signals that the associated buffer should be emitted
+ * and cleared.
+ * @return A function that returns an Observable of arrays of buffered values.
+ */
+export declare function bufferToggle<T, O>(openings: ObservableInput<O>, closingSelector: (value: O) => ObservableInput<any>): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferToggle.d.ts.map

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

@@ -0,0 +1,41 @@
+import { ObservableInput, OperatorFunction } from '../types';
+/**
+ * Buffers the source Observable values, using a factory function of closing
+ * Observables to determine when to close, emit, and reset the buffer.
+ *
+ * <span class="informal">Collects values from the past as an array. When it
+ * starts collecting values, it calls a function that returns an Observable that
+ * tells when to close the buffer and restart collecting.</span>
+ *
+ * ![](bufferWhen.svg)
+ *
+ * Opens a buffer immediately, then closes the buffer when the observable
+ * returned by calling `closingSelector` function emits a value. When it closes
+ * the buffer, it immediately opens a new buffer and repeats the process.
+ *
+ * ## Example
+ *
+ * Emit an array of the last clicks every [1-5] random seconds
+ *
+ * ```ts
+ * import { fromEvent, bufferWhen, interval } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(
+ *   bufferWhen(() => interval(1000 + Math.random() * 4000))
+ * );
+ * buffered.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link buffer}
+ * @see {@link bufferCount}
+ * @see {@link bufferTime}
+ * @see {@link bufferToggle}
+ * @see {@link windowWhen}
+ *
+ * @param {function(): Observable} closingSelector A function that takes no
+ * arguments and returns an Observable that signals buffer closure.
+ * @return A function that returns an Observable of arrays of buffered values.
+ */
+export declare function bufferWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, T[]>;
+//# sourceMappingURL=bufferWhen.d.ts.map

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

@@ -0,0 +1,4 @@
+import { Observable } from '../Observable';
+import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
+export declare function catchError<T, O extends ObservableInput<any>>(selector: (err: any, caught: Observable<T>) => O): OperatorFunction<T, T | ObservedValueOf<O>>;
+//# sourceMappingURL=catchError.d.ts.map

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

@@ -0,0 +1,6 @@
+import { combineLatestAll } from './combineLatestAll';
+/**
+ * @deprecated Renamed to {@link combineLatestAll}. Will be removed in v8.
+ */
+export declare const combineAll: typeof combineLatestAll;
+//# sourceMappingURL=combineAll.d.ts.map

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

@@ -0,0 +1,6 @@
+import { OperatorFunction, ObservableInput } from '../types';
+export declare function combineLatestAll<T>(): OperatorFunction<ObservableInput<T>, T[]>;
+export declare function combineLatestAll<T>(): OperatorFunction<any, T[]>;
+export declare function combineLatestAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>;
+export declare function combineLatestAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>;
+//# sourceMappingURL=combineLatestAll.d.ts.map