@bleedingdev/modern-js-utils 3.9.0-ultramodern.2 → 3.9.0-ultramodern.3

package/dist/compiled/inquirer/rxjs/internal/ajax/ajax.d.ts

@@ -0,0 +1,227 @@
+import { Observable } from '../Observable';
+import { AjaxConfig } from './types';
+import { AjaxResponse } from './AjaxResponse';
+export interface AjaxCreationMethod {
+    /**
+     * Creates an observable that will perform an AJAX request using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope by default.
+     *
+     * This is the most configurable option, and the basis for all other AJAX calls in the library.
+     *
+     * ## Example
+     *
+     * ```ts
+     * import { ajax } from 'rxjs/ajax';
+     * import { map, catchError, of } from '../..';
+     *
+     * const obs$ = ajax({
+     *   method: 'GET',
+     *   url: 'https://api.github.com/users?per_page=5',
+     *   responseType: 'json'
+     * }).pipe(
+     *   map(userResponse => console.log('users: ', userResponse)),
+     *   catchError(error => {
+     *     console.log('error: ', error);
+     *     return of(error);
+     *   })
+     * );
+     * ```
+     */
+    <T>(config: AjaxConfig): Observable<AjaxResponse<T>>;
+    /**
+     * Perform an HTTP GET using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope. Defaults to a `responseType` of `"json"`.
+     *
+     * ## Example
+     *
+     * ```ts
+     * import { ajax } from 'rxjs/ajax';
+     * import { map, catchError, of } from '../..';
+     *
+     * const obs$ = ajax('https://api.github.com/users?per_page=5').pipe(
+     *   map(userResponse => console.log('users: ', userResponse)),
+     *   catchError(error => {
+     *     console.log('error: ', error);
+     *     return of(error);
+     *   })
+     * );
+     * ```
+     */
+    <T>(url: string): Observable<AjaxResponse<T>>;
+    /**
+     * Performs an HTTP GET using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope by default, and a `responseType` of `"json"`.
+     *
+     * @param url The URL to get the resource from
+     * @param headers Optional headers. Case-Insensitive.
+     */
+    get<T>(url: string, headers?: Record<string, string>): Observable<AjaxResponse<T>>;
+    /**
+     * Performs an HTTP POST using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope by default, and a `responseType` of `"json"`.
+     *
+     * Before sending the value passed to the `body` argument, it is automatically serialized
+     * based on the specified `responseType`. By default, a JavaScript object will be serialized
+     * to JSON. A `responseType` of `application/x-www-form-urlencoded` will flatten any provided
+     * dictionary object to a url-encoded string.
+     *
+     * @param url The URL to get the resource from
+     * @param body The content to send. The body is automatically serialized.
+     * @param headers Optional headers. Case-Insensitive.
+     */
+    post<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>>;
+    /**
+     * Performs an HTTP PUT using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope by default, and a `responseType` of `"json"`.
+     *
+     * Before sending the value passed to the `body` argument, it is automatically serialized
+     * based on the specified `responseType`. By default, a JavaScript object will be serialized
+     * to JSON. A `responseType` of `application/x-www-form-urlencoded` will flatten any provided
+     * dictionary object to a url-encoded string.
+     *
+     * @param url The URL to get the resource from
+     * @param body The content to send. The body is automatically serialized.
+     * @param headers Optional headers. Case-Insensitive.
+     */
+    put<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>>;
+    /**
+     * Performs an HTTP PATCH using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope by default, and a `responseType` of `"json"`.
+     *
+     * Before sending the value passed to the `body` argument, it is automatically serialized
+     * based on the specified `responseType`. By default, a JavaScript object will be serialized
+     * to JSON. A `responseType` of `application/x-www-form-urlencoded` will flatten any provided
+     * dictionary object to a url-encoded string.
+     *
+     * @param url The URL to get the resource from
+     * @param body The content to send. The body is automatically serialized.
+     * @param headers Optional headers. Case-Insensitive.
+     */
+    patch<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>>;
+    /**
+     * Performs an HTTP DELETE using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope by default, and a `responseType` of `"json"`.
+     *
+     * @param url The URL to get the resource from
+     * @param headers Optional headers. Case-Insensitive.
+     */
+    delete<T>(url: string, headers?: Record<string, string>): Observable<AjaxResponse<T>>;
+    /**
+     * Performs an HTTP GET using the
+     * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in
+     * global scope by default, and returns the hydrated JavaScript object from the
+     * response.
+     *
+     * @param url The URL to get the resource from
+     * @param headers Optional headers. Case-Insensitive.
+     */
+    getJSON<T>(url: string, headers?: Record<string, string>): Observable<T>;
+}
+/**
+ * There is an ajax operator on the Rx object.
+ *
+ * It creates an observable for an Ajax request with either a request object with
+ * url, headers, etc or a string for a URL.
+ *
+ * ## Examples
+ *
+ * Using `ajax()` to fetch the response object that is being returned from API
+ *
+ * ```ts
+ * import { ajax } from 'rxjs/ajax';
+ * import { map, catchError, of } from '../..';
+ *
+ * const obs$ = ajax('https://api.github.com/users?per_page=5').pipe(
+ *   map(userResponse => console.log('users: ', userResponse)),
+ *   catchError(error => {
+ *     console.log('error: ', error);
+ *     return of(error);
+ *   })
+ * );
+ *
+ * obs$.subscribe({
+ *   next: value => console.log(value),
+ *   error: err => console.log(err)
+ * });
+ * ```
+ *
+ * Using `ajax.getJSON()` to fetch data from API
+ *
+ * ```ts
+ * import { ajax } from 'rxjs/ajax';
+ * import { map, catchError, of } from '../..';
+ *
+ * const obs$ = ajax.getJSON('https://api.github.com/users?per_page=5').pipe(
+ *   map(userResponse => console.log('users: ', userResponse)),
+ *   catchError(error => {
+ *     console.log('error: ', error);
+ *     return of(error);
+ *   })
+ * );
+ *
+ * obs$.subscribe({
+ *   next: value => console.log(value),
+ *   error: err => console.log(err)
+ * });
+ * ```
+ *
+ * Using `ajax()` with object as argument and method POST with a two seconds delay
+ *
+ * ```ts
+ * import { ajax } from 'rxjs/ajax';
+ * import { map, catchError, of } from '../..';
+ *
+ * const users = ajax({
+ *   url: 'https://httpbin.org/delay/2',
+ *   method: 'POST',
+ *   headers: {
+ *     'Content-Type': 'application/json',
+ *     'rxjs-custom-header': 'Rxjs'
+ *   },
+ *   body: {
+ *     rxjs: 'Hello World!'
+ *   }
+ * }).pipe(
+ *   map(response => console.log('response: ', response)),
+ *   catchError(error => {
+ *     console.log('error: ', error);
+ *     return of(error);
+ *   })
+ * );
+ *
+ * users.subscribe({
+ *   next: value => console.log(value),
+ *   error: err => console.log(err)
+ * });
+ * ```
+ *
+ * Using `ajax()` to fetch. An error object that is being returned from the request
+ *
+ * ```ts
+ * import { ajax } from 'rxjs/ajax';
+ * import { map, catchError, of } from '../..';
+ *
+ * const obs$ = ajax('https://api.github.com/404').pipe(
+ *   map(userResponse => console.log('users: ', userResponse)),
+ *   catchError(error => {
+ *     console.log('error: ', error);
+ *     return of(error);
+ *   })
+ * );
+ *
+ * obs$.subscribe({
+ *   next: value => console.log(value),
+ *   error: err => console.log(err)
+ * });
+ * ```
+ */
+export declare const ajax: AjaxCreationMethod;
+export declare function fromAjax<T>(init: AjaxConfig): Observable<AjaxResponse<T>>;
+//# sourceMappingURL=ajax.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/ajax/errors.d.ts

