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

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

@@ -0,0 +1,55 @@
+import { Action } from './scheduler/Action';
+import { Subscription } from './Subscription';
+import { SchedulerLike, SchedulerAction } from './types';
+/**
+ * An execution context and a data structure to order tasks and schedule their
+ * execution. Provides a notion of (potentially virtual) time, through the
+ * `now()` getter method.
+ *
+ * Each unit of work in a Scheduler is called an `Action`.
+ *
+ * ```ts
+ * class Scheduler {
+ *   now(): number;
+ *   schedule(work, delay?, state?): Subscription;
+ * }
+ * ```
+ *
+ * @class Scheduler
+ * @deprecated Scheduler is an internal implementation detail of RxJS, and
+ * should not be used directly. Rather, create your own class and implement
+ * {@link SchedulerLike}. Will be made internal in v8.
+ */
+export declare class Scheduler implements SchedulerLike {
+    private schedulerActionCtor;
+    static now: () => number;
+    constructor(schedulerActionCtor: typeof Action, now?: () => number);
+    /**
+     * A getter method that returns a number representing the current time
+     * (at the time this function was called) according to the scheduler's own
+     * internal clock.
+     * @return {number} A number that represents the current time. May or may not
+     * have a relation to wall-clock time. May or may not refer to a time unit
+     * (e.g. milliseconds).
+     */
+    now: () => number;
+    /**
+     * Schedules a function, `work`, for execution. May happen at some point in
+     * the future, according to the `delay` parameter, if specified. May be passed
+     * some context object, `state`, which will be passed to the `work` function.
+     *
+     * The given arguments will be processed an stored as an Action object in a
+     * queue of actions.
+     *
+     * @param {function(state: ?T): ?Subscription} work A function representing a
+     * task, or some unit of work to be executed by the Scheduler.
+     * @param {number} [delay] Time to wait before executing the work, where the
+     * time unit is implicit and defined by the Scheduler itself.
+     * @param {T} [state] Some contextual data that the `work` function uses when
+     * called by the Scheduler.
+     * @return {Subscription} A subscription in order to be able to unsubscribe
+     * the scheduled work.
+     */
+    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
+}
+//# sourceMappingURL=Scheduler.d.ts.map

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

@@ -0,0 +1,58 @@
+import { Operator } from './Operator';
+import { Observable } from './Observable';
+import { Observer, SubscriptionLike } from './types';
+/**
+ * A Subject is a special type of Observable that allows values to be
+ * multicasted to many Observers. Subjects are like EventEmitters.
+ *
+ * Every Subject is an Observable and an Observer. You can subscribe to a
+ * Subject, and you can call next to feed values as well as error and complete.
+ */
+export declare class Subject<T> extends Observable<T> implements SubscriptionLike {
+    closed: boolean;
+    private currentObservers;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    observers: Observer<T>[];
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    isStopped: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    hasError: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    thrownError: any;
+    /**
+     * Creates a "subject" by basically gluing an observer to an observable.
+     *
+     * @nocollapse
+     * @deprecated Recommended you do not use. Will be removed at some point in the future. Plans for replacement still under discussion.
+     */
+    static create: (...args: any[]) => any;
+    constructor();
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    lift<R>(operator: Operator<T, R>): Observable<R>;
+    next(value: T): void;
+    error(err: any): void;
+    complete(): void;
+    unsubscribe(): void;
+    get observed(): boolean;
+    /**
+     * Creates a new Observable with this Subject as the source. You can do this
+     * to create custom Observer-side logic of the Subject and conceal it from
+     * code that uses the Observable.
+     * @return {Observable} Observable that the Subject casts to
+     */
+    asObservable(): Observable<T>;
+}
+/**
+ * @class AnonymousSubject<T>
+ */
+export declare class AnonymousSubject<T> extends Subject<T> {
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    destination?: Observer<T> | undefined;
+    constructor(
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    destination?: Observer<T> | undefined, source?: Observable<T>);
+    next(value: T): void;
+    error(err: any): void;
+    complete(): void;
+}
+//# sourceMappingURL=Subject.d.ts.map

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

