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

package/dist/_types/rxjs/dist/types/internal/scheduler/AsapScheduler.d.ts

@@ -0,0 +1,6 @@
+import { AsyncAction } from './AsyncAction';
+import { AsyncScheduler } from './AsyncScheduler';
+export declare class AsapScheduler extends AsyncScheduler {
+    flush(action?: AsyncAction<any>): void;
+}
+//# sourceMappingURL=AsapScheduler.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/AsyncAction.d.ts

@@ -0,0 +1,25 @@
+import { Action } from './Action';
+import { SchedulerAction } from '../types';
+import { Subscription } from '../Subscription';
+import { AsyncScheduler } from './AsyncScheduler';
+import { TimerHandle } from './timerHandle';
+export declare class AsyncAction<T> extends Action<T> {
+    protected scheduler: AsyncScheduler;
+    protected work: (this: SchedulerAction<T>, state?: T) => void;
+    id: TimerHandle | undefined;
+    state?: T;
+    delay: number;
+    protected pending: boolean;
+    constructor(scheduler: AsyncScheduler, work: (this: SchedulerAction<T>, state?: T) => void);
+    schedule(state?: T, delay?: number): Subscription;
+    protected requestAsyncId(scheduler: AsyncScheduler, _id?: TimerHandle, delay?: number): TimerHandle;
+    protected recycleAsyncId(_scheduler: AsyncScheduler, id?: TimerHandle, delay?: number | null): TimerHandle | undefined;
+    /**
+     * Immediately executes this action and the `work` it contains.
+     * @return {any}
+     */
+    execute(state: T, delay: number): any;
+    protected _execute(state: T, _delay: number): any;
+    unsubscribe(): void;
+}
+//# sourceMappingURL=AsyncAction.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/AsyncScheduler.d.ts

@@ -0,0 +1,9 @@
+import { Scheduler } from '../Scheduler';
+import { Action } from './Action';
+import { AsyncAction } from './AsyncAction';
+export declare class AsyncScheduler extends Scheduler {
+    actions: Array<AsyncAction<any>>;
+    constructor(SchedulerAction: typeof Action, now?: () => number);
+    flush(action: AsyncAction<any>): void;
+}
+//# sourceMappingURL=AsyncScheduler.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/QueueScheduler.d.ts

@@ -0,0 +1,4 @@
+import { AsyncScheduler } from './AsyncScheduler';
+export declare class QueueScheduler extends AsyncScheduler {
+}
+//# sourceMappingURL=QueueScheduler.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/VirtualTimeScheduler.d.ts

@@ -0,0 +1,49 @@
+import { AsyncAction } from './AsyncAction';
+import { Subscription } from '../Subscription';
+import { AsyncScheduler } from './AsyncScheduler';
+import { SchedulerAction } from '../types';
+import { TimerHandle } from './timerHandle';
+export declare class VirtualTimeScheduler extends AsyncScheduler {
+    maxFrames: number;
+    /** @deprecated Not used in VirtualTimeScheduler directly. Will be removed in v8. */
+    static frameTimeFactor: number;
+    /**
+     * The current frame for the state of the virtual scheduler instance. The difference
+     * between two "frames" is synonymous with the passage of "virtual time units". So if
+     * you record `scheduler.frame` to be `1`, then later, observe `scheduler.frame` to be at `11`,
+     * that means `10` virtual time units have passed.
+     */
+    frame: number;
+    /**
+     * Used internally to examine the current virtual action index being processed.
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     */
+    index: number;
+    /**
+     * This creates an instance of a `VirtualTimeScheduler`. Experts only. The signature of
+     * this constructor is likely to change in the long run.
+     *
+     * @param schedulerActionCtor The type of Action to initialize when initializing actions during scheduling.
+     * @param maxFrames The maximum number of frames to process before stopping. Used to prevent endless flush cycles.
+     */
+    constructor(schedulerActionCtor?: typeof AsyncAction, maxFrames?: number);
+    /**
+     * Prompt the Scheduler to execute all of its queued actions, therefore
+     * clearing its queue.
+     * @return {void}
+     */
+    flush(): void;
+}
+export declare class VirtualAction<T> extends AsyncAction<T> {
+    protected scheduler: VirtualTimeScheduler;
+    protected work: (this: SchedulerAction<T>, state?: T) => void;
+    protected index: number;
+    protected active: boolean;
+    constructor(scheduler: VirtualTimeScheduler, work: (this: SchedulerAction<T>, state?: T) => void, index?: number);
+    schedule(state?: T, delay?: number): Subscription;
+    protected requestAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): TimerHandle;
+    protected recycleAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): TimerHandle | undefined;
+    protected _execute(state: T, delay: number): any;
+    private static sortActions;
+}
+//# sourceMappingURL=VirtualTimeScheduler.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/animationFrame.d.ts