@@ -0,0 +1,65 @@
+import { AjaxRequest } from './types';
+/**
+ * A normalized AJAX error.
+ *
+ * @see {@link ajax}
+ */
+export interface AjaxError extends Error {
+    /**
+     * The XHR instance associated with the error.
+     */
+    xhr: XMLHttpRequest;
+    /**
+     * The AjaxRequest associated with the error.
+     */
+    request: AjaxRequest;
+    /**
+     * The HTTP status code, if the request has completed. If not,
+     * it is set to `0`.
+     */
+    status: number;
+    /**
+     * The responseType (e.g. 'json', 'arraybuffer', or 'xml').
+     */
+    responseType: XMLHttpRequestResponseType;
+    /**
+     * The response data.
+     */
+    response: any;
+}
+export interface AjaxErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;
+}
+/**
+ * Thrown when an error occurs during an AJAX request.
+ * This is only exported because it is useful for checking to see if an error
+ * is an `instanceof AjaxError`. DO NOT create new instances of `AjaxError` with
+ * the constructor.
+ *
+ * @see {@link ajax}
+ */
+export declare const AjaxError: AjaxErrorCtor;
+export interface AjaxTimeoutError extends AjaxError {
+}
+export interface AjaxTimeoutErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;
+}
+/**
+ * Thrown when an AJAX request times out. Not to be confused with {@link TimeoutError}.
+ *
+ * This is exported only because it is useful for checking to see if errors are an
+ * `instanceof AjaxTimeoutError`. DO NOT use the constructor to create an instance of
+ * this type.
+ *
+ * @see {@link ajax}
+ */
+export declare const AjaxTimeoutError: AjaxTimeoutErrorCtor;
+//# sourceMappingURL=errors.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/ajax/getXHRResponse.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gets what should be in the `response` property of the XHR. However,
+ * since we still support the final versions of IE, we need to do a little
+ * checking here to make sure that we get the right thing back. Consequently,
+ * we need to do a JSON.parse() in here, which *could* throw if the response
+ * isn't valid JSON.
+ *
+ * This is used both in creating an AjaxResponse, and in creating certain errors
+ * that we throw, so we can give the user whatever was in the response property.
+ *
+ * @param xhr The XHR to examine the response of
+ */
+export declare function getXHRResponse(xhr: XMLHttpRequest): any;
+//# sourceMappingURL=getXHRResponse.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/ajax/types.d.ts