@@ -0,0 +1,78 @@
+import { Observer } from './types';
+import { Subscription } from './Subscription';
+/**
+ * Implements the {@link Observer} interface and extends the
+ * {@link Subscription} class. While the {@link Observer} is the public API for
+ * consuming the values of an {@link Observable}, all Observers get converted to
+ * a Subscriber, in order to provide Subscription-like capabilities such as
+ * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
+ * implementing operators, but it is rarely used as a public API.
+ *
+ * @class Subscriber<T>
+ */
+export declare class Subscriber<T> extends Subscription implements Observer<T> {
+    /**
+     * A static factory for a Subscriber, given a (potentially partial) definition
+     * of an Observer.
+     * @param next The `next` callback of an Observer.
+     * @param error The `error` callback of an
+     * Observer.
+     * @param complete The `complete` callback of an
+     * Observer.
+     * @return A Subscriber wrapping the (partially defined)
+     * Observer represented by the given arguments.
+     * @nocollapse
+     * @deprecated Do not use. Will be removed in v8. There is no replacement for this
+     * method, and there is no reason to be creating instances of `Subscriber` directly.
+     * If you have a specific use case, please file an issue.
+     */
+    static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    protected isStopped: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    protected destination: Subscriber<any> | Observer<any>;
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
+     */
+    constructor(destination?: Subscriber<any> | Observer<any>);
+    /**
+     * The {@link Observer} callback to receive notifications of type `next` from
+     * the Observable, with a value. The Observable may call this method 0 or more
+     * times.
+     * @param {T} [value] The `next` value.
+     * @return {void}
+     */
+    next(value?: T): void;
+    /**
+     * The {@link Observer} callback to receive notifications of type `error` from
+     * the Observable, with an attached `Error`. Notifies the Observer that
+     * the Observable has experienced an error condition.
+     * @param {any} [err] The `error` exception.
+     * @return {void}
+     */
+    error(err?: any): void;
+    /**
+     * The {@link Observer} callback to receive a valueless notification of type
+     * `complete` from the Observable. Notifies the Observer that the Observable
+     * has finished sending push-based notifications.
+     * @return {void}
+     */
+    complete(): void;
+    unsubscribe(): void;
+    protected _next(value: T): void;
+    protected _error(err: any): void;
+    protected _complete(): void;
+}
+export declare class SafeSubscriber<T> extends Subscriber<T> {
+    constructor(observerOrNext?: Partial<Observer<T>> | ((value: T) => void) | null, error?: ((e?: any) => void) | null, complete?: (() => void) | null);
+}
+/**
+ * The observer used as a stub for subscriptions where the user did not
+ * pass any arguments to `subscribe`. Comes with the default error handling
+ * behavior.
+ */
+export declare const EMPTY_OBSERVER: Readonly<Observer<any>> & {
+    closed: true;
+};
+//# sourceMappingURL=Subscriber.d.ts.map

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

@@ -0,0 +1,96 @@
+import { SubscriptionLike, TeardownLogic } from './types';
+/**
+ * Represents a disposable resource, such as the execution of an Observable. A
+ * Subscription has one important method, `unsubscribe`, that takes no argument
+ * and just disposes the resource held by the subscription.
+ *
+ * Additionally, subscriptions may be grouped together through the `add()`
+ * method, which will attach a child Subscription to the current Subscription.
+ * When a Subscription is unsubscribed, all its children (and its grandchildren)
+ * will be unsubscribed as well.
+ *
+ * @class Subscription
+ */
+export declare class Subscription implements SubscriptionLike {
+    private initialTeardown?;
+    /** @nocollapse */
+    static EMPTY: Subscription;
+    /**
+     * A flag to indicate whether this Subscription has already been unsubscribed.
+     */
+    closed: boolean;
+    private _parentage;
+    /**
+     * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
+     * list occurs in the {@link #add} and {@link #remove} methods.
+     */
+    private _finalizers;
+    /**
+     * @param initialTeardown A function executed first as part of the finalization
+     * process that is kicked off when {@link #unsubscribe} is called.
+     */
+    constructor(initialTeardown?: (() => void) | undefined);
+    /**
+     * Disposes the resources held by the subscription. May, for instance, cancel
+     * an ongoing Observable execution or cancel any other type of work that
+     * started when the Subscription was created.
+     * @return {void}
+     */
+    unsubscribe(): void;
+    /**
+     * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
+     * when this subscription is unsubscribed. If this subscription is already {@link #closed},
+     * because it has already been unsubscribed, then whatever finalizer is passed to it
+     * will automatically be executed (unless the finalizer itself is also a closed subscription).
+     *
+     * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
+     * subscription to a any subscription will result in no operation. (A noop).
+     *
+     * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
+     * operation at all. (A noop).
+     *
+     * `Subscription` instances that are added to this instance will automatically remove themselves
+     * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
+     * will need to be removed manually with {@link #remove}
+     *
+     * @param teardown The finalization logic to add to this subscription.
+     */
+    add(teardown: TeardownLogic): void;
+    /**
+     * Checks to see if a this subscription already has a particular parent.
+     * This will signal that this subscription has already been added to the parent in question.
+     * @param parent the parent to check for
+     */
+    private _hasParent;
+    /**
+     * Adds a parent to this subscription so it can be removed from the parent if it
+     * unsubscribes on it's own.
+     *
+     * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
+     * @param parent The parent subscription to add
+     */
+    private _addParent;
+    /**
+     * Called on a child when it is removed via {@link #remove}.
+     * @param parent The parent to remove
+     */
+    private _removeParent;
+    /**
+     * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
+     *
+     * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
+     * from every other `Subscription` they have been added to. This means that using the `remove` method
+     * is not a common thing and should be used thoughtfully.
+     *
+     * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance
+     * more than once, you will need to call `remove` the same number of times to remove all instances.
+     *
+     * All finalizer instances are removed to free up memory upon unsubscription.
+     *
+     * @param teardown The finalizer to remove from this subscription
+     */
+    remove(teardown: Exclude<TeardownLogic, void>): void;
+}
+export declare const EMPTY_SUBSCRIPTION: Subscription;
+export declare function isSubscription(value: any): value is Subscription;
+//# sourceMappingURL=Subscription.d.ts.map

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