@@ -0,0 +1,38 @@
+import { AnimationFrameScheduler } from './AnimationFrameScheduler';
+/**
+ *
+ * Animation Frame Scheduler
+ *
+ * <span class="informal">Perform task when `window.requestAnimationFrame` would fire</span>
+ *
+ * When `animationFrame` scheduler is used with delay, it will fall back to {@link asyncScheduler} scheduler
+ * behaviour.
+ *
+ * Without delay, `animationFrame` scheduler can be used to create smooth browser animations.
+ * It makes sure scheduled task will happen just before next browser content repaint,
+ * thus performing animations as efficiently as possible.
+ *
+ * ## Example
+ * Schedule div height animation
+ * ```ts
+ * // html: <div style="background: #0ff;"></div>
+ * import { animationFrameScheduler } from 'rxjs';
+ *
+ * const div = document.querySelector('div');
+ *
+ * animationFrameScheduler.schedule(function(height) {
+ *   div.style.height = height + "px";
+ *
+ *   this.schedule(height + 1);  // `this` references currently executing Action,
+ *                               // which we reschedule with new state
+ * }, 0, 0);
+ *
+ * // You will see a div element growing in height
+ * ```
+ */
+export declare const animationFrameScheduler: AnimationFrameScheduler;
+/**
+ * @deprecated Renamed to {@link animationFrameScheduler}. Will be removed in v8.
+ */
+export declare const animationFrame: AnimationFrameScheduler;
+//# sourceMappingURL=animationFrame.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/asap.d.ts

@@ -0,0 +1,41 @@
+import { AsapScheduler } from './AsapScheduler';
+/**
+ *
+ * Asap Scheduler
+ *
+ * <span class="informal">Perform task as fast as it can be performed asynchronously</span>
+ *
+ * `asap` scheduler behaves the same as {@link asyncScheduler} scheduler when you use it to delay task
+ * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing
+ * code to end and then it will try to execute given task as fast as possible.
+ *
+ * `asap` scheduler will do its best to minimize time between end of currently executing code
+ * and start of scheduled task. This makes it best candidate for performing so called "deferring".
+ * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves
+ * some (although minimal) unwanted delay.
+ *
+ * Note that using `asap` scheduler does not necessarily mean that your task will be first to process
+ * after currently executing code. In particular, if some task was also scheduled with `asap` before,
+ * that task will execute first. That being said, if you need to schedule task asynchronously, but
+ * as soon as possible, `asap` scheduler is your best bet.
+ *
+ * ## Example
+ * Compare async and asap scheduler<
+ * ```ts
+ * import { asapScheduler, asyncScheduler } from 'rxjs';
+ *
+ * asyncScheduler.schedule(() => console.log('async')); // scheduling 'async' first...
+ * asapScheduler.schedule(() => console.log('asap'));
+ *
+ * // Logs:
+ * // "asap"
+ * // "async"
+ * // ... but 'asap' goes first!
+ * ```
+ */
+export declare const asapScheduler: AsapScheduler;
+/**
+ * @deprecated Renamed to {@link asapScheduler}. Will be removed in v8.
+ */
+export declare const asap: AsapScheduler;
+//# sourceMappingURL=asap.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/async.d.ts

