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

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

@@ -0,0 +1,54 @@
+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.
+     *
+     * @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 that this Subject casts to.
+     */
+    asObservable(): Observable<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/compiled/inquirer/rxjs/internal/Subscriber.d.ts

@@ -0,0 +1,72 @@
+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.
+ */
+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.
+     * @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 value The `next` value.
+     */
+    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 err The `error` exception.
+     */
+    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.
+     */
+    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/compiled/inquirer/rxjs/internal/Subscription.d.ts

@@ -0,0 +1,92 @@
+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.
+ */
+export declare class Subscription implements SubscriptionLike {
+    private initialTeardown?;
+    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.
+     */
+    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/compiled/inquirer/rxjs/internal/ajax/AjaxResponse.d.ts

@@ -0,0 +1,115 @@
+import { AjaxRequest, AjaxResponseType } from './types';
+/**
+ * A normalized response from an AJAX request. To get the data from the response,
+ * you will want to read the `response` property.
+ *
+ * - DO NOT create instances of this class directly.
+ * - DO NOT subclass this class.
+ *
+ * It is advised not to hold this object in memory, as it has a reference to
+ * the original XHR used to make the request, as well as properties containing
+ * request and response data.
+ *
+ * @see {@link ajax}
+ * @see {@link AjaxConfig}
+ */
+export declare class AjaxResponse<T> {
+    /**
+     * The original event object from the raw XHR event.
+     */
+    readonly originalEvent: ProgressEvent;
+    /**
+     * The XMLHttpRequest object used to make the request.
+     * NOTE: It is advised not to hold this in memory, as it will retain references to all of it's event handlers
+     * and many other things related to the request.
+     */
+    readonly xhr: XMLHttpRequest;
+    /**
+     * The request parameters used to make the HTTP request.
+     */
+    readonly request: AjaxRequest;
+    /**
+     * The event type. This can be used to discern between different events
+     * if you're using progress events with {@link includeDownloadProgress} or
+     * {@link includeUploadProgress} settings in {@link AjaxConfig}.
+     *
+     * The event type consists of two parts: the {@link AjaxDirection} and the
+     * the event type. Merged with `_`, they form the `type` string. The
+     * direction can be an `upload` or a `download` direction, while an event can
+     * be `loadstart`, `progress` or `load`.
+     *
+     * `download_load` is the type of event when download has finished and the
+     * response is available.
+     */
+    readonly type: AjaxResponseType;
+    /** The HTTP status code */
+    readonly status: number;
+    /**
+     * The response data, if any. Note that this will automatically be converted to the proper type
+     */
+    readonly response: T;
+    /**
+     * The responseType set on the request. (For example: `""`, `"arraybuffer"`, `"blob"`, `"document"`, `"json"`, or `"text"`)
+     * @deprecated There isn't much reason to examine this. It's the same responseType set (or defaulted) on the ajax config.
+     * If you really need to examine this value, you can check it on the `request` or the `xhr`. Will be removed in v8.
+     */
+    readonly responseType: XMLHttpRequestResponseType;
+    /**
+     * The total number of bytes loaded so far. To be used with {@link total} while
+     * calculating progress. (You will want to set {@link includeDownloadProgress} or
+     * {@link includeDownloadProgress})
+     */
+    readonly loaded: number;
+    /**
+     * The total number of bytes to be loaded. To be used with {@link loaded} while
+     * calculating progress. (You will want to set {@link includeDownloadProgress} or
+     * {@link includeDownloadProgress})
+     */
+    readonly total: number;
+    /**
+     * A dictionary of the response headers.
+     */
+    readonly responseHeaders: Record<string, string>;
+    /**
+     * A normalized response from an AJAX request. To get the data from the response,
+     * you will want to read the `response` property.
+     *
+     * - DO NOT create instances of this class directly.
+     * - DO NOT subclass this class.
+     *
+     * @param originalEvent The original event object from the XHR `onload` event.
+     * @param xhr The `XMLHttpRequest` object used to make the request. This is useful for examining status code, etc.
+     * @param request The request settings used to make the HTTP request.
+     * @param type The type of the event emitted by the {@link ajax} Observable
+     */
+    constructor(
+    /**
+     * The original event object from the raw XHR event.
+     */
+    originalEvent: ProgressEvent, 
+    /**
+     * The XMLHttpRequest object used to make the request.
+     * NOTE: It is advised not to hold this in memory, as it will retain references to all of it's event handlers
+     * and many other things related to the request.
+     */
+    xhr: XMLHttpRequest, 
+    /**
+     * The request parameters used to make the HTTP request.
+     */
+    request: AjaxRequest, 
+    /**
+     * The event type. This can be used to discern between different events
+     * if you're using progress events with {@link includeDownloadProgress} or
+     * {@link includeUploadProgress} settings in {@link AjaxConfig}.
+     *
+     * The event type consists of two parts: the {@link AjaxDirection} and the
+     * the event type. Merged with `_`, they form the `type` string. The
+     * direction can be an `upload` or a `download` direction, while an event can
+     * be `loadstart`, `progress` or `load`.
+     *
+     * `download_load` is the type of event when download has finished and the
+     * response is available.
+     */
+    type?: AjaxResponseType);
+}
+//# sourceMappingURL=AjaxResponse.d.ts.map

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