@@ -0,0 +1,73 @@
+import { Subscriber } from './Subscriber';
+import { ObservableNotification } from './types';
+/**
+ * The {@link GlobalConfig} object for RxJS. It is used to configure things
+ * like how to react on unhandled errors.
+ */
+export declare const config: GlobalConfig;
+/**
+ * The global configuration object for RxJS, used to configure things
+ * like how to react on unhandled errors. Accessible via {@link config}
+ * object.
+ */
+export interface GlobalConfig {
+    /**
+     * A registration point for unhandled errors from RxJS. These are errors that
+     * cannot were not handled by consuming code in the usual subscription path. For
+     * example, if you have this configured, and you subscribe to an observable without
+     * providing an error handler, errors from that subscription will end up here. This
+     * will _always_ be called asynchronously on another job in the runtime. This is because
+     * we do not want errors thrown in this user-configured handler to interfere with the
+     * behavior of the library.
+     */
+    onUnhandledError: ((err: any) => void) | null;
+    /**
+     * A registration point for notifications that cannot be sent to subscribers because they
+     * have completed, errored or have been explicitly unsubscribed. By default, next, complete
+     * and error notifications sent to stopped subscribers are noops. However, sometimes callers
+     * might want a different behavior. For example, with sources that attempt to report errors
+     * to stopped subscribers, a caller can configure RxJS to throw an unhandled error instead.
+     * This will _always_ be called asynchronously on another job in the runtime. This is because
+     * we do not want errors thrown in this user-configured handler to interfere with the
+     * behavior of the library.
+     */
+    onStoppedNotification: ((notification: ObservableNotification<any>, subscriber: Subscriber<any>) => void) | null;
+    /**
+     * The promise constructor used by default for {@link Observable#toPromise toPromise} and {@link Observable#forEach forEach}
+     * methods.
+     *
+     * @deprecated As of version 8, RxJS will no longer support this sort of injection of a
+     * Promise constructor. If you need a Promise implementation other than native promises,
+     * please polyfill/patch Promise as you see appropriate. Will be removed in v8.
+     */
+    Promise?: PromiseConstructorLike;
+    /**
+     * If true, turns on synchronous error rethrowing, which is a deprecated behavior
+     * in v6 and higher. This behavior enables bad patterns like wrapping a subscribe
+     * call in a try/catch block. It also enables producer interference, a nasty bug
+     * where a multicast can be broken for all observers by a downstream consumer with
+     * an unhandled error. DO NOT USE THIS FLAG UNLESS IT'S NEEDED TO BUY TIME
+     * FOR MIGRATION REASONS.
+     *
+     * @deprecated As of version 8, RxJS will no longer support synchronous throwing
+     * of unhandled errors. All errors will be thrown on a separate call stack to prevent bad
+     * behaviors described above. Will be removed in v8.
+     */
+    useDeprecatedSynchronousErrorHandling: boolean;
+    /**
+     * If true, enables an as-of-yet undocumented feature from v5: The ability to access
+     * `unsubscribe()` via `this` context in `next` functions created in observers passed
+     * to `subscribe`.
+     *
+     * This is being removed because the performance was severely problematic, and it could also cause
+     * issues when types other than POJOs are passed to subscribe as subscribers, as they will likely have
+     * their `this` context overwritten.
+     *
+     * @deprecated As of version 8, RxJS will no longer support altering the
+     * context of next functions provided as part of an observer to Subscribe. Instead,
+     * you will have access to a subscription or a signal or token that will allow you to do things like
+     * unsubscribe and test closed status. Will be removed in v8.
+     */
+    useDeprecatedNextContext: boolean;
+}
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1,7 @@
+import { Observable } from './Observable';
+export interface FirstValueFromConfig<T> {
+    defaultValue: T;
+}
+export declare function firstValueFrom<T, D>(source: Observable<T>, config: FirstValueFromConfig<D>): Promise<T | D>;
+export declare function firstValueFrom<T>(source: Observable<T>): Promise<T>;
+//# sourceMappingURL=firstValueFrom.d.ts.map

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