@@ -0,0 +1,53 @@
+import { AsyncScheduler } from './AsyncScheduler';
+/**
+ *
+ * Async Scheduler
+ *
+ * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span>
+ *
+ * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript
+ * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating
+ * in intervals.
+ *
+ * If you just want to "defer" task, that is to perform it right after currently
+ * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),
+ * better choice will be the {@link asapScheduler} scheduler.
+ *
+ * ## Examples
+ * Use async scheduler to delay task
+ * ```ts
+ * import { asyncScheduler } from 'rxjs';
+ *
+ * const task = () => console.log('it works!');
+ *
+ * asyncScheduler.schedule(task, 2000);
+ *
+ * // After 2 seconds logs:
+ * // "it works!"
+ * ```
+ *
+ * Use async scheduler to repeat task in intervals
+ * ```ts
+ * import { asyncScheduler } from 'rxjs';
+ *
+ * function task(state) {
+ *   console.log(state);
+ *   this.schedule(state + 1, 1000); // `this` references currently executing Action,
+ *                                   // which we reschedule with new state and delay
+ * }
+ *
+ * asyncScheduler.schedule(task, 3000, 0);
+ *
+ * // Logs:
+ * // 0 after 3s
+ * // 1 after 4s
+ * // 2 after 5s
+ * // 3 after 6s
+ * ```
+ */
+export declare const asyncScheduler: AsyncScheduler;
+/**
+ * @deprecated Renamed to {@link asyncScheduler}. Will be removed in v8.
+ */
+export declare const async: AsyncScheduler;
+//# sourceMappingURL=async.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/queue.d.ts

@@ -0,0 +1,69 @@
+import { QueueScheduler } from './QueueScheduler';
+/**
+ *
+ * Queue Scheduler
+ *
+ * <span class="informal">Put every next task on a queue, instead of executing it immediately</span>
+ *
+ * `queue` scheduler, when used with delay, behaves the same as {@link asyncScheduler} scheduler.
+ *
+ * When used without delay, it schedules given task synchronously - executes it right when
+ * it is scheduled. However when called recursively, that is when inside the scheduled task,
+ * another task is scheduled with queue scheduler, instead of executing immediately as well,
+ * that task will be put on a queue and wait for current one to finish.
+ *
+ * This means that when you execute task with `queue` scheduler, you are sure it will end
+ * before any other task scheduled with that scheduler will start.
+ *
+ * ## Examples
+ * Schedule recursively first, then do something
+ * ```ts
+ * import { queueScheduler } from 'rxjs';
+ *
+ * queueScheduler.schedule(() => {
+ *   queueScheduler.schedule(() => console.log('second')); // will not happen now, but will be put on a queue
+ *
+ *   console.log('first');
+ * });
+ *
+ * // Logs:
+ * // "first"
+ * // "second"
+ * ```
+ *
+ * Reschedule itself recursively
+ * ```ts
+ * import { queueScheduler } from 'rxjs';
+ *
+ * queueScheduler.schedule(function(state) {
+ *   if (state !== 0) {
+ *     console.log('before', state);
+ *     this.schedule(state - 1); // `this` references currently executing Action,
+ *                               // which we reschedule with new state
+ *     console.log('after', state);
+ *   }
+ * }, 0, 3);
+ *
+ * // In scheduler that runs recursively, you would expect:
+ * // "before", 3
+ * // "before", 2
+ * // "before", 1
+ * // "after", 1
+ * // "after", 2
+ * // "after", 3
+ *
+ * // But with queue it logs:
+ * // "before", 3
+ * // "after", 3
+ * // "before", 2
+ * // "after", 2
+ * // "before", 1
+ * // "after", 1
+ * ```
+ */
+export declare const queueScheduler: QueueScheduler;
+/**
+ * @deprecated Renamed to {@link queueScheduler}. Will be removed in v8.
+ */
+export declare const queue: QueueScheduler;
+//# sourceMappingURL=queue.d.ts.map

package/dist/_types/rxjs/dist/types/internal/scheduler/timerHandle.d.ts

@@ -0,0 +1,2 @@
+export declare type TimerHandle = number | ReturnType<typeof setTimeout>;
+//# sourceMappingURL=timerHandle.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Symbol.observable or a string "@@observable". Used for interop
+ *
+ * @deprecated We will no longer be exporting this symbol in upcoming versions of RxJS.
+ * Instead polyfill and use Symbol.observable directly *or* use https://www.npmjs.com/package/symbol-observable
+ */
+export declare const observable: string | symbol;
+//# sourceMappingURL=observable.d.ts.map

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

