client.js

/**
 * @fileoverview added by tsickle
 * Generated from: packages/common/http/src/client.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 { Injectable } from '@angular/core';
import { of } from 'rxjs';
import { concatMap, filter, map } from 'rxjs/operators';
import { HttpHandler } from './backend';
import { HttpHeaders } from './headers';
import { HttpParams } from './params';
import { HttpRequest } from './request';
import { HttpResponse } from './response';
/**
 * Constructs an instance of `HttpRequestOptions<T>` from a source `HttpMethodOptions` and
 * the given `body`. This function clones the object and adds the body.
 *
 * Note that the `responseType` *options* value is a String that identifies the
 * single data type of the response.
 * A single overload version of the method handles each response type.
 * The value of `responseType` cannot be a union, as the combined signature could imply.
 *
 * @template T
 * @param {?} options
 * @param {?} body
 * @return {?}
 */
function addBody(options, body) {
    return {
        body,
        headers: options.headers,
        observe: options.observe,
        params: options.params,
        reportProgress: options.reportProgress,
        responseType: options.responseType,
        withCredentials: options.withCredentials,
    };
}
/**
 * Performs HTTP requests.
 * This service is available as an injectable class, with methods to perform HTTP requests.
 * Each request method has multiple signatures, and the return type varies based on
 * the signature that is called (mainly the values of `observe` and `responseType`).
 *
 * Note that the `responseType` *options* value is a String that identifies the
 * single data type of the response.
 * A single overload version of the method handles each response type.
 * The value of `responseType` cannot be a union, as the combined signature could imply.
 *
 * \@usageNotes
 * Sample HTTP requests for the [Tour of Heroes](/tutorial/toh-pt0) application.
 *
 * ### HTTP Request Example
 *
 * ```
 *  // GET heroes whose name contains search term
 * searchHeroes(term: string): observable<Hero[]>{
 *
 *  const params = new HttpParams({fromString: 'name=term'});
 *    return this.httpClient.request('GET', this.heroesUrl, {responseType:'json', params});
 * }
 * ```
 * ### JSONP Example
 * ```
 * requestJsonp(url, callback = 'callback') {
 *  return this.httpClient.jsonp(this.heroesURL, callback);
 * }
 * ```
 *
 * ### PATCH Example
 * ```
 * // PATCH one of the heroes' name
 * patchHero (id: number, heroName: string): Observable<{}> {
 * const url = `${this.heroesUrl}/${id}`;   // PATCH api/heroes/42
 *  return this.httpClient.patch(url, {name: heroName}, httpOptions)
 *    .pipe(catchError(this.handleError('patchHero')));
 * }
 * ```
 *
 * @see [HTTP Guide](guide/http)
 *
 * \@publicApi
 */