@@ -0,0 +1,7 @@
+import { Observable } from './Observable';
+export interface LastValueFromConfig<T> {
+    defaultValue: T;
+}
+export declare function lastValueFrom<T, D>(source: Observable<T>, config: LastValueFromConfig<D>): Promise<T | D>;
+export declare function lastValueFrom<T>(source: Observable<T>): Promise<T>;
+//# sourceMappingURL=lastValueFrom.d.ts.map

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

@@ -0,0 +1,42 @@
+import { Subject } from '../Subject';
+import { Observable } from '../Observable';
+import { Subscription } from '../Subscription';
+/**
+ * @class ConnectableObservable<T>
+ * @deprecated Will be removed in v8. Use {@link connectable} to create a connectable observable.
+ * If you are using the `refCount` method of `ConnectableObservable`, use the {@link share} operator
+ * instead.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export declare class ConnectableObservable<T> extends Observable<T> {
+    source: Observable<T>;
+    protected subjectFactory: () => Subject<T>;
+    protected _subject: Subject<T> | null;
+    protected _refCount: number;
+    protected _connection: Subscription | null;
+    /**
+     * @param source The source observable
+     * @param subjectFactory The factory that creates the subject used internally.
+     * @deprecated Will be removed in v8. Use {@link connectable} to create a connectable observable.
+     * `new ConnectableObservable(source, factory)` is equivalent to
+     * `connectable(source, { connector: factory })`.
+     * When the `refCount()` method is needed, the {@link share} operator should be used instead:
+     * `new ConnectableObservable(source, factory).refCount()` is equivalent to
+     * `source.pipe(share({ connector: factory }))`.
+     * Details: https://rxjs.dev/deprecations/multicasting
+     */
+    constructor(source: Observable<T>, subjectFactory: () => Subject<T>);
+    protected getSubject(): Subject<T>;
+    protected _teardown(): void;
+    /**
+     * @deprecated {@link ConnectableObservable} will be removed in v8. Use {@link connectable} instead.
+     * Details: https://rxjs.dev/deprecations/multicasting
+     */
+    connect(): Subscription;
+    /**
+     * @deprecated {@link ConnectableObservable} will be removed in v8. Use the {@link share} operator instead.
+     * Details: https://rxjs.dev/deprecations/multicasting
+     */
+    refCount(): Observable<T>;
+}
+//# sourceMappingURL=ConnectableObservable.d.ts.map

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

