/**
 * @fileoverview added by tsickle
 * Generated from: packages/common/http/src/response.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @license
 * Copyright Google Inc. All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { HttpHeaders } from './headers';
/** @enum {number} */
const HttpEventType = {
    /**
     * The request was sent out over the wire.
     */
    Sent: 0,
    /**
     * An upload progress event was received.
     */
    UploadProgress: 1,
    /**
     * The response status code and headers were received.
     */
    ResponseHeader: 2,
    /**
     * A download progress event was received.
     */
    DownloadProgress: 3,
    /**
     * The full response including the body was received.
     */
    Response: 4,
    /**
     * A custom event from an interceptor or a backend.
     */
    User: 5,
};
export { HttpEventType };
HttpEventType[HttpEventType.Sent] = 'Sent';
HttpEventType[HttpEventType.UploadProgress] = 'UploadProgress';
HttpEventType[HttpEventType.ResponseHeader] = 'ResponseHeader';
HttpEventType[HttpEventType.DownloadProgress] = 'DownloadProgress';
HttpEventType[HttpEventType.Response] = 'Response';
HttpEventType[HttpEventType.User] = 'User';
/**
 * Base interface for progress events.
 *
 * \@publicApi
 * @record
 */
export function HttpProgressEvent() { }
if (false) {
    /**
     * Progress event type is either upload or download.
     * @type {?}
     */
    HttpProgressEvent.prototype.type;
    /**
     * Number of bytes uploaded or downloaded.
     * @type {?}
     */
    HttpProgressEvent.prototype.loaded;
    /**
     * Total number of bytes to upload or download. Depending on the request or
     * response, this may not be computable and thus may not be present.
     * @type {?|undefined}
     */
    HttpProgressEvent.prototype.total;
}
/**
 * A download progress event.
 *
 * \@publicApi
 * @record
 */
export function HttpDownloadProgressEvent() { }
if (false) {
    /** @type {?} */
    HttpDownloadProgressEvent.prototype.type;
    /**
     * The partial response body as downloaded so far.
     *
     * Only present if the responseType was `text`.
     * @type {?|undefined}
     */
    HttpDownloadProgressEvent.prototype.partialText;
}
/**
 * An upload progress event.
 *
 * \@publicApi
 * @record
 */
export function HttpUploadProgressEvent() { }
if (false) {
    /** @type {?} */
    HttpUploadProgressEvent.prototype.type;
}
/**
 * An event indicating that the request was sent to the server. Useful
 * when a request may be retried multiple times, to distinguish between
 * retries on the final event stream.
 *
 * \@publicApi
 * @record
 */
export function HttpSentEvent() { }
if (false) {
    /** @type {?} */
    HttpSentEvent.prototype.type;
}
/**
 * A user-defined event.
 *
 * Grouping all custom events under this type ensures they will be handled
 * and forwarded by all implementations of interceptors.
 *
 * \@publicApi
 * @record
 * @template T
 */
export function HttpUserEvent() { }
if (false) {
    /** @type {?} */
    HttpUserEvent.prototype.type;
}
/**
 * An error that represents a failed attempt to JSON.parse text coming back
 * from the server.
 *
 * It bundles the Error object with the actual response body that failed to parse.
 *
 *
 * @record
 */
export function HttpJsonParseError() { }
if (false) {
    /** @type {?} */
    HttpJsonParseError.prototype.error;
    /** @type {?} */
    HttpJsonParseError.prototype.text;
}
/**
 * Base class for both `HttpResponse` and `HttpHeaderResponse`.
 *
 * \@publicApi
 * @abstract
 */
export class HttpResponseBase {
    /**
     * Super-constructor for all responses.
     *
     * The single parameter accepted is an initialization hash. Any properties
     * of the response passed there will override the default values.
     * @param {?} init
     * @param {?=} defaultStatus
     * @param {?=} defaultStatusText
     */
    constructor(init, defaultStatus = 200, defaultStatusText = 'OK') {
        // If the hash has values passed, use them to initialize the response.
        // Otherwise use the default values.
        this.headers = init.headers || new HttpHeaders();
        this.status = init.status !== undefined ? init.status : defaultStatus;
        this.statusText = init.statusText || defaultStatusText;
        this.url = init.url || null;
        // Cache the ok value to avoid defining a getter.
        this.ok = this.status >= 200 && this.status < 300;
    }
}
if (false) {
    /**
     * All response headers.
     * @type {?}
     */
    HttpResponseBase.prototype.headers;
    /**
     * Response status code.
     * @type {?}
     */
    HttpResponseBase.prototype.status;
    /**
     * Textual description of response status code.
     *
     * Do not depend on this.
     * @type {?}
     */
    HttpResponseBase.prototype.statusText;
    /**
     * URL of the resource retrieved, or null if not available.
     * @type {?}
     */
    HttpResponseBase.prototype.url;
    /**
     * Whether the status code falls in the 2xx range.
     * @type {?}
     */
    HttpResponseBase.prototype.ok;
    /**
     * Type of the response, narrowed to either the full response or the header.
     * @type {?}
     */
    HttpResponseBase.prototype.type;
}
/**
 * A partial HTTP response which only includes the status and header data,
 * but no response body.
 *
 * `HttpHeaderResponse` is a `HttpEvent` available on the response
 * event stream, only when progress events are requested.
 *
 * \@publicApi
 */
