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

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @mastra/nestjs
 
+## 0.1.8-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [[`df1947a`](https://github.com/mastra-ai/mastra/commit/df1947affa40f742067542251fac7ca759492ef4), [`ee59b74`](https://github.com/mastra-ai/mastra/commit/ee59b743ce73ad11784b4d9c6fbba8568edee1c8), [`a97b1a0`](https://github.com/mastra-ai/mastra/commit/a97b1a0abaed83946c3519d1e0f680d0815b8a67)]:
+  - @mastra/core@1.37.0-alpha.2
+  - @mastra/server@1.37.0-alpha.2
+
 ## 0.1.8-alpha.1
 
 ### Patch Changes

package/dist/_types/rxjs/dist/types/index.d.ts

@@ -0,0 +1,173 @@
+/// <reference path="operators/index.d.ts" />
+/// <reference path="testing/index.d.ts" />
+export { Observable } from './internal/Observable';
+export { ConnectableObservable } from './internal/observable/ConnectableObservable';
+export { GroupedObservable } from './internal/operators/groupBy';
+export { Operator } from './internal/Operator';
+export { observable } from './internal/symbol/observable';
+export { animationFrames } from './internal/observable/dom/animationFrames';
+export { Subject } from './internal/Subject';
+export { BehaviorSubject } from './internal/BehaviorSubject';
+export { ReplaySubject } from './internal/ReplaySubject';
+export { AsyncSubject } from './internal/AsyncSubject';
+export { asap, asapScheduler } from './internal/scheduler/asap';
+export { async, asyncScheduler } from './internal/scheduler/async';
+export { queue, queueScheduler } from './internal/scheduler/queue';
+export { animationFrame, animationFrameScheduler } from './internal/scheduler/animationFrame';
+export { VirtualTimeScheduler, VirtualAction } from './internal/scheduler/VirtualTimeScheduler';
+export { Scheduler } from './internal/Scheduler';
+export { Subscription } from './internal/Subscription';
+export { Subscriber } from './internal/Subscriber';
+export { Notification, NotificationKind } from './internal/Notification';
+export { pipe } from './internal/util/pipe';
+export { noop } from './internal/util/noop';
+export { identity } from './internal/util/identity';
+export { isObservable } from './internal/util/isObservable';
+export { lastValueFrom } from './internal/lastValueFrom';
+export { firstValueFrom } from './internal/firstValueFrom';
+export { ArgumentOutOfRangeError } from './internal/util/ArgumentOutOfRangeError';
+export { EmptyError } from './internal/util/EmptyError';
+export { NotFoundError } from './internal/util/NotFoundError';
+export { ObjectUnsubscribedError } from './internal/util/ObjectUnsubscribedError';
+export { SequenceError } from './internal/util/SequenceError';
+export { TimeoutError } from './internal/operators/timeout';
+export { UnsubscriptionError } from './internal/util/UnsubscriptionError';
+export { bindCallback } from './internal/observable/bindCallback';
+export { bindNodeCallback } from './internal/observable/bindNodeCallback';
+export { combineLatest } from './internal/observable/combineLatest';
+export { concat } from './internal/observable/concat';
+export { connectable } from './internal/observable/connectable';
+export { defer } from './internal/observable/defer';
+export { empty } from './internal/observable/empty';
+export { forkJoin } from './internal/observable/forkJoin';
+export { from } from './internal/observable/from';
+export { fromEvent } from './internal/observable/fromEvent';
+export { fromEventPattern } from './internal/observable/fromEventPattern';
+export { generate } from './internal/observable/generate';
+export { iif } from './internal/observable/iif';
+export { interval } from './internal/observable/interval';
+export { merge } from './internal/observable/merge';
+export { never } from './internal/observable/never';
+export { of } from './internal/observable/of';
+export { onErrorResumeNext } from './internal/observable/onErrorResumeNext';
+export { pairs } from './internal/observable/pairs';
+export { partition } from './internal/observable/partition';
+export { race } from './internal/observable/race';
+export { range } from './internal/observable/range';
+export { throwError } from './internal/observable/throwError';
+export { timer } from './internal/observable/timer';
+export { using } from './internal/observable/using';
+export { zip } from './internal/observable/zip';
+export { scheduled } from './internal/scheduled/scheduled';
+export { EMPTY } from './internal/observable/empty';
+export { NEVER } from './internal/observable/never';
+export * from './internal/types';
+export { config, GlobalConfig } from './internal/config';
+export { audit } from './internal/operators/audit';
+export { auditTime } from './internal/operators/auditTime';
+export { buffer } from './internal/operators/buffer';
+export { bufferCount } from './internal/operators/bufferCount';
+export { bufferTime } from './internal/operators/bufferTime';
+export { bufferToggle } from './internal/operators/bufferToggle';
+export { bufferWhen } from './internal/operators/bufferWhen';
+export { catchError } from './internal/operators/catchError';
+export { combineAll } from './internal/operators/combineAll';
+export { combineLatestAll } from './internal/operators/combineLatestAll';
+export { combineLatestWith } from './internal/operators/combineLatestWith';
+export { concatAll } from './internal/operators/concatAll';
+export { concatMap } from './internal/operators/concatMap';
+export { concatMapTo } from './internal/operators/concatMapTo';
+export { concatWith } from './internal/operators/concatWith';
+export { connect, ConnectConfig } from './internal/operators/connect';
+export { count } from './internal/operators/count';
+export { debounce } from './internal/operators/debounce';
+export { debounceTime } from './internal/operators/debounceTime';
+export { defaultIfEmpty } from './internal/operators/defaultIfEmpty';
+export { delay } from './internal/operators/delay';
+export { delayWhen } from './internal/operators/delayWhen';
+export { dematerialize } from './internal/operators/dematerialize';
+export { distinct } from './internal/operators/distinct';
+export { distinctUntilChanged } from './internal/operators/distinctUntilChanged';
+export { distinctUntilKeyChanged } from './internal/operators/distinctUntilKeyChanged';
+export { elementAt } from './internal/operators/elementAt';
+export { endWith } from './internal/operators/endWith';
+export { every } from './internal/operators/every';
+export { exhaust } from './internal/operators/exhaust';
+export { exhaustAll } from './internal/operators/exhaustAll';
+export { exhaustMap } from './internal/operators/exhaustMap';
+export { expand } from './internal/operators/expand';
+export { filter } from './internal/operators/filter';
+export { finalize } from './internal/operators/finalize';
+export { find } from './internal/operators/find';
+export { findIndex } from './internal/operators/findIndex';
+export { first } from './internal/operators/first';
+export { groupBy, BasicGroupByOptions, GroupByOptionsWithElement } from './internal/operators/groupBy';
+export { ignoreElements } from './internal/operators/ignoreElements';
+export { isEmpty } from './internal/operators/isEmpty';
+export { last } from './internal/operators/last';
+export { map } from './internal/operators/map';
+export { mapTo } from './internal/operators/mapTo';
+export { materialize } from './internal/operators/materialize';
+export { max } from './internal/operators/max';
+export { mergeAll } from './internal/operators/mergeAll';
+export { flatMap } from './internal/operators/flatMap';
+export { mergeMap } from './internal/operators/mergeMap';
+export { mergeMapTo } from './internal/operators/mergeMapTo';
+export { mergeScan } from './internal/operators/mergeScan';
+export { mergeWith } from './internal/operators/mergeWith';
+export { min } from './internal/operators/min';
+export { multicast } from './internal/operators/multicast';
+export { observeOn } from './internal/operators/observeOn';
+export { onErrorResumeNextWith } from './internal/operators/onErrorResumeNextWith';
+export { pairwise } from './internal/operators/pairwise';
+export { pluck } from './internal/operators/pluck';
+export { publish } from './internal/operators/publish';
+export { publishBehavior } from './internal/operators/publishBehavior';
+export { publishLast } from './internal/operators/publishLast';
+export { publishReplay } from './internal/operators/publishReplay';
+export { raceWith } from './internal/operators/raceWith';
+export { reduce } from './internal/operators/reduce';
+export { repeat, RepeatConfig } from './internal/operators/repeat';
+export { repeatWhen } from './internal/operators/repeatWhen';
+export { retry, RetryConfig } from './internal/operators/retry';
+export { retryWhen } from './internal/operators/retryWhen';
+export { refCount } from './internal/operators/refCount';
+export { sample } from './internal/operators/sample';
+export { sampleTime } from './internal/operators/sampleTime';
+export { scan } from './internal/operators/scan';
+export { sequenceEqual } from './internal/operators/sequenceEqual';
+export { share, ShareConfig } from './internal/operators/share';
+export { shareReplay, ShareReplayConfig } from './internal/operators/shareReplay';
+export { single } from './internal/operators/single';
+export { skip } from './internal/operators/skip';
+export { skipLast } from './internal/operators/skipLast';
+export { skipUntil } from './internal/operators/skipUntil';
+export { skipWhile } from './internal/operators/skipWhile';
+export { startWith } from './internal/operators/startWith';
+export { subscribeOn } from './internal/operators/subscribeOn';
+export { switchAll } from './internal/operators/switchAll';
+export { switchMap } from './internal/operators/switchMap';
+export { switchMapTo } from './internal/operators/switchMapTo';
+export { switchScan } from './internal/operators/switchScan';
+export { take } from './internal/operators/take';
+export { takeLast } from './internal/operators/takeLast';
+export { takeUntil } from './internal/operators/takeUntil';
+export { takeWhile } from './internal/operators/takeWhile';
+export { tap, TapObserver } from './internal/operators/tap';
+export { throttle, ThrottleConfig } from './internal/operators/throttle';
+export { throttleTime } from './internal/operators/throttleTime';
+export { throwIfEmpty } from './internal/operators/throwIfEmpty';
+export { timeInterval } from './internal/operators/timeInterval';
+export { timeout, TimeoutConfig, TimeoutInfo } from './internal/operators/timeout';
+export { timeoutWith } from './internal/operators/timeoutWith';
+export { timestamp } from './internal/operators/timestamp';
+export { toArray } from './internal/operators/toArray';
+export { window } from './internal/operators/window';
+export { windowCount } from './internal/operators/windowCount';
+export { windowTime } from './internal/operators/windowTime';
+export { windowToggle } from './internal/operators/windowToggle';
+export { windowWhen } from './internal/operators/windowWhen';
+export { withLatestFrom } from './internal/operators/withLatestFrom';
+export { zipAll } from './internal/operators/zipAll';
+export { zipWith } from './internal/operators/zipWith';
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/rxjs/dist/types/internal/AnyCatcher.d.ts