@@ -0,0 +1,301 @@
+/// <reference lib="esnext.asynciterable" />
+import { Observable } from './Observable';
+import { Subscription } from './Subscription';
+/**
+ * Note: This will add Symbol.observable globally for all TypeScript users,
+ * however, we are no longer polyfilling Symbol.observable
+ */
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+/**
+ * A function type interface that describes a function that accepts one parameter `T`
+ * and returns another parameter `R`.
+ *
+ * Usually used to describe {@link OperatorFunction} - it always takes a single
+ * parameter (the source Observable) and returns another Observable.
+ */
+export interface UnaryFunction<T, R> {
+    (source: T): R;
+}
+export interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {
+}
+export declare type FactoryOrValue<T> = T | (() => T);
+export interface MonoTypeOperatorFunction<T> extends OperatorFunction<T, T> {
+}
+/**
+ * A value and the time at which it was emitted.
+ *
+ * Emitted by the `timestamp` operator
+ *
+ * @see {@link timestamp}
+ */
+export interface Timestamp<T> {
+    value: T;
+    /**
+     * The timestamp. By default, this is in epoch milliseconds.
+     * Could vary based on the timestamp provider passed to the operator.
+     */
+    timestamp: number;
+}
+/**
+ * A value emitted and the amount of time since the last value was emitted.
+ *
+ * Emitted by the `timeInterval` operator.
+ *
+ * @see {@link timeInterval}
+ */
+export interface TimeInterval<T> {
+    value: T;
+    /**
+     * The amount of time between this value's emission and the previous value's emission.
+     * If this is the first emitted value, then it will be the amount of time since subscription
+     * started.
+     */
+    interval: number;
+}
+export interface Unsubscribable {
+    unsubscribe(): void;
+}
+export declare type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;
+export interface SubscriptionLike extends Unsubscribable {
+    unsubscribe(): void;
+    readonly closed: boolean;
+}
+/**
+ * @deprecated Do not use. Most likely you want to use `ObservableInput`. Will be removed in v8.
+ */
+export declare type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>;
+/** OBSERVABLE INTERFACES */
+export interface Subscribable<T> {
+    subscribe(observer: Partial<Observer<T>>): Unsubscribable;
+}
+/**
+ * Valid types that can be converted to observables.
+ */
+export declare type ObservableInput<T> = Observable<T> | InteropObservable<T> | AsyncIterable<T> | PromiseLike<T> | ArrayLike<T> | Iterable<T> | ReadableStreamLike<T>;
+/**
+ * @deprecated Renamed to {@link InteropObservable }. Will be removed in v8.
+ */
+export declare type ObservableLike<T> = InteropObservable<T>;
+/**
+ * An object that implements the `Symbol.observable` interface.
+ */
+export interface InteropObservable<T> {
+    [Symbol.observable]: () => Subscribable<T>;
+}
+/**
+ * A notification representing a "next" from an observable.
+ * Can be used with {@link dematerialize}.
+ */
+export interface NextNotification<T> {
+    /** The kind of notification. Always "N" */
+    kind: 'N';
+    /** The value of the notification. */
+    value: T;
+}
+/**
+ * A notification representing an "error" from an observable.
+ * Can be used with {@link dematerialize}.
+ */
+export interface ErrorNotification {
+    /** The kind of notification. Always "E" */
+    kind: 'E';
+    error: any;
+}
+/**
+ * A notification representing a "completion" from an observable.
+ * Can be used with {@link dematerialize}.
+ */
+export interface CompleteNotification {
+    kind: 'C';
+}
+/**
+ * Valid observable notification types.
+ */
+export declare type ObservableNotification<T> = NextNotification<T> | ErrorNotification | CompleteNotification;
+export interface NextObserver<T> {
+    closed?: boolean;
+    next: (value: T) => void;
+    error?: (err: any) => void;
+    complete?: () => void;
+}
+export interface ErrorObserver<T> {
+    closed?: boolean;
+    next?: (value: T) => void;
+    error: (err: any) => void;
+    complete?: () => void;
+}
+export interface CompletionObserver<T> {
+    closed?: boolean;
+    next?: (value: T) => void;
+    error?: (err: any) => void;
+    complete: () => void;
+}
+export declare type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>;
+/**
+ * An object interface that defines a set of callback functions a user can use to get
+ * notified of any set of {@link Observable}
+ * {@link guide/glossary-and-semantics#notification notification} events.
+ *
+ * For more info, please refer to {@link guide/observer this guide}.
+ */
+export interface Observer<T> {
+    /**
+     * A callback function that gets called by the producer during the subscription when
+     * the producer "has" the `value`. It won't be called if `error` or `complete` callback
+     * functions have been called, nor after the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
+     */
+    next: (value: T) => void;
+    /**
+     * A callback function that gets called by the producer if and when it encountered a
+     * problem of any kind. The errored value will be provided through the `err` parameter.
+     * This callback can't be called more than one time, it can't be called if the
+     * `complete` callback function have been called previously, nor it can't be called if
+     * the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
+     */
+    error: (err: any) => void;
+    /**
+     * A callback function that gets called by the producer if and when it has no more
+     * values to provide (by calling `next` callback function). This means that no error
+     * has happened. This callback can't be called more than one time, it can't be called
+     * if the `error` callback function have been called previously, nor it can't be called
+     * if the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
+     */
+    complete: () => void;
+}
+export interface SubjectLike<T> extends Observer<T>, Subscribable<T> {
+}
+export interface SchedulerLike extends TimestampProvider {
+    schedule<T>(work: (this: SchedulerAction<T>, state: T) => void, delay: number, state: T): Subscription;
+    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay: number, state?: T): Subscription;
+    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
+}
+export interface SchedulerAction<T> extends Subscription {
+    schedule(state?: T, delay?: number): Subscription;
+}
+/**
+ * This is a type that provides a method to allow RxJS to create a numeric timestamp
+ */
+export interface TimestampProvider {
+    /**
+     * Returns a timestamp as a number.
+     *
+     * This is used by types like `ReplaySubject` or operators like `timestamp` to calculate
+     * the amount of time passed between events.
+     */
+    now(): number;
+}
+/**
+ * Extracts the type from an `ObservableInput<any>`. If you have
+ * `O extends ObservableInput<any>` and you pass in `Observable<number>`, or
+ * `Promise<number>`, etc, it will type as `number`.
+ */
+export declare type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never;
+/**
+ * Extracts a union of element types from an `ObservableInput<any>[]`.
+ * If you have `O extends ObservableInput<any>[]` and you pass in
+ * `Observable<string>[]` or `Promise<string>[]` you would get
+ * back a type of `string`.
+ * If you pass in `[Observable<string>, Observable<number>]` you would
+ * get back a type of `string | number`.
+ */
+export declare type ObservedValueUnionFromArray<X> = X extends Array<ObservableInput<infer T>> ? T : never;
+/**
+ * @deprecated Renamed to {@link ObservedValueUnionFromArray}. Will be removed in v8.
+ */
+export declare type ObservedValuesFromArray<X> = ObservedValueUnionFromArray<X>;
+/**
+ * Extracts a tuple of element types from an `ObservableInput<any>[]`.
+ * If you have `O extends ObservableInput<any>[]` and you pass in
+ * `[Observable<string>, Observable<number>]` you would get back a type
+ * of `[string, number]`.
+ */
+export declare type ObservedValueTupleFromArray<X> = {
+    [K in keyof X]: ObservedValueOf<X[K]>;
+};
+/**
+ * Used to infer types from arguments to functions like {@link forkJoin}.
+ * So that you can have `forkJoin([Observable<A>, PromiseLike<B>]): Observable<[A, B]>`
+ * et al.
+ */
+export declare type ObservableInputTuple<T> = {
+    [K in keyof T]: ObservableInput<T[K]>;
+};
+/**
+ * Constructs a new tuple with the specified type at the head.
+ * If you declare `Cons<A, [B, C]>` you will get back `[A, B, C]`.
+ */
+export declare type Cons<X, Y extends readonly any[]> = ((arg: X, ...rest: Y) => any) extends (...args: infer U) => any ? U : never;
+/**
+ * Extracts the head of a tuple.
+ * If you declare `Head<[A, B, C]>` you will get back `A`.
+ */
+export declare type Head<X extends readonly any[]> = ((...args: X) => any) extends (arg: infer U, ...rest: any[]) => any ? U : never;
+/**
+ * Extracts the tail of a tuple.
+ * If you declare `Tail<[A, B, C]>` you will get back `[B, C]`.
+ */
+export declare type Tail<X extends readonly any[]> = ((...args: X) => any) extends (arg: any, ...rest: infer U) => any ? U : never;
+/**
+ * Extracts the generic value from an Array type.
+ * If you have `T extends Array<any>`, and pass a `string[]` to it,
+ * `ValueFromArray<T>` will return the actual type of `string`.
+ */
+export declare type ValueFromArray<A extends readonly unknown[]> = A extends Array<infer T> ? T : never;
+/**
+ * Gets the value type from an {@link ObservableNotification}, if possible.
+ */
+export declare type ValueFromNotification<T> = T extends {
+    kind: 'N' | 'E' | 'C';
+} ? T extends NextNotification<any> ? T extends {
+    value: infer V;
+} ? V : undefined : never : never;
+/**
+ * A simple type to represent a gamut of "falsy" values... with a notable exception:
+ * `NaN` is "falsy" however, it is not and cannot be typed via TypeScript. See
+ * comments here: https://github.com/microsoft/TypeScript/issues/28682#issuecomment-707142417
+ */
+export declare type Falsy = null | undefined | false | 0 | -0 | 0n | '';
+export declare type TruthyTypesOf<T> = T extends Falsy ? never : T;
+interface ReadableStreamDefaultReaderLike<T> {
+    read(): PromiseLike<{
+        done: false;
+        value: T;
+    } | {
+        done: true;
+        value?: undefined;
+    }>;
+    releaseLock(): void;
+}
+/**
+ * The base signature RxJS will look for to identify and use
+ * a [ReadableStream](https://streams.spec.whatwg.org/#rs-class)
+ * as an {@link ObservableInput} source.
+ */
+export interface ReadableStreamLike<T> {
+    getReader(): ReadableStreamDefaultReaderLike<T>;
+}
+/**
+ * An observable with a `connect` method that is used to create a subscription
+ * to an underlying source, connecting it with all consumers via a multicast.
+ */
+export interface Connectable<T> extends Observable<T> {
+    /**
+     * (Idempotent) Calling this method will connect the underlying source observable to all subscribed consumers
+     * through an underlying {@link Subject}.
+     * @returns A subscription, that when unsubscribed, will "disconnect" the source from the connector subject,
+     * severing notifications to all consumers.
+     */
+    connect(): Subscription;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/ArgumentOutOfRangeError.d.ts

@@ -0,0 +1,21 @@
+export interface ArgumentOutOfRangeError extends Error {
+}
+export interface ArgumentOutOfRangeErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (): ArgumentOutOfRangeError;
+}
+/**
+ * An error thrown when an element was queried at a certain index of an
+ * Observable, but no such index or position exists in that sequence.
+ *
+ * @see {@link elementAt}
+ * @see {@link take}
+ * @see {@link takeLast}
+ *
+ * @class ArgumentOutOfRangeError
+ */
+export declare const ArgumentOutOfRangeError: ArgumentOutOfRangeErrorCtor;
+//# sourceMappingURL=ArgumentOutOfRangeError.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/EmptyError.d.ts

@@ -0,0 +1,23 @@
+export interface EmptyError extends Error {
+}
+export interface EmptyErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (): EmptyError;
+}
+/**
+ * An error thrown when an Observable or a sequence was queried but has no
+ * elements.
+ *
+ * @see {@link first}
+ * @see {@link last}
+ * @see {@link single}
+ * @see {@link firstValueFrom}
+ * @see {@link lastValueFrom}
+ *
+ * @class EmptyError
+ */
+export declare const EmptyError: EmptyErrorCtor;
+//# sourceMappingURL=EmptyError.d.ts.map