export class HttpHeaderResponse extends HttpResponseBase {
    /**
     * Create a new `HttpHeaderResponse` with the given parameters.
     * @param {?=} init
     */
    constructor(init = {}) {
        super(init);
        this.type = HttpEventType.ResponseHeader;
    }
    /**
     * Copy this `HttpHeaderResponse`, overriding its contents with the
     * given parameter hash.
     * @param {?=} update
     * @return {?}
     */
    clone(update = {}) {
        // Perform a straightforward initialization of the new HttpHeaderResponse,
        // overriding the current parameters with new ones if given.
        return new HttpHeaderResponse({
            headers: update.headers || this.headers,
            status: update.status !== undefined ? update.status : this.status,
            statusText: update.statusText || this.statusText,
            url: update.url || this.url || undefined,
        });
    }
}
if (false) {
    /** @type {?} */
    HttpHeaderResponse.prototype.type;
}
/**
 * A full HTTP response, including a typed response body (which may be `null`
 * if one was not returned).
 *
 * `HttpResponse` is a `HttpEvent` available on the response event
 * stream.
 *
 * \@publicApi
 * @template T
 */
export class HttpResponse extends HttpResponseBase {
    /**
     * Construct a new `HttpResponse`.
     * @param {?=} init
     */
    constructor(init = {}) {
        super(init);
        this.type = HttpEventType.Response;
        this.body = init.body !== undefined ? init.body : null;
    }
    /**
     * @param {?=} update
     * @return {?}
     */
    clone(update = {}) {
        return new HttpResponse({
            body: (update.body !== undefined) ? update.body : this.body,
            headers: update.headers || this.headers,
            status: (update.status !== undefined) ? update.status : this.status,
            statusText: update.statusText || this.statusText,
            url: update.url || this.url || undefined,
        });
    }
}
if (false) {
    /**
     * The response body, or `null` if one was not returned.
     * @type {?}
     */
    HttpResponse.prototype.body;
    /** @type {?} */
    HttpResponse.prototype.type;
}
/**
 * A response that represents an error or failure, either from a
 * non-successful HTTP status, an error while executing the request,
 * or some other failure which occurred during the parsing of the response.
 *
 * Any error returned on the `Observable` response stream will be
 * wrapped in an `HttpErrorResponse` to provide additional context about
 * the state of the HTTP layer when the error occurred. The error property
 * will contain either a wrapped Error object or the error response returned
 * from the server.
 *
 * \@publicApi
 */
