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

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

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

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

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

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

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

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

@@ -1,53 +0,0 @@
-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;
- * }
- * ```
- *
- * @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 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 work A function representing a task, or some unit of work to be
-     * executed by the Scheduler.
-     * @param delay Time to wait before executing the work, where the time unit is
-     * implicit and defined by the Scheduler itself.
-     * @param state Some contextual data that the `work` function uses when called
-     * by the Scheduler.
-     * @return 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/compiled/inquirer/rxjs/internal/Subject.d.ts

@@ -1,54 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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