@@ -0,0 +1,5 @@
+import { SchedulerLike } from '../types';
+import { Observable } from '../Observable';
+export declare function bindCallback(callbackFunc: (...args: any[]) => void, resultSelector: (...args: any[]) => any, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>;
+export declare function bindCallback<A extends readonly unknown[], R extends readonly unknown[]>(callbackFunc: (...args: [...A, (...res: R) => void]) => void, schedulerLike?: SchedulerLike): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;
+//# sourceMappingURL=bindCallback.d.ts.map

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

@@ -0,0 +1,5 @@
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+export declare function bindNodeCallback(callbackFunc: (...args: any[]) => void, resultSelector: (...args: any[]) => any, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>;
+export declare function bindNodeCallback<A extends readonly unknown[], R extends readonly unknown[]>(callbackFunc: (...args: [...A, (err: any, ...res: R) => void]) => void, schedulerLike?: SchedulerLike): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;
+//# sourceMappingURL=bindNodeCallback.d.ts.map

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

@@ -0,0 +1,33 @@
+import { Observable } from '../Observable';
+import { ObservableInput, SchedulerLike, ObservedValueOf, ObservableInputTuple } from '../types';
+import { Subscriber } from '../Subscriber';
+import { AnyCatcher } from '../AnyCatcher';
+/**
+ * You have passed `any` here, we can't figure out if it is
+ * an array or an object, so you're getting `unknown`. Use better types.
+ * @param arg Something typed as `any`
+ */
+export declare function combineLatest<T extends AnyCatcher>(arg: T): Observable<unknown>;
+export declare function combineLatest(sources: []): Observable<never>;
+export declare function combineLatest<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<A>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[], R>(sources: readonly [...ObservableInputTuple<A>], resultSelector: (...values: A) => R, scheduler: SchedulerLike): Observable<R>;
+export declare function combineLatest<A extends readonly unknown[], R>(sources: readonly [...ObservableInputTuple<A>], resultSelector: (...values: A) => R): Observable<R>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>], scheduler: SchedulerLike): Observable<A>;
+/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */
+export declare function combineLatest<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[], R>(...sourcesAndResultSelectorAndScheduler: [...ObservableInputTuple<A>, (...values: A) => R, SchedulerLike]): Observable<R>;
+/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */
+export declare function combineLatest<A extends readonly unknown[], R>(...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R]): Observable<R>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[]>(...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike]): Observable<A>;
+export declare function combineLatest(sourcesObject: {
+    [K in any]: never;
+}): Observable<never>;
+export declare function combineLatest<T extends Record<string, ObservableInput<any>>>(sourcesObject: T): Observable<{
+    [K in keyof T]: ObservedValueOf<T[K]>;
+}>;
+export declare function combineLatestInit(observables: ObservableInput<any>[], scheduler?: SchedulerLike, valueTransform?: (values: any[]) => any): (subscriber: Subscriber<any>) => void;
+//# sourceMappingURL=combineLatest.d.ts.map

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

@@ -0,0 +1,5 @@
+import { Observable } from '../Observable';
+import { ObservableInputTuple, SchedulerLike } from '../types';
+export declare function concat<T extends readonly unknown[]>(...inputs: [...ObservableInputTuple<T>]): Observable<T[number]>;
+export declare function concat<T extends readonly unknown[]>(...inputsAndScheduler: [...ObservableInputTuple<T>, SchedulerLike]): Observable<T[number]>;
+//# sourceMappingURL=concat.d.ts.map

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

@@ -0,0 +1,27 @@
+import { Connectable, ObservableInput, SubjectLike } from '../types';
+export interface ConnectableConfig<T> {
+    /**
+     * A factory function used to create the Subject through which the source
+     * is multicast. By default this creates a {@link Subject}.
+     */
+    connector: () => SubjectLike<T>;
+    /**
+     * If true, the resulting observable will reset internal state upon disconnection
+     * and return to a "cold" state. This allows the resulting observable to be
+     * reconnected.
+     * If false, upon disconnection, the connecting subject will remain the
+     * connecting subject, meaning the resulting observable will not go "cold" again,
+     * and subsequent repeats or resubscriptions will resubscribe to that same subject.
+     */
+    resetOnDisconnect?: boolean;
+}
+/**
+ * Creates an observable that multicasts once `connect()` is called on it.
+ *
+ * @param source The observable source to make connectable.
+ * @param config The configuration object for `connectable`.
+ * @returns A "connectable" observable, that has a `connect()` method, that you must call to
+ * connect the source to all consumers through the subject provided as the connector.
+ */
+export declare function connectable<T>(source: ObservableInput<T>, config?: ConnectableConfig<T>): Connectable<T>;
+//# sourceMappingURL=connectable.d.ts.map

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