@@ -0,0 +1,10 @@
+declare const anyCatcherSymbol: unique symbol;
+/**
+ * This is just a type that we're using to identify `any` being passed to
+ * function overloads. This is used because of situations like {@link forkJoin},
+ * where it could return an `Observable<T[]>` or an `Observable<{ [key: K]: T }>`,
+ * so `forkJoin(any)` would mean we need to return `Observable<unknown>`.
+ */
+export declare type AnyCatcher = typeof anyCatcherSymbol;
+export {};
+//# sourceMappingURL=AnyCatcher.d.ts.map

package/dist/_types/rxjs/dist/types/internal/AsyncSubject.d.ts

@@ -0,0 +1,15 @@
+import { Subject } from './Subject';
+/**
+ * A variant of Subject that only emits a value when it completes. It will emit
+ * its latest value to all its observers on completion.
+ *
+ * @class AsyncSubject<T>
+ */
+export declare class AsyncSubject<T> extends Subject<T> {
+    private _value;
+    private _hasValue;
+    private _isComplete;
+    next(value: T): void;
+    complete(): void;
+}
+//# sourceMappingURL=AsyncSubject.d.ts.map

package/dist/_types/rxjs/dist/types/internal/BehaviorSubject.d.ts

@@ -0,0 +1,15 @@
+import { Subject } from './Subject';
+/**
+ * A variant of Subject that requires an initial value and emits its current
+ * value whenever it is subscribed to.
+ *
+ * @class BehaviorSubject<T>
+ */
+export declare class BehaviorSubject<T> extends Subject<T> {
+    private _value;
+    constructor(_value: T);
+    get value(): T;
+    getValue(): T;
+    next(value: T): void;
+}
+//# sourceMappingURL=BehaviorSubject.d.ts.map