export class HttpClient {
    /**
     * @param {?} handler
     */
    constructor(handler) {
        this.handler = handler;
    }
    /**
     * Constructs an observable for a generic HTTP request that, when subscribed,
     * fires the request through the chain of registered interceptors and on to the
     * server.
     *
     * You can pass an `HttpRequest` directly as the only parameter. In this case,
     * the call returns an observable of the raw `HttpEvent` stream.
     *
     * Alternatively you can pass an HTTP method as the first parameter,
     * a URL string as the second, and an options hash containing the request body as the third.
     * See `addBody()`. In this case, the specified `responseType` and `observe` options determine the
     * type of returned observable.
     *   * The `responseType` value determines how a successful response body is parsed.
     *   * If `responseType` is the default `json`, you can pass a type interface for the resulting
     * object as a type parameter to the call.
     *
     * The `observe` value determines the return type, according to what you are interested in
     * observing.
     *   * An `observe` value of events returns an observable of the raw `HttpEvent` stream, including
     * progress events by default.
     *   * An `observe` value of response returns an observable of `HttpResponse<T>`,
     * where the `T` parameter depends on the `responseType` and any optionally provided type
     * parameter.
     *   * An `observe` value of body returns an observable of `<T>` with the same `T` body type.
     *
     * @param {?} first
     * @param {?=} url
     * @param {?=} options
     * @return {?}
     */
    request(first, url, options = {}) {
        /** @type {?} */
        let req;
        // First, check whether the primary argument is an instance of `HttpRequest`.
        if (first instanceof HttpRequest) {
            // It is. The other arguments must be undefined (per the signatures) and can be
            // ignored.
            req = first;
        }
        else {
            // It's a string, so it represents a URL. Construct a request based on it,
            // and incorporate the remaining arguments (assuming `GET` unless a method is
            // provided.
            // Figure out the headers.
            /** @type {?} */
            let headers = undefined;
            if (options.headers instanceof HttpHeaders) {
                headers = options.headers;
            }
            else {
                headers = new HttpHeaders(options.headers);
            }
            // Sort out parameters.
            /** @type {?} */
            let params = undefined;
            if (!!options.params) {
                if (options.params instanceof HttpParams) {
                    params = options.params;
                }
                else {
                    params = new HttpParams((/** @type {?} */ ({ fromObject: options.params })));
                }
            }
            // Construct the request.
            req = new HttpRequest(first, (/** @type {?} */ (url)), (options.body !== undefined ? options.body : null), {
                headers,
                params,
                reportProgress: options.reportProgress,
                // By default, JSON is assumed to be returned for all calls.
                responseType: options.responseType || 'json',
                withCredentials: options.withCredentials,
            });
        }
        // Start with an Observable.of() the initial request, and run the handler (which
        // includes all interceptors) inside a concatMap(). This way, the handler runs
        // inside an Observable chain, which causes interceptors to be re-run on every
        // subscription (this also makes retries re-run the handler, including interceptors).
        /** @type {?} */
        const events$ = of(req).pipe(concatMap((/**
         * @param {?} req
         * @return {?}
         */
        (req) => this.handler.handle(req))));
        // If coming via the API signature which accepts a previously constructed HttpRequest,
        // the only option is to get the event stream. Otherwise, return the event stream if
        // that is what was requested.
        if (first instanceof HttpRequest || options.observe === 'events') {
            return events$;
        }
        // The requested stream contains either the full response or the body. In either
        // case, the first step is to filter the event stream to extract a stream of
        // responses(s).
        /** @type {?} */
        const res$ = (/** @type {?} */ (events$.pipe(filter((/**
         * @param {?} event
         * @return {?}
         */
        (event) => event instanceof HttpResponse)))));
        // Decide which stream to return.
        switch (options.observe || 'body') {
            case 'body':
                // The requested stream is the body. Map the response stream to the response
                // body. This could be done more simply, but a misbehaving interceptor might
                // transform the response body into a different format and ignore the requested
                // responseType. Guard against this by validating that the response is of the
                // requested type.
                switch (req.responseType) {
                    case 'arraybuffer':
                        return res$.pipe(map((/**
                         * @param {?} res
                         * @return {?}
                         */
                        (res) => {
                            // Validate that the body is an ArrayBuffer.
                            if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
                                throw new Error('Response is not an ArrayBuffer.');
                            }
                            return res.body;
                        })));
                    case 'blob':
                        return res$.pipe(map((/**
                         * @param {?} res
                         * @return {?}
                         */
                        (res) => {
                            // Validate that the body is a Blob.
                            if (res.body !== null && !(res.body instanceof Blob)) {
                                throw new Error('Response is not a Blob.');
                            }
                            return res.body;
                        })));
                    case 'text':
                        return res$.pipe(map((/**
                         * @param {?} res
                         * @return {?}
                         */
                        (res) => {
                            // Validate that the body is a string.
                            if (res.body !== null && typeof res.body !== 'string') {
                                throw new Error('Response is not a string.');
                            }
                            return res.body;
                        })));
                    case 'json':
                    default:
                        // No validation needed for JSON responses, as they can be of any type.
                        return res$.pipe(map((/**
                         * @param {?} res
                         * @return {?}
                         */
                        (res) => res.body)));
                }
            case 'response':
                // The response stream was requested directly, so return it.
                return res$;
            default:
                // Guard against new future observe types being added.
                throw new Error(`Unreachable: unhandled observe type ${options.observe}}`);
        }
    }
    /**
     * Constructs an observable that, when subscribed, causes the configured
     * `DELETE` request to execute on the server. See the individual overloads for
     * details on the return type.
     *
     * @param {?} url     The endpoint URL.
     * @param {?=} options The HTTP options to send with the request.
     *
     * @return {?}
     */
    delete(url, options = {}) {
        return this.request('DELETE', url, (/** @type {?} */ (options)));
    }
    /**
     * Constructs an observable that, when subscribed, causes the configured
     * `GET` request to execute on the server. See the individual overloads for
     * details on the return type.
     * @param {?} url
     * @param {?=} options
     * @return {?}
     */
    get(url, options = {}) {
        return this.request('GET', url, (/** @type {?} */ (options)));
    }
    /**
     * Constructs an observable that, when subscribed, causes the configured
     * `HEAD` request to execute on the server. The `HEAD` method returns
     * meta information about the resource without transferring the
     * resource itself. See the individual overloads for
     * details on the return type.
     * @param {?} url
     * @param {?=} options
     * @return {?}
     */
    head(url, options = {}) {
        return this.request('HEAD', url, (/** @type {?} */ (options)));
    }
    /**
     * Constructs an `Observable` that, when subscribed, causes a request with the special method
     * `JSONP` to be dispatched via the interceptor pipeline.
     * The [JSONP pattern](https://en.wikipedia.org/wiki/JSONP) works around limitations of certain
     * API endpoints that don't support newer,
     * and preferable [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) protocol.
     * JSONP treats the endpoint API as a JavaScript file and tricks the browser to process the
     * requests even if the API endpoint is not located on the same domain (origin) as the client-side
     * application making the request.
     * The endpoint API must support JSONP callback for JSONP requests to work.
     * The resource API returns the JSON response wrapped in a callback function.
     * You can pass the callback function name as one of the query parameters.
     * Note that JSONP requests can only be used with `GET` requests.
     *
     * @template T
     * @param {?} url The resource URL.
     * @param {?} callbackParam The callback function name.
     *
     * @return {?}
     */
    jsonp(url, callbackParam) {
        return this.request('JSONP', url, {
            params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),
            observe: 'body',
            responseType: 'json',
        });
    }
    /**
     * Constructs an `Observable` that, when subscribed, causes the configured
     * `OPTIONS` request to execute on the server. This method allows the client
     * to determine the supported HTTP methods and other capabilites of an endpoint,
     * without implying a resource action. See the individual overloads for
     * details on the return type.
     * @param {?} url
     * @param {?=} options
     * @return {?}
     */
    options(url, options = {}) {
        return this.request('OPTIONS', url, (/** @type {?} */ (options)));
    }
    /**
     * Constructs an observable that, when subscribed, causes the configured
     * `PATCH` request to execute on the server. See the individual overloads for
     * details on the return type.
     * @param {?} url
     * @param {?} body
     * @param {?=} options
     * @return {?}
     */
    patch(url, body, options = {}) {
        return this.request('PATCH', url, addBody(options, body));
    }
    /**
     * Constructs an observable that, when subscribed, causes the configured
     * `POST` request to execute on the server. The server responds with the location of
     * the replaced resource. See the individual overloads for
     * details on the return type.
     * @param {?} url
     * @param {?} body
     * @param {?=} options
     * @return {?}
     */
    post(url, body, options = {}) {
        return this.request('POST', url, addBody(options, body));
    }
    /**
     * Constructs an observable that, when subscribed, causes the configured
     * `PUT` request to execute on the server. The `PUT` method replaces an existing resource
     * with a new set of values.
     * See the individual overloads for details on the return type.
     * @param {?} url
     * @param {?} body
     * @param {?=} options
     * @return {?}
     */
    put(url, body, options = {}) {
        return this.request('PUT', url, addBody(options, body));
    }
}
HttpClient.decorators = [
    { type: Injectable }
];
/** @nocollapse */
HttpClient.ctorParameters = () => [
    { type: HttpHandler }
];
if (false) {
    /**
     * @type {?}
     * @private
     */
    HttpClient.prototype.handler;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/client.ts"],"names":[],"mappings":";;;;;;;;;;;;AAQA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAa,EAAE,EAAC,MAAM,MAAM,CAAC;AACpC,OAAO,EAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;AAEtD,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AACtC,OAAO,EAAC,UAAU,EAAoB,MAAM,UAAU,CAAC;AACvD,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AACtC,OAAO,EAAY,YAAY,EAAC,MAAM,YAAY,CAAC;;;;;;;;;;;;;;;AAanD,SAAS,OAAO,CACZ,OAOC,EACD,IAAY;IACd,OAAO;QACL,IAAI;QACJ,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,YAAY,EAAE,OAAO,CAAC,YAAY;QAClC,eAAe,EAAE,OAAO,CAAC,eAAe;KACzC,CAAC;AACJ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDD,MAAM,OAAO,UAAU;;;;IACrB,YAAoB,OAAoB;QAApB,YAAO,GAAP,OAAO,CAAa;IAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsV5C,OAAO,CAAC,KAA8B,EAAE,GAAY,EAAE,UAQlD,EAAE;;YACA,GAAqB;QACzB,6EAA6E;QAC7E,IAAI,KAAK,YAAY,WAAW,EAAE;YAChC,+EAA+E;YAC/E,WAAW;YACX,GAAG,GAAG,KAAK,CAAC;SACb;aAAM;;;;;;gBAMD,OAAO,GAA0B,SAAS;YAC9C,IAAI,OAAO,CAAC,OAAO,YAAY,WAAW,EAAE;gBAC1C,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;aAC3B;iBAAM;gBACL,OAAO,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;aAC5C;;;gBAGG,MAAM,GAAyB,SAAS;YAC5C,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE;gBACpB,IAAI,OAAO,CAAC,MAAM,YAAY,UAAU,EAAE;oBACxC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;iBACzB;qBAAM;oBACL,MAAM,GAAG,IAAI,UAAU,CAAC,mBAAA,EAAC,UAAU,EAAE,OAAO,CAAC,MAAM,EAAC,EAAqB,CAAC,CAAC;iBAC5E;aACF;YAED,yBAAyB;YACzB,GAAG,GAAG,IAAI,WAAW,CAAC,KAAK,EAAE,mBAAA,GAAG,EAAC,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE;gBACrF,OAAO;gBACP,MAAM;gBACN,cAAc,EAAE,OAAO,CAAC,cAAc;;gBAEtC,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,MAAM;gBAC5C,eAAe,EAAE,OAAO,CAAC,eAAe;aACzC,CAAC,CAAC;SACJ;;;;;;cAMK,OAAO,GACT,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS;;;;QAAC,CAAC,GAAqB,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAC,CAAC;QAEhF,sFAAsF;QACtF,oFAAoF;QACpF,8BAA8B;QAC9B,IAAI,KAAK,YAAY,WAAW,IAAI,OAAO,CAAC,OAAO,KAAK,QAAQ,EAAE;YAChE,OAAO,OAAO,CAAC;SAChB;;;;;cAKK,IAAI,GAAkC,mBAA+B,OAAO,CAAC,IAAI,CACnF,MAAM;;;;QAAC,CAAC,KAAqB,EAAE,EAAE,CAAC,KAAK,YAAY,YAAY,EAAC,CAAC,EAAA;QAErE,iCAAiC;QACjC,QAAQ,OAAO,CAAC,OAAO,IAAI,MAAM,EAAE;YACjC,KAAK,MAAM;gBACT,4EAA4E;gBAC5E,4EAA4E;gBAC5E,+EAA+E;gBAC/E,6EAA6E;gBAC7E,kBAAkB;gBAClB,QAAQ,GAAG,CAAC,YAAY,EAAE;oBACxB,KAAK,aAAa;wBAChB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG;;;;wBAAC,CAAC,GAAsB,EAAE,EAAE;4BAC9C,4CAA4C;4BAC5C,IAAI,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,YAAY,WAAW,CAAC,EAAE;gCAC3D,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;6BACpD;4BACD,OAAO,GAAG,CAAC,IAAI,CAAC;wBAClB,CAAC,EAAC,CAAC,CAAC;oBACN,KAAK,MAAM;wBACT,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG;;;;wBAAC,CAAC,GAAsB,EAAE,EAAE;4BAC9C,oCAAoC;4BACpC,IAAI,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,YAAY,IAAI,CAAC,EAAE;gCACpD,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;6BAC5C;4BACD,OAAO,GAAG,CAAC,IAAI,CAAC;wBAClB,CAAC,EAAC,CAAC,CAAC;oBACN,KAAK,MAAM;wBACT,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG;;;;wBAAC,CAAC,GAAsB,EAAE,EAAE;4BAC9C,sCAAsC;4BACtC,IAAI,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE;gCACrD,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;6BAC9C;4BACD,OAAO,GAAG,CAAC,IAAI,CAAC;wBAClB,CAAC,EAAC,CAAC,CAAC;oBACN,KAAK,MAAM,CAAC;oBACZ;wBACE,uEAAuE;wBACvE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG;;;;wBAAC,CAAC,GAAsB,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAC,CAAC,CAAC;iBAC/D;YACH,KAAK,UAAU;gBACb,4DAA4D;gBAC5D,OAAO,IAAI,CAAC;YACd;gBACE,sDAAsD;gBACtD,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,CAAC,OAAO,GAAG,CAAC,CAAC;SAC9E;IACH,CAAC;;;;;;;;;;;IA6QD,MAAM,CAAC,GAAW,EAAE,UAOhB,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAM,QAAQ,EAAE,GAAG,EAAE,mBAAA,OAAO,EAAO,CAAC,CAAC;IAC1D,CAAC;;;;;;;;;IA0QD,GAAG,CAAC,GAAW,EAAE,UAOb,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAM,KAAK,EAAE,GAAG,EAAE,mBAAA,OAAO,EAAO,CAAC,CAAC;IACvD,CAAC;;;;;;;;;;;IAiRD,IAAI,CAAC,GAAW,EAAE,UAOd,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAM,MAAM,EAAE,GAAG,EAAE,mBAAA,OAAO,EAAO,CAAC,CAAC;IACxD,CAAC;;;;;;;;;;;;;;;;;;;;;IA4CD,KAAK,CAAI,GAAW,EAAE,aAAqB;QACzC,OAAO,IAAI,CAAC,OAAO,CAAM,OAAO,EAAE,GAAG,EAAE;YACrC,MAAM,EAAE,IAAI,UAAU,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,gBAAgB,CAAC;YAChE,OAAO,EAAE,MAAM;YACf,YAAY,EAAE,MAAM;SACrB,CAAC,CAAC;IACL,CAAC;;;;;;;;;;;IA8QD,OAAO,CAAC,GAAW,EAAE,UAOjB,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAM,SAAS,EAAE,GAAG,EAAE,mBAAA,OAAO,EAAO,CAAC,CAAC;IAC3D,CAAC;;;;;;;;;;IA6RD,KAAK,CAAC,GAAW,EAAE,IAAc,EAAE,UAO/B,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAM,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IACjE,CAAC;;;;;;;;;;;IA6RD,IAAI,CAAC,GAAW,EAAE,IAAc,EAAE,UAO9B,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAM,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IAChE,CAAC;;;;;;;;;;;IA2RD,GAAG,CAAC,GAAW,EAAE,IAAc,EAAE,UAO7B,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAM,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IAC/D,CAAC;;;YAt8EF,UAAU;;;;YAtFH,WAAW;;;;;;;IAwFL,6BAA4B","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 {Injectable} from '@angular/core';\nimport {Observable, of} from 'rxjs';\nimport {concatMap, filter, map} from 'rxjs/operators';\n\nimport {HttpHandler} from './backend';\nimport {HttpHeaders} from './headers';\nimport {HttpParams, HttpParamsOptions} from './params';\nimport {HttpRequest} from './request';\nimport {HttpEvent, HttpResponse} from './response';\n\n\n/**\n * Constructs an instance of `HttpRequestOptions<T>` from a source `HttpMethodOptions` and\n * the given `body`. This function clones the object and adds the body.\n *\n * Note that the `responseType` *options* value is a String that identifies the\n * single data type of the response.\n * A single overload version of the method handles each response type.\n * The value of `responseType` cannot be a union, as the combined signature could imply.\n *\n */\nfunction addBody<T>(\n    options: {\n      headers?: HttpHeaders|{[header: string]: string | string[]},\n      observe?: HttpObserve,\n      params?: HttpParams|{[param: string]: string | string[]},\n      reportProgress?: boolean,\n      responseType?: 'arraybuffer'|'blob'|'json'|'text',\n      withCredentials?: boolean,\n    },\n    body: T|null): any {\n  return {\n    body,\n    headers: options.headers,\n    observe: options.observe,\n    params: options.params,\n    reportProgress: options.reportProgress,\n    responseType: options.responseType,\n    withCredentials: options.withCredentials,\n  };\n}\n\nexport type HttpObserve = 'body'|'events'|'response';\n\n/**\n * Performs HTTP requests.\n * This service is available as an injectable class, with methods to perform HTTP requests.\n * Each request method has multiple signatures, and the return type varies based on\n * the signature that is called (mainly the values of `observe` and `responseType`).\n *\n * Note that the `responseType` *options* value is a String that identifies the\n * single data type of the response.\n * A single overload version of the method handles each response type.\n * The value of `responseType` cannot be a union, as the combined signature could imply.\n\n *\n * @usageNotes\n * Sample HTTP requests for the [Tour of Heroes](/tutorial/toh-pt0) application.\n *\n * ### HTTP Request Example\n *\n * ```\n *  // GET heroes whose name contains search term\n * searchHeroes(term: string): observable<Hero[]>{\n *\n *  const params = new HttpParams({fromString: 'name=term'});\n *    return this.httpClient.request('GET', this.heroesUrl, {responseType:'json', params});\n * }\n * ```\n * ### JSONP Example\n * ```\n * requestJsonp(url, callback = 'callback') {\n *  return this.httpClient.jsonp(this.heroesURL, callback);\n * }\n * ```\n *\n * ### PATCH Example\n * ```\n * // PATCH one of the heroes' name\n * patchHero (id: number, heroName: string): Observable<{}> {\n * const url = `${this.heroesUrl}/${id}`;   // PATCH api/heroes/42\n *  return this.httpClient.patch(url, {name: heroName}, httpOptions)\n *    .pipe(catchError(this.handleError('patchHero')));\n * }\n * ```\n *\n * @see [HTTP Guide](guide/http)\n *\n * @publicApi\n */\n@Injectable()\nexport class HttpClient {\n  constructor(private handler: HttpHandler) {}\n\n  /**\n   * Sends an `HTTPRequest` and returns a stream of `HTTPEvents`.\n   *\n   * @return An `Observable` of the response, with the response body as a stream of `HTTPEvents`.\n   */\n  request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;\n\n  /**\n   * Constructs a request that interprets the body as an `ArrayBuffer` and returns the response in\n   * an `ArrayBuffer`.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   *\n   * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Constructs a request that interprets the body as a blob and returns\n   * the response as a blob.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type `Blob`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs a request that interprets the body as a text string and\n   * returns a string value.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type string.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs a request that interprets the body as an `ArrayBuffer` and returns the\n   * the full event stream.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body as an array of `HTTPEvents` for\n   *     the\n   * request.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    params?: HttpParams|{[param: string]: string | string[]}, observe: 'events',\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs a request that interprets the body as a `Blob` and returns\n   * the full event stream.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of of all `HttpEvents` for the request,\n   * with the response body of type `Blob`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs a request which interprets the body as a text string and returns the full event\n   * stream.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HttpEvents` for the reques,\n   * with the response body of type string.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs a request which interprets the body as a JSON object and returns the full event\n   * stream.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the  request.\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   *  with the response body of type `Object`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    reportProgress?: boolean, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<any>>;\n\n  /**\n   * Constructs a request which interprets the body as a JSON object and returns the full event\n   * stream.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with the response body of type `R`.\n   */\n  request<R>(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    reportProgress?: boolean, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<R>>;\n\n  /**\n   * Constructs a request which interprets the body as an `ArrayBuffer`\n   * and returns the full `HTTPResponse`.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with the response body as an `ArrayBuffer`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs a request which interprets the body as a `Blob` and returns the full `HTTPResponse`.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with the response body of type `Blob`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs a request which interprets the body as a text stream and returns the full\n   * `HTTPResponse`.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the HTTP response, with the response body of type string.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs a request which interprets the body as a JSON object and returns the full\n   * `HTTPResponse`.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the full `HTTPResponse`,\n   * with the response body of type `Object`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    reportProgress?: boolean, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs a request which interprets the body as a JSON object and returns\n   * the full `HTTPResponse` with the response body in the requested type.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return  An `Observable` of the full `HTTPResponse`, with the response body of type `R`.\n   */\n  request<R>(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    reportProgress?: boolean, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<R>>;\n\n  /**\n   * Constructs a request which interprets the body as a JSON object and returns the full\n   * `HTTPResponse` as a JSON object.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with the response body of type `Object`.\n   */\n  request(method: string, url: string, options?: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    responseType?: 'json',\n    reportProgress?: boolean,\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs a request which interprets the body as a JSON object\n   * with the response body of the requested type.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with the response body of type `R`.\n   */\n  request<R>(method: string, url: string, options?: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    responseType?: 'json',\n    reportProgress?: boolean,\n    withCredentials?: boolean,\n  }): Observable<R>;\n\n  /**\n   * Constructs a request where response type and requested observable are not known statically.\n   *\n   * @param method  The HTTP method.\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the reuested response, wuth body of type `any`.\n   */\n  request(method: string, url: string, options?: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    params?: HttpParams|{[param: string]: string | string[]},\n    observe?: HttpObserve,\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  }): Observable<any>;\n\n  /**\n   * Constructs an observable for a generic HTTP request that, when subscribed,\n   * fires the request through the chain of registered interceptors and on to the\n   * server.\n   *\n   * You can pass an `HttpRequest` directly as the only parameter. In this case,\n   * the call returns an observable of the raw `HttpEvent` stream.\n   *\n   * Alternatively you can pass an HTTP method as the first parameter,\n   * a URL string as the second, and an options hash containing the request body as the third.\n   * See `addBody()`. In this case, the specified `responseType` and `observe` options determine the\n   * type of returned observable.\n   *   * The `responseType` value determines how a successful response body is parsed.\n   *   * If `responseType` is the default `json`, you can pass a type interface for the resulting\n   * object as a type parameter to the call.\n   *\n   * The `observe` value determines the return type, according to what you are interested in\n   * observing.\n   *   * An `observe` value of events returns an observable of the raw `HttpEvent` stream, including\n   * progress events by default.\n   *   * An `observe` value of response returns an observable of `HttpResponse<T>`,\n   * where the `T` parameter depends on the `responseType` and any optionally provided type\n   * parameter.\n   *   * An `observe` value of body returns an observable of `<T>` with the same `T` body type.\n   *\n   */\n  request(first: string|HttpRequest<any>, url?: string, options: {\n    body?: any,\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    let req: HttpRequest<any>;\n    // First, check whether the primary argument is an instance of `HttpRequest`.\n    if (first instanceof HttpRequest) {\n      // It is. The other arguments must be undefined (per the signatures) and can be\n      // ignored.\n      req = first;\n    } else {\n      // It's a string, so it represents a URL. Construct a request based on it,\n      // and incorporate the remaining arguments (assuming `GET` unless a method is\n      // provided.\n\n      // Figure out the headers.\n      let headers: HttpHeaders|undefined = undefined;\n      if (options.headers instanceof HttpHeaders) {\n        headers = options.headers;\n      } else {\n        headers = new HttpHeaders(options.headers);\n      }\n\n      // Sort out parameters.\n      let params: HttpParams|undefined = undefined;\n      if (!!options.params) {\n        if (options.params instanceof HttpParams) {\n          params = options.params;\n        } else {\n          params = new HttpParams({fromObject: options.params} as HttpParamsOptions);\n        }\n      }\n\n      // Construct the request.\n      req = new HttpRequest(first, url!, (options.body !== undefined ? options.body : null), {\n        headers,\n        params,\n        reportProgress: options.reportProgress,\n        // By default, JSON is assumed to be returned for all calls.\n        responseType: options.responseType || 'json',\n        withCredentials: options.withCredentials,\n      });\n    }\n\n    // Start with an Observable.of() the initial request, and run the handler (which\n    // includes all interceptors) inside a concatMap(). This way, the handler runs\n    // inside an Observable chain, which causes interceptors to be re-run on every\n    // subscription (this also makes retries re-run the handler, including interceptors).\n    const events$: Observable<HttpEvent<any>> =\n        of(req).pipe(concatMap((req: HttpRequest<any>) => this.handler.handle(req)));\n\n    // If coming via the API signature which accepts a previously constructed HttpRequest,\n    // the only option is to get the event stream. Otherwise, return the event stream if\n    // that is what was requested.\n    if (first instanceof HttpRequest || options.observe === 'events') {\n      return events$;\n    }\n\n    // The requested stream contains either the full response or the body. In either\n    // case, the first step is to filter the event stream to extract a stream of\n    // responses(s).\n    const res$: Observable<HttpResponse<any>> = <Observable<HttpResponse<any>>>events$.pipe(\n        filter((event: HttpEvent<any>) => event instanceof HttpResponse));\n\n    // Decide which stream to return.\n    switch (options.observe || 'body') {\n      case 'body':\n        // The requested stream is the body. Map the response stream to the response\n        // body. This could be done more simply, but a misbehaving interceptor might\n        // transform the response body into a different format and ignore the requested\n        // responseType. Guard against this by validating that the response is of the\n        // requested type.\n        switch (req.responseType) {\n          case 'arraybuffer':\n            return res$.pipe(map((res: HttpResponse<any>) => {\n              // Validate that the body is an ArrayBuffer.\n              if (res.body !== null && !(res.body instanceof ArrayBuffer)) {\n                throw new Error('Response is not an ArrayBuffer.');\n              }\n              return res.body;\n            }));\n          case 'blob':\n            return res$.pipe(map((res: HttpResponse<any>) => {\n              // Validate that the body is a Blob.\n              if (res.body !== null && !(res.body instanceof Blob)) {\n                throw new Error('Response is not a Blob.');\n              }\n              return res.body;\n            }));\n          case 'text':\n            return res$.pipe(map((res: HttpResponse<any>) => {\n              // Validate that the body is a string.\n              if (res.body !== null && typeof res.body !== 'string') {\n                throw new Error('Response is not a string.');\n              }\n              return res.body;\n            }));\n          case 'json':\n          default:\n            // No validation needed for JSON responses, as they can be of any type.\n            return res$.pipe(map((res: HttpResponse<any>) => res.body));\n        }\n      case 'response':\n        // The response stream was requested directly, so return it.\n        return res$;\n      default:\n        // Guard against new future observe types being added.\n        throw new Error(`Unreachable: unhandled observe type ${options.observe}}`);\n    }\n  }\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`\n   *  and returns the response as an `ArrayBuffer`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return  An `Observable` of the response body as an `ArrayBuffer`.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a `Blob` and returns\n   * the response as a `Blob`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response body as a `Blob`.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a text string and returns\n   * a string.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type string.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`\n   *  and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HTTPEvents` for the request,\n   * with response body as an `ArrayBuffer`.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a `Blob`\n   *  and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all the `HTTPEvents` for the request, with the response body as a\n   * `Blob`.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a text string\n   * and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HTTPEvents` for the request, with the response\n   *  body of type string.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a JSON object\n   * and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HTTPEvents` for the request, with response body of\n   * type `Object`.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Constructs a `DELETE`request that interprets the body as a JSON object\n   * and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all the `HTTPEvents` for the request, with a response\n   * body in the requested type.\n   */\n  delete<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer` and returns\n   *  the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the full `HTTPResponse`, with the response body as an `ArrayBuffer`.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a `Blob` and returns the full\n   * `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with the response body of type `Blob`.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a text stream and\n   *  returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the full `HTTPResponse`, with the response body of type string.\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs a `DELETE` request the interprets the body as a JSON object and returns\n   * the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with the response body of type `Object`.\n   *\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a JSON object\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with the response body of the requested type.\n   */\n  delete<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Constructs a `DELETE` request that interprets the body as a JSON object and\n   * returns the response body as a JSON object.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type `Object`.\n   */\n  delete(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs a DELETE request that interprets the body as a JSON object and returns\n   * the response in a given type.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with response body in the requested type.\n   */\n  delete<T>(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n\n  /**\n   * Constructs an observable that, when subscribed, causes the configured\n   * `DELETE` request to execute on the server. See the individual overloads for\n   * details on the return type.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   */\n  delete(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('DELETE', url, options as any);\n  }\n\n\n  /**\n   * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the\n   * response in an `ArrayBuffer`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a `Blob`\n   * and returns the response as a `Blob`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body as a `Blob`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a text string\n   * and returns the response as a string value.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type string.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns\n   *  the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HttpEvents` for the request, with the response\n   * body as an `ArrayBuffer`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a `Blob` and\n   * returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body as a `Blob`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a text string and returns\n   * the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type string.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a JSON object\n   * and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type `Object`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a JSON object and returns the full event\n   * stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with a response body in the requested type.\n   */\n  get<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and\n   * returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a `Blob` and\n   * returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   *  with the response body as a `Blob`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a text stream and\n   * returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body of type string.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a JSON object and\n   * returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the full `HttpResponse`,\n   * with the response body of type `Object`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a JSON object and\n   * returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the full `HTTPResponse` for the request,\n   * with a response body in the requested type.\n   */\n  get<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a JSON object and\n   * returns the response body as a JSON object.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   *\n   * @return An `Observable` of the response body as a JSON object.\n   */\n  get(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs a `GET` request that interprets the body as a JSON object and returns\n   * the response body in a given type.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with a response body in the requested type.\n   */\n  get<T>(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n\n  /**\n   * Constructs an observable that, when subscribed, causes the configured\n   * `GET` request to execute on the server. See the individual overloads for\n   * details on the return type.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('GET', url, options as any);\n  }\n\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and\n   * returns the response as an `ArrayBuffer`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a `Blob` and returns\n   * the response as a `Blob`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return  An `Observable` of the response, with the response body as a `Blob`.\n   */\n\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a text string and returns the response\n   * as a string value.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body of type string.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as an  `ArrayBuffer`\n   *  and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of tall `HttpEvents` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a `Blob` and\n   * returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with the response body as a `Blob`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a text string\n   * and returns the full event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all HttpEvents for the request, with the response body of type\n   *     string.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a JSON object\n   * and returns the full HTTP event stream.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of all `HTTPEvents` for the request, with a response body of\n   * type `Object`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a JSON object and\n   * returns the full event stream.\n   *\n   * @return An `Observable` of all the `HTTPEvents` for the request\n   * , with a response body in the requested type.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   */\n  head<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer`\n   *  and returns the full HTTP response.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a `Blob` and returns\n   * the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body as a blob.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as text stream\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body of type string.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a JSON object and\n   * returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body of type `Object`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a JSON object\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with a responmse body of the requested type.\n   */\n  head<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a JSON object and\n   * returns the response body as a JSON object.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the response, with the response body as a JSON object.\n   */\n  head(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs a `HEAD` request that interprets the body as a JSON object and returns\n   * the response in a given type.\n   *\n   * @param url     The endpoint URL.\n   * @param options The HTTP options to send with the request.\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with a response body of the given type.\n   */\n  head<T>(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n\n  /**\n   * Constructs an observable that, when subscribed, causes the configured\n   * `HEAD` request to execute on the server. The `HEAD` method returns\n   * meta information about the resource without transferring the\n   * resource itself. See the individual overloads for\n   * details on the return type.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('HEAD', url, options as any);\n  }\n\n  /**\n   * Constructs a `JSONP` request for the given URL and name of the callback parameter.\n   *\n   * @param url The resource URL.\n   * @param callbackParam The callback function name.\n   *\n   * @return An `Observable` of the response object, with response body as an object.\n   */\n  jsonp(url: string, callbackParam: string): Observable<Object>;\n\n  /**\n   * Constructs a `JSONP` request for the given URL and name of the callback parameter.\n   *\n   * @param url The resource URL.\n   * @param callbackParam The callback function name.\n   *\n   * You must install a suitable interceptor, such as one provided by `HttpClientJsonpModule`.\n   * If no such interceptor is reached,\n   * then the `JSONP` request can be rejected by the configured backend.\n   *\n   * @return An `Observable` of the response object, with response body in the requested type.\n   */\n  jsonp<T>(url: string, callbackParam: string): Observable<T>;\n\n  /**\n   * Constructs an `Observable` that, when subscribed, causes a request with the special method\n   * `JSONP` to be dispatched via the interceptor pipeline.\n   * The [JSONP pattern](https://en.wikipedia.org/wiki/JSONP) works around limitations of certain\n   * API endpoints that don't support newer,\n   * and preferable [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) protocol.\n   * JSONP treats the endpoint API as a JavaScript file and tricks the browser to process the\n   * requests even if the API endpoint is not located on the same domain (origin) as the client-side\n   * application making the request.\n   * The endpoint API must support JSONP callback for JSONP requests to work.\n   * The resource API returns the JSON response wrapped in a callback function.\n   * You can pass the callback function name as one of the query parameters.\n   * Note that JSONP requests can only be used with `GET` requests.\n   *\n   * @param url The resource URL.\n   * @param callbackParam The callback function name.\n   *\n   */\n  jsonp<T>(url: string, callbackParam: string): Observable<T> {\n    return this.request<any>('JSONP', url, {\n      params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),\n      observe: 'body',\n      responseType: 'json',\n    });\n  }\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as an\n   * `ArrayBuffer` and returns the response as an `ArrayBuffer`.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a `Blob` and returns\n   * the response as a `Blob`.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body as a `Blob`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a text string and\n   * returns a string value.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body of type string.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`\n   *  and returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return  An `Observable` of all `HttpEvents` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a `Blob` and\n   * returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with the response body as a `Blob`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a text string\n   * and returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HTTPEvents` for the request,\n   * with the response body of type string.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a JSON object\n   * and returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HttpEvents` for the request with the response\n   * body of type `Object`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a JSON object and\n   * returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HttpEvents` for the request,\n   * with a response body in the requested type.\n   */\n  options<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`\n   *  and returns the full HTTP response.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HttpResponse` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a `Blob`\n   *  and returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HttpResponse` for the request,\n   *  with the response body as a `Blob`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as text stream\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HttpResponse` for the request,\n   *  with the response body of type string.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a JSON object\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HttpResponse` for the request,\n   * with the response body of type `Object`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a JSON object and\n   * returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HttpResponse` for the request,\n   * with a response body in the requested type.\n   */\n  options<T>(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a JSON object and returns the\n   * response body as a JSON object.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body as a JSON object.\n   */\n  options(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs an `OPTIONS` request that interprets the body as a JSON object and returns the\n   * response in a given type.\n   *\n   * @param url The endpoint URL.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HTTPResponse`, with a response body of the given type.\n   */\n  options<T>(url: string, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n\n  /**\n   * Constructs an `Observable` that, when subscribed, causes the configured\n   * `OPTIONS` request to execute on the server. This method allows the client\n   * to determine the supported HTTP methods and other capabilites of an endpoint,\n   * without implying a resource action. See the individual overloads for\n   * details on the return type.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('OPTIONS', url, options as any);\n  }\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns\n   * the response as an `ArrayBuffer`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a `Blob` and returns the response\n   * as a `Blob`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body as a `Blob`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a text string and\n   * returns the response as a string value.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with a response body of type string.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and\n   *  returns the the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HTTPevents` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a `Blob`\n   *  and returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HTTPevents` for the request, with the\n   * response body as `Blob`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a text string and\n   * returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HTTPevents`for the request, with a\n   * response body of type string.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a JSON object\n   * and returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HTTPevents` for the request,\n   * with a response body of type `Object`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a JSON object\n   * and returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of all the `HTTPevents` for the request,\n   *  with a response body in the requested type.\n   */\n  patch<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer`\n   *  and returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return  An `Observable` of the `HttpResponse` for the request,\n   *  with the response body as an `ArrayBuffer`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a `Blob` and returns the full\n   * `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return  An `Observable` of the `HttpResponse` for the request,\n   * with the response body as a `Blob`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a text stream and returns the\n   * full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return  An `Observable` of the `HttpResponse` for the request,\n   * with a response body of type string.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a JSON object\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HttpResponse` for the request,\n   * with a response body in the requested type.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a JSON object\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the `HttpResponse` for the request,\n   * with a response body in the given type.\n   */\n  patch<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a JSON object and\n   * returns the response body as a JSON object.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body as a JSON object.\n   */\n  patch(url: string, body: any|null, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs a `PATCH` request that interprets the body as a JSON object\n   * and returns the response in a given type.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to edit.\n   * @param options HTTP options.\n   *\n   * @return  An `Observable` of the `HttpResponse` for the request,\n   * with a response body in the given type.\n   */\n  patch<T>(url: string, body: any|null, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n\n  /**\n   * Constructs an observable that, when subscribed, causes the configured\n   * `PATCH` request to execute on the server. See the individual overloads for\n   * details on the return type.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('PATCH', url, addBody(options, body));\n  }\n\n  /**\n   * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns\n   * an `ArrayBuffer`.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options.\n   *\n   * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a `Blob` and returns the\n   * response as a `Blob`.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the response, with the response body as a `Blob`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a text string and\n   * returns the response as a string value.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the response, with a response body of type string.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and\n   * returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a `Blob`\n   * and returns the response in an observable of the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all `HttpEvents` for the request, with the response body as `Blob`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a text string and returns the full\n   * event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return  An `Observable` of all `HttpEvents` for the request,\n   * with a response body of type string.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs a POST request that interprets the body as a JSON object and returns the full event\n   * stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return  An `Observable` of all `HttpEvents` for the request,\n   * with a response body of type `Object`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Constructs a POST request that interprets the body as a JSON object and returns the full event\n   * stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with a response body in the requested type.\n   */\n  post<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Constructs a POST request that interprets the body as an `ArrayBuffer`\n   *  and returns the full `HTTPresponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return  An `Observable` of the `HTTPResponse` for the request, with the response body as an\n   *     `ArrayBuffer`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a `Blob` and returns the full\n   * `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body as a `Blob`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a text stream and returns\n   * the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return  An `Observable` of the `HTTPResponse` for the request,\n   * with a response body of type string.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a JSON object\n   * and returns the full `HTTPResponse`.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request, with a response body of type\n   * `Object`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a JSON object and returns the full\n   * `HTTPResponse`.\n   *\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request, with a response body in the\n   *     requested type.\n   */\n  post<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a\n   * JSON object and returns the response body as a JSON object.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the response, with the response body as a JSON object.\n   */\n  post(url: string, body: any|null, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs a `POST` request that interprets the body as a JSON object\n   * and returns an observable of the response.\n   *\n   * @param url The endpoint URL.\n   * @param body The content to replace with.\n   * @param options HTTP options\n   *\n   * @return  An `Observable` of the `HTTPResponse` for the request, with a response body in the\n   *     requested type.\n   */\n  post<T>(url: string, body: any|null, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n\n  /**\n   * Constructs an observable that, when subscribed, causes the configured\n   * `POST` request to execute on the server. The server responds with the location of\n   * the replaced resource. See the individual overloads for\n   * details on the return type.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('POST', url, addBody(options, body));\n  }\n\n  /**\n   * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the\n   * response as an `ArrayBuffer`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a `Blob` and returns\n   * the response as a `Blob`.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the response, with the response body as a `Blob`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a text string and\n   * returns the response as a string value.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the response, with a response body of type string.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and\n   * returns the full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with the response body as an `ArrayBuffer`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a `Blob` and returns the full event\n   * stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with the response body as a `Blob`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a text string and returns the full event\n   * stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all HttpEvents for the request, with a response body\n   * of type string.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a JSON object and returns the full event\n   * stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all `HttpEvents` for the request, with a response body of\n   * type `Object`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a JSON object and returns the\n   * full event stream.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of all `HttpEvents` for the request,\n   * with a response body in the requested type.\n   */\n  put<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'events',\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as an\n   * `ArrayBuffer` and returns an observable of the full HTTP response.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request, with the response body as an\n   *     `ArrayBuffer`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'arraybuffer',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a `Blob` and returns the\n   * full HTTP response.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with the response body as a `Blob`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'blob',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a text stream and returns the\n   * full HTTP response.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request, with a response body of type\n   *     string.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean, responseType: 'text',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a JSON object and returns the full HTTP\n   * response.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request, with a response body\n   * of type 'Object`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a JSON object and returns the full HTTP\n   * response.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request,\n   * with a response body in the requested type.\n   */\n  put<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]}, observe: 'response',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a JSON object and returns the response\n   * body as a JSON object.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the response, with the response body as a JSON object.\n   */\n  put(url: string, body: any|null, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Constructs a `PUT` request that interprets the body as a JSON object\n   * and returns an observable of the response.\n   *\n   * @param url The endpoint URL.\n   * @param body The resources to add/update.\n   * @param options HTTP options\n   *\n   * @return An `Observable` of the `HTTPResponse` for the request, with a response body in the\n   *     requested type.\n   */\n  put<T>(url: string, body: any|null, options?: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: 'body',\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n\n  /**\n   * Constructs an observable that, when subscribed, causes the configured\n   * `PUT` request to execute on the server. The `PUT` method replaces an existing resource\n   * with a new set of values.\n   * See the individual overloads for details on the return type.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders|{[header: string]: string | string[]},\n    observe?: HttpObserve,\n    params?: HttpParams|{[param: string]: string | string[]},\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('PUT', url, addBody(options, body));\n  }\n}\n"]}