@@ -0,0 +1,52 @@
+import { Observable } from '../Observable';
+import { ObservedValueOf, ObservableInput } from '../types';
+/**
+ * Creates an Observable that, on subscribe, calls an Observable factory to
+ * make an Observable for each new Observer.
+ *
+ * <span class="informal">Creates the Observable lazily, that is, only when it
+ * is subscribed.
+ * </span>
+ *
+ * ![](defer.png)
+ *
+ * `defer` allows you to create an Observable only when the Observer
+ * subscribes. It waits until an Observer subscribes to it, calls the given
+ * factory function to get an Observable -- where a factory function typically
+ * generates a new Observable -- and subscribes the Observer to this Observable.
+ * In case the factory function returns a falsy value, then EMPTY is used as
+ * Observable instead. Last but not least, an exception during the factory
+ * function call is transferred to the Observer by calling `error`.
+ *
+ * ## Example
+ *
+ * Subscribe to either an Observable of clicks or an Observable of interval, at random
+ *
+ * ```ts
+ * import { defer, fromEvent, interval } from 'rxjs';
+ *
+ * const clicksOrInterval = defer(() => {
+ *   return Math.random() > 0.5
+ *     ? fromEvent(document, 'click')
+ *     : interval(1000);
+ * });
+ * clicksOrInterval.subscribe(x => console.log(x));
+ *
+ * // Results in the following behavior:
+ * // If the result of Math.random() is greater than 0.5 it will listen
+ * // for clicks anywhere on the "document"; when document is clicked it
+ * // will log a MouseEvent object to the console. If the result is less
+ * // than 0.5 it will emit ascending numbers, one every second(1000ms).
+ * ```
+ *
+ * @see {@link Observable}
+ *
+ * @param {function(): ObservableInput} observableFactory The Observable
+ * factory function to invoke for each Observer that subscribes to the output
+ * Observable. May also return a Promise, which will be converted on the fly
+ * to an Observable.
+ * @return {Observable} An Observable whose Observers' subscriptions trigger
+ * an invocation of the given Observable factory function.
+ */
+export declare function defer<R extends ObservableInput<any>>(observableFactory: () => R): Observable<ObservedValueOf<R>>;
+//# sourceMappingURL=defer.d.ts.map

package/dist/_types/rxjs/dist/types/internal/observable/dom/animationFrames.d.ts

@@ -0,0 +1,76 @@
+import { Observable } from '../../Observable';
+import { TimestampProvider } from '../../types';
+/**
+ * An observable of animation frames
+ *
+ * Emits the amount of time elapsed since subscription and the timestamp on each animation frame.
+ * Defaults to milliseconds provided to the requestAnimationFrame's callback. Does not end on its own.
+ *
+ * Every subscription will start a separate animation loop. Since animation frames are always scheduled
+ * by the browser to occur directly before a repaint, scheduling more than one animation frame synchronously
+ * should not be much different or have more overhead than looping over an array of events during
+ * a single animation frame. However, if for some reason the developer would like to ensure the
+ * execution of animation-related handlers are all executed during the same task by the engine,
+ * the `share` operator can be used.
+ *
+ * This is useful for setting up animations with RxJS.
+ *
+ * ## Examples
+ *
+ * Tweening a div to move it on the screen
+ *
+ * ```ts
+ * import { animationFrames, map, takeWhile, endWith } from 'rxjs';
+ *
+ * function tween(start: number, end: number, duration: number) {
+ *   const diff = end - start;
+ *   return animationFrames().pipe(
+ *     // Figure out what percentage of time has passed
+ *     map(({ elapsed }) => elapsed / duration),
+ *     // Take the vector while less than 100%
+ *     takeWhile(v => v < 1),
+ *     // Finish with 100%
+ *     endWith(1),
+ *     // Calculate the distance traveled between start and end
+ *     map(v => v * diff + start)
+ *   );
+ * }
+ *
+ * // Setup a div for us to move around
+ * const div = document.createElement('div');
+ * document.body.appendChild(div);
+ * div.style.position = 'absolute';
+ * div.style.width = '40px';
+ * div.style.height = '40px';
+ * div.style.backgroundColor = 'lime';
+ * div.style.transform = 'translate3d(10px, 0, 0)';
+ *
+ * tween(10, 200, 4000).subscribe(x => {
+ *   div.style.transform = `translate3d(${ x }px, 0, 0)`;
+ * });
+ * ```
+ *
+ * Providing a custom timestamp provider
+ *
+ * ```ts
+ * import { animationFrames, TimestampProvider } from 'rxjs';
+ *
+ * // A custom timestamp provider
+ * let now = 0;
+ * const customTSProvider: TimestampProvider = {
+ *   now() { return now++; }
+ * };
+ *
+ * const source$ = animationFrames(customTSProvider);
+ *
+ * // Log increasing numbers 0...1...2... on every animation frame.
+ * source$.subscribe(({ elapsed }) => console.log(elapsed));
+ * ```
+ *
+ * @param timestampProvider An object with a `now` method that provides a numeric timestamp
+ */
+export declare function animationFrames(timestampProvider?: TimestampProvider): Observable<{
+    timestamp: number;
+    elapsed: number;
+}>;
+//# sourceMappingURL=animationFrames.d.ts.map