export class HttpErrorResponse extends HttpResponseBase {
    /**
     * @param {?} init
     */
    constructor(init) {
        // Initialize with a default status of 0 / Unknown Error.
        super(init, 0, 'Unknown Error');
        this.name = 'HttpErrorResponse';
        /**
         * Errors are never okay, even when the status code is in the 2xx success range.
         */
        this.ok = false;
        // If the response was successful, then this was a parse error. Otherwise, it was
        // a protocol-level failure of some sort. Either the request failed in transit
        // or the server returned an unsuccessful status code.
        if (this.status >= 200 && this.status < 300) {
            this.message = `Http failure during parsing for ${init.url || '(unknown url)'}`;
        }
        else {
            this.message =
                `Http failure response for ${init.url || '(unknown url)'}: ${init.status} ${init.statusText}`;
        }
        this.error = init.error || null;
    }
}
if (false) {
    /** @type {?} */
    HttpErrorResponse.prototype.name;
    /** @type {?} */
    HttpErrorResponse.prototype.message;
    /** @type {?} */
    HttpErrorResponse.prototype.error;
    /**
     * Errors are never okay, even when the status code is in the 2xx success range.
     * @type {?}
     */
    HttpErrorResponse.prototype.ok;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/response.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {HttpHeaders} from './headers';\n\n/**\n * Type enumeration for the different kinds of `HttpEvent`.\n *\n * @publicApi\n */\nexport enum HttpEventType {\n  /**\n   * The request was sent out over the wire.\n   */\n  Sent,\n\n  /**\n   * An upload progress event was received.\n   */\n  UploadProgress,\n\n  /**\n   * The response status code and headers were received.\n   */\n  ResponseHeader,\n\n  /**\n   * A download progress event was received.\n   */\n  DownloadProgress,\n\n  /**\n   * The full response including the body was received.\n   */\n  Response,\n\n  /**\n   * A custom event from an interceptor or a backend.\n   */\n  User,\n}\n\n/**\n * Base interface for progress events.\n *\n * @publicApi\n */\nexport interface HttpProgressEvent {\n  /**\n   * Progress event type is either upload or download.\n   */\n  type: HttpEventType.DownloadProgress|HttpEventType.UploadProgress;\n\n  /**\n   * Number of bytes uploaded or downloaded.\n   */\n  loaded: number;\n\n  /**\n   * Total number of bytes to upload or download. Depending on the request or\n   * response, this may not be computable and thus may not be present.\n   */\n  total?: number;\n}\n\n/**\n * A download progress event.\n *\n * @publicApi\n */\nexport interface HttpDownloadProgressEvent extends HttpProgressEvent {\n  type: HttpEventType.DownloadProgress;\n\n  /**\n   * The partial response body as downloaded so far.\n   *\n   * Only present if the responseType was `text`.\n   */\n  partialText?: string;\n}\n\n/**\n * An upload progress event.\n *\n * @publicApi\n */\nexport interface HttpUploadProgressEvent extends HttpProgressEvent {\n  type: HttpEventType.UploadProgress;\n}\n\n/**\n * An event indicating that the request was sent to the server. Useful\n * when a request may be retried multiple times, to distinguish between\n * retries on the final event stream.\n *\n * @publicApi\n */\nexport interface HttpSentEvent { type: HttpEventType.Sent; }\n\n/**\n * A user-defined event.\n *\n * Grouping all custom events under this type ensures they will be handled\n * and forwarded by all implementations of interceptors.\n *\n * @publicApi\n */\nexport interface HttpUserEvent<T> { type: HttpEventType.User; }\n\n/**\n * An error that represents a failed attempt to JSON.parse text coming back\n * from the server.\n *\n * It bundles the Error object with the actual response body that failed to parse.\n *\n *\n */\nexport interface HttpJsonParseError {\n  error: Error;\n  text: string;\n}\n\n/**\n * Union type for all possible events on the response stream.\n *\n * Typed according to the expected type of the response.\n *\n * @publicApi\n */\nexport type HttpEvent<T> =\n    HttpSentEvent | HttpHeaderResponse | HttpResponse<T>| HttpProgressEvent | HttpUserEvent<T>;\n\n/**\n * Base class for both `HttpResponse` and `HttpHeaderResponse`.\n *\n * @publicApi\n */\nexport abstract class HttpResponseBase {\n  /**\n   * All response headers.\n   */\n  readonly headers: HttpHeaders;\n\n  /**\n   * Response status code.\n   */\n  readonly status: number;\n\n  /**\n   * Textual description of response status code.\n   *\n   * Do not depend on this.\n   */\n  readonly statusText: string;\n\n  /**\n   * URL of the resource retrieved, or null if not available.\n   */\n  readonly url: string|null;\n\n  /**\n   * Whether the status code falls in the 2xx range.\n   */\n  readonly ok: boolean;\n\n  /**\n   * Type of the response, narrowed to either the full response or the header.\n   */\n  // TODO(issue/24571): remove '!'.\n  readonly type !: HttpEventType.Response | HttpEventType.ResponseHeader;\n\n  /**\n   * Super-constructor for all responses.\n   *\n   * The single parameter accepted is an initialization hash. Any properties\n   * of the response passed there will override the default values.\n   */\n  constructor(\n      init: {\n        headers?: HttpHeaders,\n        status?: number,\n        statusText?: string,\n        url?: string,\n      },\n      defaultStatus: number = 200, defaultStatusText: string = 'OK') {\n    // If the hash has values passed, use them to initialize the response.\n    // Otherwise use the default values.\n    this.headers = init.headers || new HttpHeaders();\n    this.status = init.status !== undefined ? init.status : defaultStatus;\n    this.statusText = init.statusText || defaultStatusText;\n    this.url = init.url || null;\n\n    // Cache the ok value to avoid defining a getter.\n    this.ok = this.status >= 200 && this.status < 300;\n  }\n}\n\n/**\n * A partial HTTP response which only includes the status and header data,\n * but no response body.\n *\n * `HttpHeaderResponse` is a `HttpEvent` available on the response\n * event stream, only when progress events are requested.\n *\n * @publicApi\n */\nexport class HttpHeaderResponse extends HttpResponseBase {\n  /**\n   * Create a new `HttpHeaderResponse` with the given parameters.\n   */\n  constructor(init: {\n    headers?: HttpHeaders,\n    status?: number,\n    statusText?: string,\n    url?: string,\n  } = {}) {\n    super(init);\n  }\n\n  readonly type: HttpEventType.ResponseHeader = HttpEventType.ResponseHeader;\n\n  /**\n   * Copy this `HttpHeaderResponse`, overriding its contents with the\n   * given parameter hash.\n   */\n  clone(update: {headers?: HttpHeaders; status?: number; statusText?: string; url?: string;} = {}):\n      HttpHeaderResponse {\n    // Perform a straightforward initialization of the new HttpHeaderResponse,\n    // overriding the current parameters with new ones if given.\n    return new HttpHeaderResponse({\n      headers: update.headers || this.headers,\n      status: update.status !== undefined ? update.status : this.status,\n      statusText: update.statusText || this.statusText,\n      url: update.url || this.url || undefined,\n    });\n  }\n}\n\n/**\n * A full HTTP response, including a typed response body (which may be `null`\n * if one was not returned).\n *\n * `HttpResponse` is a `HttpEvent` available on the response event\n * stream.\n *\n * @publicApi\n */\nexport class HttpResponse<T> extends HttpResponseBase {\n  /**\n   * The response body, or `null` if one was not returned.\n   */\n  readonly body: T|null;\n\n  /**\n   * Construct a new `HttpResponse`.\n   */\n  constructor(init: {\n    body?: T | null, headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  } = {}) {\n    super(init);\n    this.body = init.body !== undefined ? init.body : null;\n  }\n\n  readonly type: HttpEventType.Response = HttpEventType.Response;\n\n  clone(): HttpResponse<T>;\n  clone(update: {headers?: HttpHeaders; status?: number; statusText?: string; url?: string;}):\n      HttpResponse<T>;\n  clone<V>(update: {\n    body?: V | null, headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  }): HttpResponse<V>;\n  clone(update: {\n    body?: any | null; headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  } = {}): HttpResponse<any> {\n    return new HttpResponse<any>({\n      body: (update.body !== undefined) ? update.body : this.body,\n      headers: update.headers || this.headers,\n      status: (update.status !== undefined) ? update.status : this.status,\n      statusText: update.statusText || this.statusText,\n      url: update.url || this.url || undefined,\n    });\n  }\n}\n\n/**\n * A response that represents an error or failure, either from a\n * non-successful HTTP status, an error while executing the request,\n * or some other failure which occurred during the parsing of the response.\n *\n * Any error returned on the `Observable` response stream will be\n * wrapped in an `HttpErrorResponse` to provide additional context about\n * the state of the HTTP layer when the error occurred. The error property\n * will contain either a wrapped Error object or the error response returned\n * from the server.\n *\n * @publicApi\n */\nexport class HttpErrorResponse extends HttpResponseBase implements Error {\n  readonly name = 'HttpErrorResponse';\n  readonly message: string;\n  readonly error: any|null;\n\n  /**\n   * Errors are never okay, even when the status code is in the 2xx success range.\n   */\n  readonly ok = false;\n\n  constructor(init: {\n    error?: any; headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  }) {\n    // Initialize with a default status of 0 / Unknown Error.\n    super(init, 0, 'Unknown Error');\n\n    // If the response was successful, then this was a parse error. Otherwise, it was\n    // a protocol-level failure of some sort. Either the request failed in transit\n    // or the server returned an unsuccessful status code.\n    if (this.status >= 200 && this.status < 300) {\n      this.message = `Http failure during parsing for ${init.url || '(unknown url)'}`;\n    } else {\n      this.message =\n          `Http failure response for ${init.url || '(unknown url)'}: ${init.status} ${init.statusText}`;\n    }\n    this.error = init.error || null;\n  }\n}\n"]}