package/dist/_types/rxjs/dist/types/internal/Notification.d.ts

@@ -0,0 +1,180 @@
+import { PartialObserver, ObservableNotification, CompleteNotification, NextNotification, ErrorNotification } from './types';
+import { Observable } from './Observable';
+/**
+ * @deprecated Use a string literal instead. `NotificationKind` will be replaced with a type alias in v8.
+ * It will not be replaced with a const enum as those are not compatible with isolated modules.
+ */
+export declare enum NotificationKind {
+    NEXT = "N",
+    ERROR = "E",
+    COMPLETE = "C"
+}
+/**
+ * Represents a push-based event or value that an {@link Observable} can emit.
+ * This class is particularly useful for operators that manage notifications,
+ * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and
+ * others. Besides wrapping the actual delivered value, it also annotates it
+ * with metadata of, for instance, what type of push message it is (`next`,
+ * `error`, or `complete`).
+ *
+ * @see {@link materialize}
+ * @see {@link dematerialize}
+ * @see {@link observeOn}
+ * @deprecated It is NOT recommended to create instances of `Notification` directly.
+ * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
+ * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
+ * Will be removed in v8.
+ */
+export declare class Notification<T> {
+    readonly kind: 'N' | 'E' | 'C';
+    readonly value?: T | undefined;
+    readonly error?: any;
+    /**
+     * A value signifying that the notification will "next" if observed. In truth,
+     * This is really synonymous with just checking `kind === "N"`.
+     * @deprecated Will be removed in v8. Instead, just check to see if the value of `kind` is `"N"`.
+     */
+    readonly hasValue: boolean;
+    /**
+     * Creates a "Next" notification object.
+     * @param kind Always `'N'`
+     * @param value The value to notify with if observed.
+     * @deprecated Internal implementation detail. Use {@link Notification#createNext createNext} instead.
+     */
+    constructor(kind: 'N', value?: T);
+    /**
+     * Creates an "Error" notification object.
+     * @param kind Always `'E'`
+     * @param value Always `undefined`
+     * @param error The error to notify with if observed.
+     * @deprecated Internal implementation detail. Use {@link Notification#createError createError} instead.
+     */
+    constructor(kind: 'E', value: undefined, error: any);
+    /**
+     * Creates a "completion" notification object.
+     * @param kind Always `'C'`
+     * @deprecated Internal implementation detail. Use {@link Notification#createComplete createComplete} instead.
+     */
+    constructor(kind: 'C');
+    /**
+     * Executes the appropriate handler on a passed `observer` given the `kind` of notification.
+     * If the handler is missing it will do nothing. Even if the notification is an error, if
+     * there is no error handler on the observer, an error will not be thrown, it will noop.
+     * @param observer The observer to notify.
+     */
+    observe(observer: PartialObserver<T>): void;
+    /**
+     * Executes a notification on the appropriate handler from a list provided.
+     * If a handler is missing for the kind of notification, nothing is called
+     * and no error is thrown, it will be a noop.
+     * @param next A next handler
+     * @param error An error handler
+     * @param complete A complete handler
+     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
+     */
+    do(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;
+    /**
+     * Executes a notification on the appropriate handler from a list provided.
+     * If a handler is missing for the kind of notification, nothing is called
+     * and no error is thrown, it will be a noop.
+     * @param next A next handler
+     * @param error An error handler
+     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
+     */
+    do(next: (value: T) => void, error: (err: any) => void): void;
+    /**
+     * Executes the next handler if the Notification is of `kind` `"N"`. Otherwise
+     * this will not error, and it will be a noop.
+     * @param next The next handler
+     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
+     */
+    do(next: (value: T) => void): void;
+    /**
+     * Executes a notification on the appropriate handler from a list provided.
+     * If a handler is missing for the kind of notification, nothing is called
+     * and no error is thrown, it will be a noop.
+     * @param next A next handler
+     * @param error An error handler
+     * @param complete A complete handler
+     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
+     */
+    accept(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;
+    /**
+     * Executes a notification on the appropriate handler from a list provided.
+     * If a handler is missing for the kind of notification, nothing is called
+     * and no error is thrown, it will be a noop.
+     * @param next A next handler
+     * @param error An error handler
+     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
+     */
+    accept(next: (value: T) => void, error: (err: any) => void): void;
+    /**
+     * Executes the next handler if the Notification is of `kind` `"N"`. Otherwise
+     * this will not error, and it will be a noop.
+     * @param next The next handler
+     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
+     */
+    accept(next: (value: T) => void): void;
+    /**
+     * Executes the appropriate handler on a passed `observer` given the `kind` of notification.
+     * If the handler is missing it will do nothing. Even if the notification is an error, if
+     * there is no error handler on the observer, an error will not be thrown, it will noop.
+     * @param observer The observer to notify.
+     * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8.
+     */
+    accept(observer: PartialObserver<T>): void;
+    /**
+     * Returns a simple Observable that just delivers the notification represented
+     * by this Notification instance.
+     *
+     * @deprecated Will be removed in v8. To convert a `Notification` to an {@link Observable},
+     * use {@link of} and {@link dematerialize}: `of(notification).pipe(dematerialize())`.
+     */
+    toObservable(): Observable<T>;
+    private static completeNotification;
+    /**
+     * A shortcut to create a Notification instance of the type `next` from a
+     * given value.
+     * @param {T} value The `next` value.
+     * @return {Notification<T>} The "next" Notification representing the
+     * argument.
+     * @nocollapse
+     * @deprecated It is NOT recommended to create instances of `Notification` directly.
+     * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
+     * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
+     * Will be removed in v8.
+     */
+    static createNext<T>(value: T): Notification<T> & NextNotification<T>;
+    /**
+     * A shortcut to create a Notification instance of the type `error` from a
+     * given error.
+     * @param {any} [err] The `error` error.
+     * @return {Notification<T>} The "error" Notification representing the
+     * argument.
+     * @nocollapse
+     * @deprecated It is NOT recommended to create instances of `Notification` directly.
+     * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
+     * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
+     * Will be removed in v8.
+     */
+    static createError(err?: any): Notification<never> & ErrorNotification;
+    /**
+     * A shortcut to create a Notification instance of the type `complete`.
+     * @return {Notification<any>} The valueless "complete" Notification.
+     * @nocollapse
+     * @deprecated It is NOT recommended to create instances of `Notification` directly.
+     * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}.
+     * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`.
+     * Will be removed in v8.
+     */
+    static createComplete(): Notification<never> & CompleteNotification;
+}
+/**
+ * Executes the appropriate handler on a passed `observer` given the `kind` of notification.
+ * If the handler is missing it will do nothing. Even if the notification is an error, if
+ * there is no error handler on the observer, an error will not be thrown, it will noop.
+ * @param notification The notification object to observe.
+ * @param observer The observer to notify.
+ */
+export declare function observeNotification<T>(notification: ObservableNotification<T>, observer: PartialObserver<T>): void;
+//# sourceMappingURL=Notification.d.ts.map

package/dist/_types/rxjs/dist/types/internal/Observable.d.ts

@@ -0,0 +1,128 @@
+import { Operator } from './Operator';
+import { Subscriber } from './Subscriber';
+import { Subscription } from './Subscription';
+import { TeardownLogic, OperatorFunction, Subscribable, Observer } from './types';
+/**
+ * A representation of any set of values over any amount of time. This is the most basic building block
+ * of RxJS.
+ *
+ * @class Observable<T>
+ */
+export declare class Observable<T> implements Subscribable<T> {
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     */
+    source: Observable<any> | undefined;
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     */
+    operator: Operator<any, T> | undefined;
+    /**
+     * @constructor
+     * @param {Function} subscribe the function that is called when the Observable is
+     * initially subscribed to. This function is given a Subscriber, to which new values
+     * can be `next`ed, or an `error` method can be called to raise an error, or
+     * `complete` can be called to notify of a successful completion.
+     */
+    constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
+    /**
+     * Creates a new Observable by calling the Observable constructor
+     * @owner Observable
+     * @method create
+     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
+     * @return {Observable} a new observable
+     * @nocollapse
+     * @deprecated Use `new Observable()` instead. Will be removed in v8.
+     */
+    static create: (...args: any[]) => any;
+    /**
+     * Creates a new Observable, with this Observable instance as the source, and the passed
+     * operator defined as the new observable's operator.
+     * @method lift
+     * @param operator the operator defining the operation to take on the observable
+     * @return a new observable with the Operator applied
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     * If you have implemented an operator using `lift`, it is recommended that you create an
+     * operator by simply returning `new Observable()` directly. See "Creating new operators from
+     * scratch" section here: https://rxjs.dev/guide/operators
+     */
+    lift<R>(operator?: Operator<T, R>): Observable<R>;
+    subscribe(observerOrNext?: Partial<Observer<T>> | ((value: T) => void)): Subscription;
+    /** @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 */
+    subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
+    /**
+     * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
+     * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
+     *
+     * **WARNING**: Only use this with observables you *know* will complete. If the source
+     * observable does not complete, you will end up with a promise that is hung up, and
+     * potentially all of the state of an async function hanging out in memory. To avoid
+     * this situation, look into adding something like {@link timeout}, {@link take},
+     * {@link takeWhile}, or {@link takeUntil} amongst others.
+     *
+     * #### Example
+     *
+     * ```ts
+     * import { interval, take } from 'rxjs';
+     *
+     * const source$ = interval(1000).pipe(take(4));
+     *
+     * async function getTotal() {
+     *   let total = 0;
+     *
+     *   await source$.forEach(value => {
+     *     total += value;
+     *     console.log('observable -> ' + value);
+     *   });
+     *
+     *   return total;
+     * }
+     *
+     * getTotal().then(
+     *   total => console.log('Total: ' + total)
+     * );
+     *
+     * // Expected:
+     * // 'observable -> 0'
+     * // 'observable -> 1'
+     * // 'observable -> 2'
+     * // 'observable -> 3'
+     * // 'Total: 6'
+     * ```
+     *
+     * @param next a handler for each value emitted by the observable
+     * @return a promise that either resolves on observable completion or
+     *  rejects with the handled error
+     */
+    forEach(next: (value: T) => void): Promise<void>;
+    /**
+     * @param next a handler for each value emitted by the observable
+     * @param promiseCtor a constructor function used to instantiate the Promise
+     * @return a promise that either resolves on observable completion or
+     *  rejects with the handled error
+     * @deprecated Passing a Promise constructor will no longer be available
+     * in upcoming versions of RxJS. This is because it adds weight to the library, for very
+     * little benefit. If you need this functionality, it is recommended that you either
+     * polyfill Promise, or you create an adapter to convert the returned native promise
+     * to whatever promise implementation you wanted. Will be removed in v8.
+     */
+    forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
+    pipe(): Observable<T>;
+    pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
+    pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
+    pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
+    pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
+    pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
+    pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
+    pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
+    pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(): Promise<T | undefined>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
+}
+//# sourceMappingURL=Observable.d.ts.map

package/dist/_types/rxjs/dist/types/internal/Operator.d.ts

@@ -0,0 +1,9 @@
+import { Subscriber } from './Subscriber';
+import { TeardownLogic } from './types';
+/***
+ * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+ */
+export interface Operator<T, R> {
+    call(subscriber: Subscriber<R>, source: any): TeardownLogic;
+}
+//# sourceMappingURL=Operator.d.ts.map

package/dist/_types/rxjs/dist/types/internal/ReplaySubject.d.ts

@@ -0,0 +1,49 @@
+import { Subject } from './Subject';
+import { TimestampProvider } from './types';
+/**
+ * A variant of {@link Subject} that "replays" old values to new subscribers by emitting them when they first subscribe.
+ *
+ * `ReplaySubject` has an internal buffer that will store a specified number of values that it has observed. Like `Subject`,
+ * `ReplaySubject` "observes" values by having them passed to its `next` method. When it observes a value, it will store that
+ * value for a time determined by the configuration of the `ReplaySubject`, as passed to its constructor.
+ *
+ * When a new subscriber subscribes to the `ReplaySubject` instance, it will synchronously emit all values in its buffer in
+ * a First-In-First-Out (FIFO) manner. The `ReplaySubject` will also complete, if it has observed completion; and it will
+ * error if it has observed an error.
+ *
+ * There are two main configuration items to be concerned with:
+ *
+ * 1. `bufferSize` - This will determine how many items are stored in the buffer, defaults to infinite.
+ * 2. `windowTime` - The amount of time to hold a value in the buffer before removing it from the buffer.
+ *
+ * Both configurations may exist simultaneously. So if you would like to buffer a maximum of 3 values, as long as the values
+ * are less than 2 seconds old, you could do so with a `new ReplaySubject(3, 2000)`.
+ *
+ * ### Differences with BehaviorSubject
+ *
+ * `BehaviorSubject` is similar to `new ReplaySubject(1)`, with a couple of exceptions:
+ *
+ * 1. `BehaviorSubject` comes "primed" with a single value upon construction.
+ * 2. `ReplaySubject` will replay values, even after observing an error, where `BehaviorSubject` will not.
+ *
+ * @see {@link Subject}
+ * @see {@link BehaviorSubject}
+ * @see {@link shareReplay}
+ */
+export declare class ReplaySubject<T> extends Subject<T> {
+    private _bufferSize;
+    private _windowTime;
+    private _timestampProvider;
+    private _buffer;
+    private _infiniteTimeWindow;
+    /**
+     * @param bufferSize The size of the buffer to replay on subscription
+     * @param windowTime The amount of time the buffered items will stay buffered
+     * @param timestampProvider An object with a `now()` method that provides the current timestamp. This is used to
+     * calculate the amount of time something has been buffered.
+     */
+    constructor(_bufferSize?: number, _windowTime?: number, _timestampProvider?: TimestampProvider);
+    next(value: T): void;
+    private _trimBuffer;
+}
+//# sourceMappingURL=ReplaySubject.d.ts.map