@@ -0,0 +1,200 @@
+import { PartialObserver } from '../types';
+/**
+ * Valid Ajax direction types. Prefixes the event `type` in the
+ * {@link AjaxResponse} object with "upload_" for events related
+ * to uploading and "download_" for events related to downloading.
+ */
+export declare type AjaxDirection = 'upload' | 'download';
+export declare type ProgressEventType = 'loadstart' | 'progress' | 'load';
+export declare type AjaxResponseType = `${AjaxDirection}_${ProgressEventType}`;
+/**
+ * The object containing values RxJS used to make the HTTP request.
+ *
+ * This is provided in {@link AjaxError} instances as the `request`
+ * object.
+ */
+export interface AjaxRequest {
+    /**
+     * The URL requested.
+     */
+    url: string;
+    /**
+     * The body to send over the HTTP request.
+     */
+    body?: any;
+    /**
+     * The HTTP method used to make the HTTP request.
+     */
+    method: string;
+    /**
+     * Whether or not the request was made asynchronously.
+     */
+    async: boolean;
+    /**
+     * The headers sent over the HTTP request.
+     */
+    headers: Readonly<Record<string, any>>;
+    /**
+     * The timeout value used for the HTTP request.
+     * Note: this is only honored if the request is asynchronous (`async` is `true`).
+     */
+    timeout: number;
+    /**
+     * The user credentials user name sent with the HTTP request.
+     */
+    user?: string;
+    /**
+     * The user credentials password sent with the HTTP request.
+     */
+    password?: string;
+    /**
+     * Whether or not the request was a CORS request.
+     */
+    crossDomain: boolean;
+    /**
+     * Whether or not a CORS request was sent with credentials.
+     * If `false`, will also ignore cookies in the CORS response.
+     */
+    withCredentials: boolean;
+    /**
+     * The [`responseType`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType) set before sending the request.
+     */
+    responseType: XMLHttpRequestResponseType;
+}
+/**
+ * Configuration for the {@link ajax} creation function.
+ */
+export interface AjaxConfig {
+    /** The address of the resource to request via HTTP. */
+    url: string;
+    /**
+     * The body of the HTTP request to send.
+     *
+     * This is serialized, by default, based off of the value of the `"content-type"` header.
+     * For example, if the `"content-type"` is `"application/json"`, the body will be serialized
+     * as JSON. If the `"content-type"` is `"application/x-www-form-urlencoded"`, whatever object passed
+     * to the body will be serialized as URL, using key-value pairs based off of the keys and values of the object.
+     * In all other cases, the body will be passed directly.
+     */
+    body?: any;
+    /**
+     * Whether or not to send the request asynchronously. Defaults to `true`.
+     * If set to `false`, this will block the thread until the AJAX request responds.
+     */
+    async?: boolean;
+    /**
+     * The HTTP Method to use for the request. Defaults to "GET".
+     */
+    method?: string;
+    /**
+     * The HTTP headers to apply.
+     *
+     * Note that, by default, RxJS will add the following headers under certain conditions:
+     *
+     * 1. If the `"content-type"` header is **NOT** set, and the `body` is [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData),
+     *    a `"content-type"` of `"application/x-www-form-urlencoded; charset=UTF-8"` will be set automatically.
+     * 2. If the `"x-requested-with"` header is **NOT** set, and the `crossDomain` configuration property is **NOT** explicitly set to `true`,
+     *    (meaning it is not a CORS request), a `"x-requested-with"` header with a value of `"XMLHttpRequest"` will be set automatically.
+     *    This header is generally meaningless, and is set by libraries and frameworks using `XMLHttpRequest` to make HTTP requests.
+     */
+    headers?: Readonly<Record<string, any>>;
+    /**
+     * The time to wait before causing the underlying XMLHttpRequest to timeout. This is only honored if the
+     * `async` configuration setting is unset or set to `true`. Defaults to `0`, which is idiomatic for "never timeout".
+     */
+    timeout?: number;
+    /** The user credentials user name to send with the HTTP request */
+    user?: string;
+    /** The user credentials password to send with the HTTP request*/
+    password?: string;
+    /**
+     * Whether or not to send the HTTP request as a CORS request.
+     * Defaults to `false`.
+     *
+     * @deprecated Will be removed in version 8. Cross domain requests and what creates a cross
+     * domain request, are dictated by the browser, and a boolean that forces it to be cross domain
+     * does not make sense. If you need to force cross domain, make sure you're making a secure request,
+     * then add a custom header to the request or use `withCredentials`. For more information on what
+     * triggers a cross domain request, see the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials).
+     * In particular, the section on [Simple Requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#Simple_requests) is useful
+     * for understanding when CORS will not be used.
+     */
+    crossDomain?: boolean;
+    /**
+     * To send user credentials in a CORS request, set to `true`. To exclude user credentials from
+     * a CORS request, _OR_ when cookies are to be ignored by the CORS response, set to `false`.
+     *
+     * Defaults to `false`.
+     */
+    withCredentials?: boolean;
+    /**
+     * The name of your site's XSRF cookie.
+     */
+    xsrfCookieName?: string;
+    /**
+     * The name of a custom header that you can use to send your XSRF cookie.
+     */
+    xsrfHeaderName?: string;
+    /**
+     * Can be set to change the response type.
+     * Valid values are `"arraybuffer"`, `"blob"`, `"document"`, `"json"`, and `"text"`.
+     * Note that the type of `"document"` (such as an XML document) is ignored if the global context is
+     * not `Window`.
+     *
+     * Defaults to `"json"`.
+     */
+    responseType?: XMLHttpRequestResponseType;
+    /**
+     * An optional factory used to create the XMLHttpRequest object used to make the AJAX request.
+     * This is useful in environments that lack `XMLHttpRequest`, or in situations where you
+     * wish to override the default `XMLHttpRequest` for some reason.
+     *
+     * If not provided, the `XMLHttpRequest` in global scope will be used.
+     *
+     * NOTE: This AJAX implementation relies on the built-in serialization and setting
+     * of Content-Type headers that is provided by standards-compliant XMLHttpRequest implementations,
+     * be sure any implementation you use meets that standard.
+     */
+    createXHR?: () => XMLHttpRequest;
+    /**
+     * An observer for watching the upload progress of an HTTP request. Will
+     * emit progress events, and completes on the final upload load event, will error for
+     * any XHR error or timeout.
+     *
+     * This will **not** error for errored status codes. Rather, it will always _complete_ when
+     * the HTTP response comes back.
+     *
+     * @deprecated If you're looking for progress events, use {@link includeDownloadProgress} and
+     * {@link includeUploadProgress} instead. Will be removed in v8.
+     */
+    progressSubscriber?: PartialObserver<ProgressEvent>;
+    /**
+     * If `true`, will emit all download progress and load complete events as {@link AjaxResponse}
+     * from the observable. The final download event will also be emitted as a {@link AjaxResponse}.
+     *
+     * If both this and {@link includeUploadProgress} are `false`, then only the {@link AjaxResponse} will
+     * be emitted from the resulting observable.
+     */
+    includeDownloadProgress?: boolean;
+    /**
+     * If `true`, will emit all upload progress and load complete events as {@link AjaxResponse}
+     * from the observable. The final download event will also be emitted as a {@link AjaxResponse}.
+     *
+     * If both this and {@link includeDownloadProgress} are `false`, then only the {@link AjaxResponse} will
+     * be emitted from the resulting observable.
+     */
+    includeUploadProgress?: boolean;
+    /**
+     * Query string parameters to add to the URL in the request.
+     * <em>This will require a polyfill for `URL` and `URLSearchParams` in Internet Explorer!</em>
+     *
+     * Accepts either a query string, a `URLSearchParams` object, a dictionary of key/value pairs, or an
+     * array of key/value entry tuples. (Essentially, it takes anything that `new URLSearchParams` would normally take).
+     *
+     * If, for some reason you have a query string in the `url` argument, this will append to the query string in the url,
+     * but it will also overwrite the value of any keys that are an exact match. In other words, a url of `/test?a=1&b=2`,
+     * with queryParams of `{ b: 5, c: 6 }` will result in a url of roughly `/test?a=1&b=5&c=6`.
+     */
+    queryParams?: string | URLSearchParams | Record<string, string | number | boolean | string[] | number[] | boolean[]> | [string, string | number | boolean | string[] | number[] | boolean[]][];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/compiled/inquirer/rxjs/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/compiled/inquirer/rxjs/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/compiled/inquirer/rxjs/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/compiled/inquirer/rxjs/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/compiled/inquirer/rxjs/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/compiled/inquirer/rxjs/internal/observable/bindCallbackInternals.d.ts

@@ -0,0 +1,4 @@
+import { SchedulerLike } from '../types';
+import { Observable } from '../Observable';
+export declare function bindCallbackInternals(isNodeStyle: boolean, callbackFunc: any, resultSelector?: any, scheduler?: SchedulerLike): (...args: any[]) => Observable<unknown>;
+//# sourceMappingURL=bindCallbackInternals.d.ts.map

package/dist/compiled/inquirer/rxjs/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