D-Net

{"version":3,"file":"http.js","sources":["../../../../../packages/common/http/index.ts","../../../../../packages/common/http/public_api.ts","../../../../../packages/common/http/src/module.ts","../../../../../packages/common/http/src/xsrf.ts","../../../../../packages/common/http/src/xhr.ts","../../../../../packages/common/http/src/jsonp.ts","../../../../../packages/common/http/src/interceptor.ts","../../../../../packages/common/http/src/client.ts","../../../../../packages/common/http/src/response.ts","../../../../../packages/common/http/src/request.ts","../../../../../packages/common/http/src/headers.ts","../../../../../packages/common/http/src/params.ts","../../../../../packages/common/http/src/backend.ts"],"sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport {HttpBackend,HttpHandler,HttpClient,HttpHeaders,HTTP_INTERCEPTORS,HttpInterceptor,JsonpClientBackend,JsonpInterceptor,HttpClientJsonpModule,HttpClientModule,HttpClientXsrfModule,ɵinterceptingHandler,HttpParameterCodec,HttpParams,HttpUrlEncodingCodec,HttpRequest,HttpDownloadProgressEvent,HttpErrorResponse,HttpEvent,HttpEventType,HttpHeaderResponse,HttpProgressEvent,HttpResponse,HttpResponseBase,HttpSentEvent,HttpUserEvent,HttpXhrBackend,XhrFactory,HttpXsrfTokenExtractor} from './public_api';\n\nexport {NoopInterceptor as ɵa} from './src/interceptor';\nexport {JsonpCallbackContext as ɵb} from './src/jsonp';\nexport {jsonpCallbackContext as ɵc} from './src/module';\nexport {BrowserXhr as ɵd} from './src/xhr';\nexport {HttpXsrfCookieExtractor as ɵg,HttpXsrfInterceptor as ɵh,XSRF_COOKIE_NAME as ɵe,XSRF_HEADER_NAME as ɵf} from './src/xsrf';","/**\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\nexport {HttpBackend, HttpHandler} from './src/backend';\nexport {HttpClient} from './src/client';\nexport {HttpHeaders} from './src/headers';\nexport {HTTP_INTERCEPTORS, HttpInterceptor} from './src/interceptor';\nexport {JsonpClientBackend, JsonpInterceptor} from './src/jsonp';\nexport {HttpClientJsonpModule, HttpClientModule, HttpClientXsrfModule, interceptingHandler as ɵinterceptingHandler} from './src/module';\nexport {HttpParameterCodec, HttpParams, HttpUrlEncodingCodec} from './src/params';\nexport {HttpRequest} from './src/request';\nexport {HttpDownloadProgressEvent, HttpErrorResponse, HttpEvent, HttpEventType, HttpHeaderResponse, HttpProgressEvent, HttpResponse, HttpResponseBase, HttpSentEvent, HttpUserEvent} from './src/response';\nexport {HttpXhrBackend, XhrFactory} from './src/xhr';\nexport {HttpXsrfTokenExtractor} from './src/xsrf';\n","/**\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\n\nimport {Inject, ModuleWithProviders, NgModule, Optional} from '@angular/core';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpClient} from './client';\nimport {HTTP_INTERCEPTORS, HttpInterceptor, HttpInterceptorHandler, NoopInterceptor} from './interceptor';\nimport {JsonpCallbackContext, JsonpClientBackend, JsonpInterceptor} from './jsonp';\nimport {BrowserXhr, HttpXhrBackend, XhrFactory} from './xhr';\nimport {HttpXsrfCookieExtractor, HttpXsrfInterceptor, HttpXsrfTokenExtractor, XSRF_COOKIE_NAME, XSRF_HEADER_NAME} from './xsrf';\n/**\n * Constructs an `HttpHandler` that applies a bunch of `HttpInterceptor`s\n * to a request before passing it to the given `HttpBackend`.\n * \n * Meant to be used as a factory function within `HttpClientModule`.\n * \n * \\@experimental\n * @param {?} backend\n * @param {?=} interceptors\n * @return {?}\n */\nexport function interceptingHandler(\n    backend: HttpBackend, interceptors: HttpInterceptor[] | null = []): HttpHandler {\n  if (!interceptors) {\n    return backend;\n  }\n  return interceptors.reduceRight(\n      (next, interceptor) => new HttpInterceptorHandler(next, interceptor), backend);\n}\n/**\n * Factory function that determines where to store JSONP callbacks.\n * \n * Ordinarily JSONP callbacks are stored on the `window` object, but this may not exist\n * in test environments. In that case, callbacks are stored on an anonymous object instead.\n * \n * \\@experimental\n * @return {?}\n */\nexport function jsonpCallbackContext(): Object {\n  if (typeof window === 'object') {\n    return window;\n  }\n  return {};\n}\n/**\n * `NgModule` which adds XSRF protection support to outgoing requests.\n * \n * Provided the server supports a cookie-based XSRF protection system, this\n * module can be used directly to configure XSRF protection with the correct\n * cookie and header names.\n * \n * If no such names are provided, the default is to use `X-XSRF-TOKEN` for\n * the header name and `XSRF-TOKEN` for the cookie name.\n * \n * \\@experimental\n */\nexport class HttpClientXsrfModule {\n/**\n * Disable the default XSRF protection.\n * @return {?}\n */\nstatic disable(): ModuleWithProviders {\n    return {\n      ngModule: HttpClientXsrfModule,\n      providers: [\n        {provide: HttpXsrfInterceptor, useClass: NoopInterceptor},\n      ],\n    };\n  }\n/**\n * Configure XSRF protection to use the given cookie name or header name,\n * or the default names (as described above) if not provided.\n * @param {?=} options\n * @return {?}\n */\nstatic withOptions(options: {\n    cookieName?: string,\n    headerName?: string,\n  } = {}): ModuleWithProviders {\n    return {\n      ngModule: HttpClientXsrfModule,\n      providers: [\n        options.cookieName ? {provide: XSRF_COOKIE_NAME, useValue: options.cookieName} : [],\n        options.headerName ? {provide: XSRF_HEADER_NAME, useValue: options.headerName} : [],\n      ],\n    };\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: NgModule, args: [{\n  providers: [\n    HttpXsrfInterceptor,\n    {provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true},\n    {provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor},\n    {provide: XSRF_COOKIE_NAME, useValue: 'XSRF-TOKEN'},\n    {provide: XSRF_HEADER_NAME, useValue: 'X-XSRF-TOKEN'},\n  ],\n}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction HttpClientXsrfModule_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpClientXsrfModule.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nHttpClientXsrfModule.ctorParameters;\n}\n\n/**\n * `NgModule` which provides the `HttpClient` and associated services.\n * \n * Interceptors can be added to the chain behind `HttpClient` by binding them\n * to the multiprovider for `HTTP_INTERCEPTORS`.\n * \n * \\@experimental\n */\nexport class HttpClientModule {\nstatic decorators: DecoratorInvocation[] = [\n{ type: NgModule, args: [{\n  imports: [\n    HttpClientXsrfModule.withOptions({\n      cookieName: 'XSRF-TOKEN',\n      headerName: 'X-XSRF-TOKEN',\n    }),\n  ],\n  providers: [\n    HttpClient,\n    // HttpHandler is the backend + interceptors and is constructed\n    // using the interceptingHandler factory function.\n    {\n      provide: HttpHandler,\n      useFactory: interceptingHandler,\n      deps: [HttpBackend, [new Optional(), new Inject(HTTP_INTERCEPTORS)]],\n    },\n    HttpXhrBackend,\n    {provide: HttpBackend, useExisting: HttpXhrBackend},\n    BrowserXhr,\n    {provide: XhrFactory, useExisting: BrowserXhr},\n  ],\n}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction HttpClientModule_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpClientModule.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nHttpClientModule.ctorParameters;\n}\n\n/**\n * `NgModule` which enables JSONP support in `HttpClient`.\n * \n * Without this module, Jsonp requests will reach the backend\n * with method JSONP, where they'll be rejected.\n * \n * \\@experimental\n */\nexport class HttpClientJsonpModule {\nstatic decorators: DecoratorInvocation[] = [\n{ type: NgModule, args: [{\n  providers: [\n    JsonpClientBackend,\n    {provide: JsonpCallbackContext, useFactory: jsonpCallbackContext},\n    {provide: HTTP_INTERCEPTORS, useClass: JsonpInterceptor, multi: true},\n  ],\n}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction HttpClientJsonpModule_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpClientJsonpModule.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nHttpClientJsonpModule.ctorParameters;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n","/**\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\n\nimport {DOCUMENT, ɵparseCookieValue as parseCookieValue} from '@angular/common';\nimport {Inject, Injectable, InjectionToken, PLATFORM_ID} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\n\nimport {HttpHandler} from './backend';\nimport {HttpInterceptor} from './interceptor';\nimport {HttpRequest} from './request';\nimport {HttpEvent} from './response';\n\nexport const /** @type {?} */ XSRF_COOKIE_NAME = new InjectionToken<string>('XSRF_COOKIE_NAME');\nexport const /** @type {?} */ XSRF_HEADER_NAME = new InjectionToken<string>('XSRF_HEADER_NAME');\n/**\n * Retrieves the current XSRF token to use with the next outgoing request.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class HttpXsrfTokenExtractor {\n/**\n * Get the XSRF token to use with an outgoing request.\n * \n * Will be called for every request, so the token may change between requests.\n * @abstract\n * @return {?}\n */\ngetToken() {}\n}\n/**\n * `HttpXsrfTokenExtractor` which retrieves the token from a cookie.\n */\nexport class HttpXsrfCookieExtractor implements HttpXsrfTokenExtractor {\nprivate lastCookieString: string = '';\nprivate lastToken: string|null = null;\n/**\n * \\@internal for testing\n */\nparseCount: number = 0;\n/**\n * @param {?} doc\n * @param {?} platform\n * @param {?} cookieName\n */\nconstructor(\nprivate doc: any,\nprivate platform: string,\nprivate cookieName: string) {}\n/**\n * @return {?}\n */\ngetToken(): string|null {\n    if (this.platform === 'server') {\n      return null;\n    }\n    const /** @type {?} */ cookieString = this.doc.cookie || '';\n    if (cookieString !== this.lastCookieString) {\n      this.parseCount++;\n      this.lastToken = parseCookieValue(cookieString, this.cookieName);\n      this.lastCookieString = cookieString;\n    }\n    return this.lastToken;\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: undefined, decorators: [{ type: Inject, args: [DOCUMENT, ] }, ]},\n{type: undefined, decorators: [{ type: Inject, args: [PLATFORM_ID, ] }, ]},\n{type: undefined, decorators: [{ type: Inject, args: [XSRF_COOKIE_NAME, ] }, ]},\n];\n}\n\nfunction HttpXsrfCookieExtractor_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpXsrfCookieExtractor.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nHttpXsrfCookieExtractor.ctorParameters;\n/** @type {?} */\nHttpXsrfCookieExtractor.prototype.lastCookieString;\n/** @type {?} */\nHttpXsrfCookieExtractor.prototype.lastToken;\n/**\n * \\@internal for testing\n * @type {?}\n */\nHttpXsrfCookieExtractor.prototype.parseCount;\n/** @type {?} */\nHttpXsrfCookieExtractor.prototype.doc;\n/** @type {?} */\nHttpXsrfCookieExtractor.prototype.platform;\n/** @type {?} */\nHttpXsrfCookieExtractor.prototype.cookieName;\n}\n\n/**\n * `HttpInterceptor` which adds an XSRF token to eligible outgoing requests.\n */\nexport class HttpXsrfInterceptor implements HttpInterceptor {\n/**\n * @param {?} tokenService\n * @param {?} headerName\n */\nconstructor(\nprivate tokenService: HttpXsrfTokenExtractor,\nprivate headerName: string) {}\n/**\n * @param {?} req\n * @param {?} next\n * @return {?}\n */\nintercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    const /** @type {?} */ lcUrl = req.url.toLowerCase();\n    // Skip both non-mutating requests and absolute URLs.\n    // Non-mutating requests don't require a token, and absolute URLs require special handling\n    // anyway as the cookie set\n    // on our origin is not the same as the token expected by another origin.\n    if (req.method === 'GET' || req.method === 'HEAD' || lcUrl.startsWith('http://') ||\n        lcUrl.startsWith('https://')) {\n      return next.handle(req);\n    }\n    const /** @type {?} */ token = this.tokenService.getToken();\n\n    // Be careful not to overwrite an existing header of the same name.\n    if (token !== null && !req.headers.has(this.headerName)) {\n      req = req.clone({headers: req.headers.set(this.headerName, token)});\n    }\n    return next.handle(req);\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: HttpXsrfTokenExtractor, },\n{type: undefined, decorators: [{ type: Inject, args: [XSRF_HEADER_NAME, ] }, ]},\n];\n}\n\nfunction HttpXsrfInterceptor_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpXsrfInterceptor.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nHttpXsrfInterceptor.ctorParameters;\n/** @type {?} */\nHttpXsrfInterceptor.prototype.tokenService;\n/** @type {?} */\nHttpXsrfInterceptor.prototype.headerName;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n","/**\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\n\nimport {Injectable} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {Observer} from 'rxjs/Observer';\n\nimport {HttpBackend} from './backend';\nimport {HttpHeaders} from './headers';\nimport {HttpRequest} from './request';\nimport {HttpDownloadProgressEvent, HttpErrorResponse, HttpEvent, HttpEventType, HttpHeaderResponse, HttpJsonParseError, HttpResponse, HttpUploadProgressEvent} from './response';\n\nconst /** @type {?} */ XSSI_PREFIX = /^\\)\\]\\}',?\\n/;\n/**\n * Determine an appropriate URL for the response, by checking either\n * XMLHttpRequest.responseURL or the X-Request-URL header.\n * @param {?} xhr\n * @return {?}\n */\nfunction getResponseUrl(xhr: any): string|null {\n  if ('responseURL' in xhr && xhr.responseURL) {\n    return xhr.responseURL;\n  }\n  if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {\n    return xhr.getResponseHeader('X-Request-URL');\n  }\n  return null;\n}\n/**\n * A wrapper around the `XMLHttpRequest` constructor.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class XhrFactory {\n/**\n * @abstract\n * @return {?}\n */\nbuild() {} }\n/**\n * A factory for \\@{link HttpXhrBackend} that uses the `XMLHttpRequest` browser API.\n * \n * \\@experimental\n */\nexport class BrowserXhr implements XhrFactory {\nconstructor() {}\n/**\n * @return {?}\n */\nbuild(): any { return /** @type {?} */(( <any>(new XMLHttpRequest()))); }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction BrowserXhr_tsickle_Closure_declarations() {\n/** @type {?} */\nBrowserXhr.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nBrowserXhr.ctorParameters;\n}\n\n\n/**\n * Tracks a response from the server that does not yet have a body.\n */\ninterface PartialResponse {\n  headers: HttpHeaders;\n  status: number;\n  statusText: string;\n  url: string;\n}\n/**\n * An `HttpBackend` which uses the XMLHttpRequest API to send\n * requests to a backend server.\n * \n * \\@experimental\n */\nexport class HttpXhrBackend implements HttpBackend {\n/**\n * @param {?} xhrFactory\n */\nconstructor(private xhrFactory: XhrFactory) {}\n/**\n * Process a request and return a stream of response events.\n * @param {?} req\n * @return {?}\n */\nhandle(req: HttpRequest<any>): Observable<HttpEvent<any>> {\n    // Quick check to give a better error message when a user attempts to use\n    // HttpClient.jsonp() without installing the JsonpClientModule\n    if (req.method === 'JSONP') {\n      throw new Error(`Attempted to construct Jsonp request without JsonpClientModule installed.`);\n    }\n\n    // Everything happens on Observable subscription.\n    return new Observable((observer: Observer<HttpEvent<any>>) => {\n      // Start by setting up the XHR object with request method, URL, and withCredentials flag.\n      const /** @type {?} */ xhr = this.xhrFactory.build();\n      xhr.open(req.method, req.urlWithParams);\n      if (!!req.withCredentials) {\n        xhr.withCredentials = true;\n      }\n\n      // Add all the requested headers.\n      req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(',')));\n\n      // Add an Accept header if one isn't present already.\n      if (!req.headers.has('Accept')) {\n        xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');\n      }\n\n      // Auto-detect the Content-Type header if one isn't present already.\n      if (!req.headers.has('Content-Type')) {\n        const /** @type {?} */ detectedType = req.detectContentTypeHeader();\n        // Sometimes Content-Type detection fails.\n        if (detectedType !== null) {\n          xhr.setRequestHeader('Content-Type', detectedType);\n        }\n      }\n\n      // Set the responseType if one was requested.\n      if (req.responseType) {\n        const /** @type {?} */ responseType = req.responseType.toLowerCase();\n\n        // JSON responses need to be processed as text. This is because if the server\n        // returns an XSSI-prefixed JSON response, the browser will fail to parse it,\n        // xhr.response will be null, and xhr.responseText cannot be accessed to\n        // retrieve the prefixed JSON data in order to strip the prefix. Thus, all JSON\n        // is parsed by first requesting text and then applying JSON.parse.\n        xhr.responseType = /** @type {?} */(( ((responseType !== 'json') ? responseType : 'text') as any));\n      }\n\n      // Serialize the request body if one is present. If not, this will be set to null.\n      const /** @type {?} */ reqBody = req.serializeBody();\n\n      // If progress events are enabled, response headers will be delivered\n      // in two events - the HttpHeaderResponse event and the full HttpResponse\n      // event. However, since response headers don't change in between these\n      // two events, it doesn't make sense to parse them twice. So headerResponse\n      // caches the data extracted from the response whenever it's first parsed,\n      // to ensure parsing isn't duplicated.\n      let /** @type {?} */ headerResponse: HttpHeaderResponse|null = null;\n\n      // partialFromXhr extracts the HttpHeaderResponse from the current XMLHttpRequest\n      // state, and memoizes it into headerResponse.\n      const /** @type {?} */ partialFromXhr = (): HttpHeaderResponse => {\n        if (headerResponse !== null) {\n          return headerResponse;\n        }\n\n        // Read status and normalize an IE9 bug (http://bugs.jquery.com/ticket/1450).\n        const /** @type {?} */ status: number = xhr.status === 1223 ? 204 : xhr.status;\n        const /** @type {?} */ statusText = xhr.statusText || 'OK';\n\n        // Parse headers from XMLHttpRequest - this step is lazy.\n        const /** @type {?} */ headers = new HttpHeaders(xhr.getAllResponseHeaders());\n\n        // Read the response URL from the XMLHttpResponse instance and fall back on the\n        // request URL.\n        const /** @type {?} */ url = getResponseUrl(xhr) || req.url;\n\n        // Construct the HttpHeaderResponse and memoize it.\n        headerResponse = new HttpHeaderResponse({headers, status, statusText, url});\n        return headerResponse;\n      };\n\n      // Next, a few closures are defined for the various events which XMLHttpRequest can\n      // emit. This allows them to be unregistered as event listeners later.\n\n      // First up is the load event, which represents a response being fully available.\n      const /** @type {?} */ onLoad = () => {\n        // Read response state from the memoized partial data.\n        let {headers, status, statusText, url} = partialFromXhr();\n\n        // The body will be read out if present.\n        let /** @type {?} */ body: any|null = null;\n\n        if (status !== 204) {\n          // Use XMLHttpRequest.response if set, responseText otherwise.\n          body = (typeof xhr.response === 'undefined') ? xhr.responseText : xhr.response;\n        }\n\n        // Normalize another potential bug (this one comes from CORS).\n        if (status === 0) {\n          status = !!body ? 200 : 0;\n        }\n\n        // ok determines whether the response will be transmitted on the event or\n        // error channel. Unsuccessful status codes (not 2xx) will always be errors,\n        // but a successful status code can still result in an error if the user\n        // asked for JSON data and the body cannot be parsed as such.\n        let /** @type {?} */ ok = status >= 200 && status < 300;\n\n        // Check whether the body needs to be parsed as JSON (in many cases the browser\n        // will have done that already).\n        if (ok && req.responseType === 'json' && typeof body === 'string') {\n          // Attempt the parse. If it fails, a parse error should be delivered to the user.\n          body = body.replace(XSSI_PREFIX, '');\n          try {\n            body = JSON.parse(body);\n          } catch ( /** @type {?} */error) {\n            // Even though the response status was 2xx, this is still an error.\n            ok = false;\n            // The parse error contains the text of the body that failed to parse.\n            body = /** @type {?} */(( { error, text: body } as HttpJsonParseError));\n          }\n        } else if (!ok && req.responseType === 'json' && typeof body === 'string') {\n          try {\n            // Attempt to parse the body as JSON.\n            body = JSON.parse(body);\n          } catch ( /** @type {?} */error) {\n            // Cannot be certain that the body was meant to be parsed as JSON.\n            // Leave the body as a string.\n          }\n        }\n\n        if (ok) {\n          // A successful response is delivered on the event stream.\n          observer.next(new HttpResponse({\n            body,\n            headers,\n            status,\n            statusText,\n            url: url || undefined,\n          }));\n          // The full body has been received and delivered, no further events\n          // are possible. This request is complete.\n          observer.complete();\n        } else {\n          // An unsuccessful request is delivered on the error channel.\n          observer.error(new HttpErrorResponse({\n            // The error in this case is the response body (error from the server).\n            error: body,\n            headers,\n            status,\n            statusText,\n            url: url || undefined,\n          }));\n        }\n      };\n\n      // The onError callback is called when something goes wrong at the network level.\n      // Connection timeout, DNS error, offline, etc. These are actual errors, and are\n      // transmitted on the error channel.\n      const /** @type {?} */ onError = (error: ErrorEvent) => {\n        const /** @type {?} */ res = new HttpErrorResponse({\n          error,\n          status: xhr.status || 0,\n          statusText: xhr.statusText || 'Unknown Error',\n        });\n        observer.error(res);\n      };\n\n      // The sentHeaders flag tracks whether the HttpResponseHeaders event\n      // has been sent on the stream. This is necessary to track if progress\n      // is enabled since the event will be sent on only the first download\n      // progerss event.\n      let /** @type {?} */ sentHeaders = false;\n\n      // The download progress event handler, which is only registered if\n      // progress events are enabled.\n      const /** @type {?} */ onDownProgress = (event: ProgressEvent) => {\n        // Send the HttpResponseHeaders event if it hasn't been sent already.\n        if (!sentHeaders) {\n          observer.next(partialFromXhr());\n          sentHeaders = true;\n        }\n\n        // Start building the download progress event to deliver on the response\n        // event stream.\n        let /** @type {?} */ progressEvent: HttpDownloadProgressEvent = {\n          type: HttpEventType.DownloadProgress,\n          loaded: event.loaded,\n        };\n\n        // Set the total number of bytes in the event if it's available.\n        if (event.lengthComputable) {\n          progressEvent.total = event.total;\n        }\n\n        // If the request was for text content and a partial response is\n        // available on XMLHttpRequest, include it in the progress event\n        // to allow for streaming reads.\n        if (req.responseType === 'text' && !!xhr.responseText) {\n          progressEvent.partialText = xhr.responseText;\n        }\n\n        // Finally, fire the event.\n        observer.next(progressEvent);\n      };\n\n      // The upload progress event handler, which is only registered if\n      // progress events are enabled.\n      const /** @type {?} */ onUpProgress = (event: ProgressEvent) => {\n        // Upload progress events are simpler. Begin building the progress\n        // event.\n        let /** @type {?} */ progress: HttpUploadProgressEvent = {\n          type: HttpEventType.UploadProgress,\n          loaded: event.loaded,\n        };\n\n        // If the total number of bytes being uploaded is available, include\n        // it.\n        if (event.lengthComputable) {\n          progress.total = event.total;\n        }\n\n        // Send the event.\n        observer.next(progress);\n      };\n\n      // By default, register for load and error events.\n      xhr.addEventListener('load', onLoad);\n      xhr.addEventListener('error', onError);\n\n      // Progress events are only enabled if requested.\n      if (req.reportProgress) {\n        // Download progress is always enabled if requested.\n        xhr.addEventListener('progress', onDownProgress);\n\n        // Upload progress depends on whether there is a body to upload.\n        if (reqBody !== null && xhr.upload) {\n          xhr.upload.addEventListener('progress', onUpProgress);\n        }\n      }\n\n      // Fire the request, and notify the event stream that it was fired.\n      xhr.send(reqBody);\n      observer.next({type: HttpEventType.Sent});\n\n      // This is the return from the Observable function, which is the\n      // request cancellation handler.\n      return () => {\n        // On a cancellation, remove all registered event listeners.\n        xhr.removeEventListener('error', onError);\n        xhr.removeEventListener('load', onLoad);\n        if (req.reportProgress) {\n          xhr.removeEventListener('progress', onDownProgress);\n          if (reqBody !== null && xhr.upload) {\n            xhr.upload.removeEventListener('progress', onUpProgress);\n          }\n        }\n\n        // Finally, abort the in-flight request.\n        xhr.abort();\n      };\n    });\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: XhrFactory, },\n];\n}\n\nfunction HttpXhrBackend_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpXhrBackend.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nHttpXhrBackend.ctorParameters;\n/** @type {?} */\nHttpXhrBackend.prototype.xhrFactory;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n","/**\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\n\nimport {DOCUMENT} from '@angular/common';\nimport {Inject, Injectable, InjectionToken} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {Observer} from 'rxjs/Observer';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpRequest} from './request';\nimport {HttpErrorResponse, HttpEvent, HttpEventType, HttpResponse} from './response';\n\n// Every request made through JSONP needs a callback name that's unique across the\n// whole page. Each request is assigned an id and the callback name is constructed\n// from that. The next id to be assigned is tracked in a global variable here that\n// is shared among all applications on the page.\nlet /** @type {?} */ nextRequestId: number = 0;\n\n// Error text given when a JSONP script is injected, but doesn't invoke the callback\n// passed in its URL.\nexport const /** @type {?} */ JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';\n\n// Error text given when a request is passed to the JsonpClientBackend that doesn't\n// have a request method JSONP.\nexport const /** @type {?} */ JSONP_ERR_WRONG_METHOD = 'JSONP requests must use JSONP request method.';\nexport const /** @type {?} */ JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response type.';\n/**\n * DI token/abstract type representing a map of JSONP callbacks.\n * \n * In the browser, this should always be the `window` object.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class JsonpCallbackContext { [key: string]: (data: any) => void; }\n/**\n * `HttpBackend` that only processes `HttpRequest` with the JSONP method,\n * by performing JSONP style requests.\n * \n * \\@experimental\n */\nexport class JsonpClientBackend implements HttpBackend {\n/**\n * @param {?} callbackMap\n * @param {?} document\n */\nconstructor(private callbackMap: JsonpCallbackContext,\nprivate document: any) {}\n/**\n * Get the name of the next callback method, by incrementing the global `nextRequestId`.\n * @return {?}\n */\nprivate nextCallback(): string { return `ng_jsonp_callback_${nextRequestId++}`; }\n/**\n * Process a JSONP request and return an event stream of the results.\n * @param {?} req\n * @return {?}\n */\nhandle(req: HttpRequest<never>): Observable<HttpEvent<any>> {\n    // Firstly, check both the method and response type. If either doesn't match\n    // then the request was improperly routed here and cannot be handled.\n    if (req.method !== 'JSONP') {\n      throw new Error(JSONP_ERR_WRONG_METHOD);\n    } else if (req.responseType !== 'json') {\n      throw new Error(JSONP_ERR_WRONG_RESPONSE_TYPE);\n    }\n\n    // Everything else happens inside the Observable boundary.\n    return new Observable<HttpEvent<any>>((observer: Observer<HttpEvent<any>>) => {\n      // The first step to make a request is to generate the callback name, and replace the\n      // callback placeholder in the URL with the name. Care has to be taken here to ensure\n      // a trailing &, if matched, gets inserted back into the URL in the correct place.\n      const /** @type {?} */ callback = this.nextCallback();\n      const /** @type {?} */ url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);\n\n      // Construct the <script> tag and point it at the URL.\n      const /** @type {?} */ node = this.document.createElement('script');\n      node.src = url;\n\n      // A JSONP request requires waiting for multiple callbacks. These variables\n      // are closed over and track state across those callbacks.\n\n      // The response object, if one has been received, or null otherwise.\n      let /** @type {?} */ body: any|null = null;\n\n      // Whether the response callback has been called.\n      let /** @type {?} */ finished: boolean = false;\n\n      // Whether the request has been cancelled (and thus any other callbacks)\n      // should be ignored.\n      let /** @type {?} */ cancelled: boolean = false;\n\n      // Set the response callback in this.callbackMap (which will be the window\n      // object in the browser. The script being loaded via the <script> tag will\n      // eventually call this callback.\n      this.callbackMap[callback] = (data?: any) => {\n        // Data has been received from the JSONP script. Firstly, delete this callback.\n        delete this.callbackMap[callback];\n\n        // Next, make sure the request wasn't cancelled in the meantime.\n        if (cancelled) {\n          return;\n        }\n\n        // Set state to indicate data was received.\n        body = data;\n        finished = true;\n      };\n\n      // cleanup() is a utility closure that removes the <script> from the page and\n      // the response callback from the window. This logic is used in both the\n      // success, error, and cancellation paths, so it's extracted out for convenience.\n      const /** @type {?} */ cleanup = () => {\n        // Remove the <script> tag if it's still on the page.\n        if (node.parentNode) {\n          node.parentNode.removeChild(node);\n        }\n\n        // Remove the response callback from the callbackMap (window object in the\n        // browser).\n        delete this.callbackMap[callback];\n      };\n\n      // onLoad() is the success callback which runs after the response callback\n      // if the JSONP script loads successfully. The event itself is unimportant.\n      // If something went wrong, onLoad() may run without the response callback\n      // having been invoked.\n      const /** @type {?} */ onLoad = (event: Event) => {\n        // Do nothing if the request has been cancelled.\n        if (cancelled) {\n          return;\n        }\n\n        // Cleanup the page.\n        cleanup();\n\n        // Check whether the response callback has run.\n        if (!finished) {\n          // It hasn't, something went wrong with the request. Return an error via\n          // the Observable error path. All JSONP errors have status 0.\n          observer.error(new HttpErrorResponse({\n            url,\n            status: 0,\n            statusText: 'JSONP Error',\n            error: new Error(JSONP_ERR_NO_CALLBACK),\n          }));\n          return;\n        }\n\n        // Success. body either contains the response body or null if none was\n        // returned.\n        observer.next(new HttpResponse({\n          body,\n          status: 200,\n          statusText: 'OK', url,\n        }));\n\n        // Complete the stream, the resposne is over.\n        observer.complete();\n      };\n\n      // onError() is the error callback, which runs if the script returned generates\n      // a Javascript error. It emits the error via the Observable error channel as\n      // a HttpErrorResponse.\n      const /** @type {?} */ onError: any = (error: Error) => {\n        // If the request was already cancelled, no need to emit anything.\n        if (cancelled) {\n          return;\n        }\n        cleanup();\n\n        // Wrap the error in a HttpErrorResponse.\n        observer.error(new HttpErrorResponse({\n          error,\n          status: 0,\n          statusText: 'JSONP Error', url,\n        }));\n      };\n\n      // Subscribe to both the success (load) and error events on the <script> tag,\n      // and add it to the page.\n      node.addEventListener('load', onLoad);\n      node.addEventListener('error', onError);\n      this.document.body.appendChild(node);\n\n      // The request has now been successfully sent.\n      observer.next({type: HttpEventType.Sent});\n\n      // Cancellation handler.\n      return () => {\n        // Track the cancellation so event listeners won't do anything even if already scheduled.\n        cancelled = true;\n\n        // Remove the event listeners so they won't run if the events later fire.\n        node.removeEventListener('load', onLoad);\n        node.removeEventListener('error', onError);\n\n        // And finally, clean up the page.\n        cleanup();\n      };\n    });\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: JsonpCallbackContext, },\n{type: undefined, decorators: [{ type: Inject, args: [DOCUMENT, ] }, ]},\n];\n}\n\nfunction JsonpClientBackend_tsickle_Closure_declarations() {\n/** @type {?} */\nJsonpClientBackend.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nJsonpClientBackend.ctorParameters;\n/** @type {?} */\nJsonpClientBackend.prototype.callbackMap;\n/** @type {?} */\nJsonpClientBackend.prototype.document;\n}\n\n/**\n * An `HttpInterceptor` which identifies requests with the method JSONP and\n * shifts them to the `JsonpClientBackend`.\n * \n * \\@experimental\n */\nexport class JsonpInterceptor {\n/**\n * @param {?} jsonp\n */\nconstructor(private jsonp: JsonpClientBackend) {}\n/**\n * @param {?} req\n * @param {?} next\n * @return {?}\n */\nintercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    if (req.method === 'JSONP') {\n      return this.jsonp.handle( /** @type {?} */((req as HttpRequest<never>)));\n    }\n    // Fall through for normal HTTP requests.\n    return next.handle(req);\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: JsonpClientBackend, },\n];\n}\n\nfunction JsonpInterceptor_tsickle_Closure_declarations() {\n/** @type {?} */\nJsonpInterceptor.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nJsonpInterceptor.ctorParameters;\n/** @type {?} */\nJsonpInterceptor.prototype.jsonp;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n","/**\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\n\nimport {Injectable, InjectionToken} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\n\nimport {HttpHandler} from './backend';\nimport {HttpRequest} from './request';\nimport {HttpEvent} from './response';\n\n/**\n * Intercepts `HttpRequest` and handles them.\n *\n * Most interceptors will transform the outgoing request before passing it to the\n * next interceptor in the chain, by calling `next.handle(transformedReq)`.\n *\n * In rare cases, interceptors may wish to completely handle a request themselves,\n * and not delegate to the remainder of the chain. This behavior is allowed.\n *\n * @experimental\n */\nexport interface HttpInterceptor {\n  /**\n   * Intercept an outgoing `HttpRequest` and optionally transform it or the\n   * response.\n   *\n   * Typically an interceptor will transform the outgoing request before returning\n   * `next.handle(transformedReq)`. An interceptor may choose to transform the\n   * response event stream as well, by applying additional Rx operators on the stream\n   * returned by `next.handle()`.\n   *\n   * More rarely, an interceptor may choose to completely handle the request itself,\n   * and compose a new event stream instead of invoking `next.handle()`. This is\n   * acceptable behavior, but keep in mind further interceptors will be skipped entirely.\n   *\n   * It is also rare but valid for an interceptor to return multiple responses on the\n   * event stream for a single request.\n   */\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;\n}\n/**\n * `HttpHandler` which applies an `HttpInterceptor` to an `HttpRequest`.\n * \n * \\@experimental\n */\nexport class HttpInterceptorHandler implements HttpHandler {\n/**\n * @param {?} next\n * @param {?} interceptor\n */\nconstructor(private next: HttpHandler,\nprivate interceptor: HttpInterceptor) {}\n/**\n * @param {?} req\n * @return {?}\n */\nhandle(req: HttpRequest<any>): Observable<HttpEvent<any>> {\n    return this.interceptor.intercept(req, this.next);\n  }\n}\n\nfunction HttpInterceptorHandler_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpInterceptorHandler.prototype.next;\n/** @type {?} */\nHttpInterceptorHandler.prototype.interceptor;\n}\n\n/**\n * A multi-provider token which represents the array of `HttpInterceptor`s that\n * are registered.\n * \n * \\@experimental\n */\nexport const HTTP_INTERCEPTORS = new InjectionToken<HttpInterceptor[]>('HTTP_INTERCEPTORS');\nexport class NoopInterceptor implements HttpInterceptor {\n/**\n * @param {?} req\n * @param {?} next\n * @return {?}\n */\nintercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    return next.handle(req);\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction NoopInterceptor_tsickle_Closure_declarations() {\n/** @type {?} */\nNoopInterceptor.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nNoopInterceptor.ctorParameters;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n","/**\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\n\nimport {Injectable} from '@angular/core';\nimport {Observable} from 'rxjs/Observable';\nimport {of } from 'rxjs/observable/of';\nimport {concatMap} from 'rxjs/operator/concatMap';\nimport {filter} from 'rxjs/operator/filter';\nimport {map} from 'rxjs/operator/map';\n\nimport {HttpHandler} from './backend';\nimport {HttpHeaders} from './headers';\nimport {HttpParams} from './params';\nimport {HttpRequest} from './request';\nimport {HttpEvent, HttpResponse} from './response';\n/**\n * Construct an instance of `HttpRequestOptions<T>` from a source `HttpMethodOptions` and\n * the given `body`. Basically, this clones the object and adds the body.\n * @template T\n * @param {?} options\n * @param {?} body\n * @return {?}\n */\nfunction addBody<T>(\n    options: {\n      headers?: HttpHeaders,\n      observe?: HttpObserve,\n      params?: HttpParams,\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\n/**\n * @experimental\n */\nexport type HttpObserve = 'body' | 'events' | 'response';\n/**\n * Perform HTTP requests.\n * \n * `HttpClient` is available as an injectable class, with methods to perform HTTP requests.\n * Each request method has multiple signatures, and the return type varies according to which\n * signature is called (mainly the values of `observe` and `responseType`).\n * \n * \\@experimental\n */\nexport class HttpClient {\n/**\n * @param {?} handler\n */\nconstructor(private handler: HttpHandler) {}\n\n  /**\n   * Send the given `HttpRequest` and return a stream of `HttpEvents`.\n   */\n  request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;\n\n  /**\n   * Construct a request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Construct a request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct a request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    params?: HttpParams,\n    observe: 'events', reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct a request which interprets the body as an `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct a request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct a request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    observe: 'events', params?: HttpParams, responseType?: 'json', withCredentials?: boolean,\n  }): Observable<HttpEvent<any>>;\n\n  /**\n   * Construct a request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `R`.\n   */\n  request<R>(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    observe: 'events', params?: HttpParams, responseType?: 'json', withCredentials?: boolean,\n  }): Observable<HttpEvent<R>>;\n\n  /**\n   * Construct a request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct a request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct a request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct a request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  request(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    observe: 'response', params?: HttpParams, responseType?: 'json', withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct a request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `R`.\n   */\n  request<R>(method: string, url: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    observe: 'response', params?: HttpParams, responseType?: 'json', withCredentials?: boolean,\n  }): Observable<HttpResponse<R>>;\n\n  /**\n   * Construct a request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  request(method: string, url: string, options?: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    responseType?: 'json',\n    reportProgress?: boolean,\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct a request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `R`.\n   */\n  request<R>(method: string, url: string, options?: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    responseType?: 'json',\n    reportProgress?: boolean,\n    withCredentials?: boolean,\n  }): Observable<R>;\n\n  /**\n   * Construct a request in a manner where response type and requested `Observable` are not known\n   * statically.\n   *\n   * @return an `Observable` of whatever was requested, typed to `any`.\n   */\n  request(method: string, url: string, options?: {\n    body?: any,\n    headers?: HttpHeaders,\n    params?: HttpParams,\n    observe?: HttpObserve,\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  }): Observable<any>;\n/**\n * Constructs an `Observable` for a particular HTTP request that, when subscribed,\n * fires the request through the chain of registered interceptors and on to the\n * server.\n * \n * This method can be called in one of two ways. Either an `HttpRequest`\n * instance can be passed directly as the only parameter, or a method can be\n * passed as the first parameter, a string URL as the second, and an\n * options hash as the third.\n * \n * If a `HttpRequest` object is passed directly, an `Observable` of the\n * raw `HttpEvent` stream will be returned.\n * \n * If a request is instead built by providing a URL, the options object\n * determines the return type of `request()`. In addition to configuring\n * request parameters such as the outgoing headers and/or the body, the options\n * hash specifies two key pieces of information about the request: the\n * `responseType` and what to `observe`.\n * \n * The `responseType` value determines how a successful response body will be\n * parsed. If `responseType` is the default `json`, a type interface for the\n * resulting object may be passed as a type parameter to `request()`.\n * \n * The `observe` value determines the return type of `request()`, based on what\n * the consumer is interested in observing. A value of `events` will return an\n * `Observable<HttpEvent>` representing the raw `HttpEvent` stream,\n * including progress events by default. A value of `response` will return an\n * `Observable<HttpResponse<T>>` where the `T` parameter of `HttpResponse`\n * depends on the `responseType` and any optionally provided type parameter.\n * A value of `body` will return an `Observable<T>` with the same `T` body type.\n * @param {?} first\n * @param {?=} url\n * @param {?=} options\n * @return {?}\n */\nrequest(first: string|HttpRequest<any>, url?: string, options: {\n    body?: any,\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    let /** @type {?} */ req: HttpRequest<any>;\n    // Firstly, 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 = /** @type {?} */(( first as HttpRequest<any>));\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      req = new HttpRequest(first, /** @type {?} */(( url)), options.body || null, {\n        headers: options.headers,\n        params: options.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 /** @type {?} */ events$: Observable<HttpEvent<any>> =\n        concatMap.call(of (req), (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 /** @type {?} */ res$: Observable<HttpResponse<any>> =\n        filter.call(events$, (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 map.call(res$, (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 map.call(res$, (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 map.call(res$, (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 map.call(res$, (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   * Construct a DELETE request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n\n  /**\n   * Construct a DELETE request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a DELETE request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct a DELETE request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as a `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `T`.\n   */\n  delete<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  delete (url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `T`.\n   */\n  delete<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Construct a DELETE request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as an `Object`.\n   */\n  delete (url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct a DELETE request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as type `T`.\n   */\n  delete<T>(url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * DELETE request to be executed on the server. See the individual overloads for\n * details of `delete()`'s return type based on the provided options.\n * @param {?} url\n * @param {?=} options\n * @return {?}\n */\ndelete (url: string, options: {\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('DELETE', url, /** @type {?} */(( options as any)));\n  }\n\n\n  /**\n   * Construct a GET request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Construct a GET request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a GET request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct a GET request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct a GET request which interprets the body as a `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct a GET request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct a GET request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Construct a GET request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `T`.\n   */\n  get<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Construct a GET request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct a GET request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct a GET request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct a GET request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  get(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct a GET request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `T`.\n   */\n  get<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Construct a GET request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as an `Object`.\n   */\n  get(url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct a GET request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as type `T`.\n   */\n  get<T>(url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * GET request to be executed on the server. See the individual overloads for\n * details of `get()`'s return type based on the provided options.\n * @param {?} url\n * @param {?=} options\n * @return {?}\n */\nget(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('GET', url, /** @type {?} */(( options as any)));\n  }\n\n\n  /**\n   * Construct a HEAD request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n\n    /**\n   * Construct a HEAD request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  }): Observable<ArrayBuffer>;\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a HEAD request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct a GET request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as a `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `T`.\n   */\n  head<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  head(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `T`.\n   */\n  head<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Construct a HEAD request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as an `Object`.\n   */\n  head(url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct a HEAD request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as type `T`.\n   */\n  head<T>(url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * HEAD request to be executed on the server. See the individual overloads for\n * details of `head()`'s return type based on the provided options.\n * @param {?} url\n * @param {?=} options\n * @return {?}\n */\nhead(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('HEAD', url, /** @type {?} */(( options as any)));\n  }\n\n  /**\n   * Construct a JSONP request for the given URL and name of the callback parameter.\n   *\n   * @return an `Observable` of the response object as an `Object`\n   */\n  jsonp(url: string, callbackParam: string): Observable<Object>;\n\n  /**\n   * Construct a JSONP request for the given URL and name of the callback parameter.\n   *\n   * @return an `Observable` of the response object as type `T`.\n   */\n  jsonp<T>(url: string, callbackParam: string): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause a request\n * with the special method `JSONP` to be dispatched via the interceptor pipeline.\n * \n * A suitable interceptor must be installed (e.g. via the `HttpClientJsonpModule`).\n * If no such interceptor is reached, then the `JSONP` request will likely be\n * rejected by the configured backend.\n * @template T\n * @param {?} url\n * @param {?} callbackParam\n * @return {?}\n */\njsonp<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   * Make an OPTIONS request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a OPTIONS request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as a `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `T`.\n   */\n  options<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  options(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `T`.\n   */\n  options<T>(url: string, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as an `Object`.\n   */\n  options(url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct an OPTIONS request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as type `T`.\n   */\n  options<T>(url: string, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * OPTIONS request to be executed on the server. See the individual overloads for\n * details of `options()`'s return type based on the provided options.\n * @param {?} url\n * @param {?=} options\n * @return {?}\n */\noptions(url: string, options: {\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  } = {}): Observable<any> {\n    return this.request<any>('OPTIONS', url, /** @type {?} */(( options as any)));\n  }\n\n  /**\n   * Construct a PATCH request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Construct a PATCH request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a PATCH request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct a PATCH request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as a `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `T`.\n   */\n  patch<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  patch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `T`.\n   */\n  patch<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Construct a PATCH request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as an `Object`.\n   */\n  patch(url: string, body: any|null, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct a PATCH request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as type `T`.\n   */\n  patch<T>(url: string, body: any|null, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * PATCH request to be executed on the server. See the individual overloads for\n * details of `patch()`'s return type based on the provided options.\n * @param {?} url\n * @param {?} body\n * @param {?=} options\n * @return {?}\n */\npatch(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\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   * Construct a POST request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Construct a POST request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a POST request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct a PATCH request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct a POST request which interprets the body as a `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct a POST request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct a POST request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Construct a POST request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `T`.\n   */\n  post<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Construct a POST request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct a POST request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct a POST request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct a POST request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  post(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct a POST request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `T`.\n   */\n  post<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Construct a POST request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as an `Object`.\n   */\n  post(url: string, body: any|null, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct a POST request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as type `T`.\n   */\n  post<T>(url: string, body: any|null, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * POST request to be executed on the server. See the individual overloads for\n * details of `post()`'s return type based on the provided options.\n * @param {?} url\n * @param {?} body\n * @param {?=} options\n * @return {?}\n */\npost(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\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   * Construct a PUT request which interprets the body as an `ArrayBuffer` and returns it.\n   *\n   * @return an `Observable` of the body as an `ArrayBuffer`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<ArrayBuffer>;\n\n  /**\n   * Construct a PUT request which interprets the body as a `Blob` and returns it.\n   *\n   * @return an `Observable` of the body as a `Blob`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<Blob>;\n\n  /**\n   * Construct a PUT request which interprets the body as text and returns it.\n   *\n   * @return an `Observable` of the body as a `string`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<string>;\n\n  /**\n   * Construct a PUT request which interprets the body as an `ArrayBuffer` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `ArrayBuffer`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * Construct a PUT request which interprets the body as a `Blob` and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Blob`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpEvent<Blob>>;\n\n  /**\n   * Construct a PUT request which interprets the body as text and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `string`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpEvent<string>>;\n\n  /**\n   * Construct a PUT request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `Object`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpEvent<Object>>;\n\n  /**\n   * Construct a PUT request which interprets the body as JSON and returns the full event stream.\n   *\n   * @return an `Observable` of all `HttpEvent`s for the request, with a body type of `T`.\n   */\n  put<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'events', responseType?: 'json', withCredentials?: boolean,\n  }): Observable<HttpEvent<T>>;\n\n  /**\n   * Construct a PUT request which interprets the body as an `ArrayBuffer` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `ArrayBuffer`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'arraybuffer', withCredentials?: boolean,\n  }): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * Construct a PUT request which interprets the body as a `Blob` and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Blob`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'blob', withCredentials?: boolean,\n  }): Observable<HttpResponse<Blob>>;\n\n  /**\n   * Construct a PUT request which interprets the body as text and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `string`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response', params?: HttpParams, reportProgress?: boolean,\n    responseType: 'text', withCredentials?: boolean,\n  }): Observable<HttpResponse<string>>;\n\n  /**\n   * Construct a PUT request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `Object`.\n   */\n  put(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<Object>>;\n\n  /**\n   * Construct a PUT request which interprets the body as JSON and returns the full response.\n   *\n   * @return an `Observable` of the `HttpResponse` for the request, with a body type of `T`.\n   */\n  put<T>(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe: 'response',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<HttpResponse<T>>;\n\n  /**\n   * Construct a PUT request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as an `Object`.\n   */\n  put(url: string, body: any|null, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<Object>;\n\n  /**\n   * Construct a PUT request which interprets the body as JSON and returns it.\n   *\n   * @return an `Observable` of the body as type `T`.\n   */\n  put<T>(url: string, body: any|null, options?: {\n    headers?: HttpHeaders,\n    observe?: 'body',\n    params?: HttpParams,\n    reportProgress?: boolean,\n    responseType?: 'json',\n    withCredentials?: boolean,\n  }): Observable<T>;\n/**\n * Constructs an `Observable` which, when subscribed, will cause the configured\n * POST request to be executed on the server. See the individual overloads for\n * details of `post()`'s return type based on the provided options.\n * @param {?} url\n * @param {?} body\n * @param {?=} options\n * @return {?}\n */\nput(url: string, body: any|null, options: {\n    headers?: HttpHeaders,\n    observe?: HttpObserve,\n    params?: HttpParams,\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  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: HttpHandler, },\n];\n}\n\nfunction HttpClient_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpClient.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nHttpClient.ctorParameters;\n/** @type {?} */\nHttpClient.prototype.handler;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n","/**\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\n\nimport {HttpHeaders} from './headers';\nexport type HttpEventType = number;\nexport let HttpEventType: any = {};\nHttpEventType.Sent = 0;\nHttpEventType.UploadProgress = 1;\nHttpEventType.ResponseHeader = 2;\nHttpEventType.DownloadProgress = 3;\nHttpEventType.Response = 4;\nHttpEventType.User = 5;\nHttpEventType[HttpEventType.Sent] = \"Sent\";\nHttpEventType[HttpEventType.UploadProgress] = \"UploadProgress\";\nHttpEventType[HttpEventType.ResponseHeader] = \"ResponseHeader\";\nHttpEventType[HttpEventType.DownloadProgress] = \"DownloadProgress\";\nHttpEventType[HttpEventType.Response] = \"Response\";\nHttpEventType[HttpEventType.User] = \"User\";\n\n\n/**\n * Base interface for progress events.\n *\n * @experimental\n */\nexport interface HttpProgressEvent {\n  /**\n   * Progress event type is either upload or download.\n   */\n  type: HttpEventType.DownloadProgress|HttpEventType.UploadProgress;\n\n  /**\n   * Number of bytes uploaded or downloaded.\n   */\n  loaded: number;\n\n  /**\n   * Total number of bytes to upload or download. Depending on the request or\n   * response, this may not be computable and thus may not be present.\n   */\n  total?: number;\n}\n\n/**\n * A download progress event.\n *\n * @experimental\n */\nexport interface HttpDownloadProgressEvent extends HttpProgressEvent {\n  type: HttpEventType.DownloadProgress;\n\n  /**\n   * The partial response body as downloaded so far.\n   *\n   * Only present if the responseType was `text`.\n   */\n  partialText?: string;\n}\n\n/**\n * An upload progress event.\n *\n * @experimental\n */\nexport interface HttpUploadProgressEvent extends HttpProgressEvent {\n  type: HttpEventType.UploadProgress;\n}\n\n/**\n * An event indicating that the request was sent to the server. Useful\n * when a request may be retried multiple times, to distinguish between\n * retries on the final event stream.\n *\n * @experimental\n */\nexport interface HttpSentEvent { type: HttpEventType.Sent; }\n\n/**\n * A user-defined event.\n *\n * Grouping all custom events under this type ensures they will be handled\n * and forwarded by all implementations of interceptors.\n *\n * @experimental\n */\nexport interface HttpUserEvent<T> { type: HttpEventType.User; }\n\n/**\n * An error that represents a failed attempt to JSON.parse text coming back\n * from the server.\n *\n * It bundles the Error object with the actual response body that failed to parse.\n *\n * @experimental\n */\nexport interface HttpJsonParseError {\n  error: Error;\n  text: string;\n}\n\n/**\n * Union type for all possible events on the response stream.\n *\n * Typed according to the expected type of the response.\n *\n * @experimental\n */\nexport type HttpEvent<T> =\n    HttpSentEvent | HttpHeaderResponse | HttpResponse<T>| HttpProgressEvent | HttpUserEvent<T>;\n/**\n * Base class for both `HttpResponse` and `HttpHeaderResponse`.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class HttpResponseBase {\n/**\n * All response headers.\n */\nreadonly headers: HttpHeaders;\n/**\n * Response status code.\n */\nreadonly status: number;\n/**\n * Textual description of response status code.\n * \n * Do not depend on this.\n */\nreadonly statusText: string;\n/**\n * URL of the resource retrieved, or null if not available.\n */\nreadonly url: string|null;\n/**\n * Whether the status code falls in the 2xx range.\n */\nreadonly ok: boolean;\n/**\n * Type of the response, narrowed to either the full response or the header.\n */\nreadonly type: HttpEventType.Response|HttpEventType.ResponseHeader;\n/**\n * Super-constructor for all responses.\n * \n * The single parameter accepted is an initialization hash. Any properties\n * of the response passed there will override the default values.\n * @param {?} init\n * @param {?=} defaultStatus\n * @param {?=} defaultStatusText\n */\nconstructor(\n      init: {\n        headers?: HttpHeaders,\n        status?: number,\n        statusText?: string,\n        url?: string,\n      },\n      defaultStatus: number = 200, defaultStatusText: string = 'OK') {\n    // If the hash has values passed, use them to initialize the response.\n    // Otherwise use the default values.\n    this.headers = init.headers || new HttpHeaders();\n    this.status = init.status !== undefined ? init.status : defaultStatus;\n    this.statusText = init.statusText || defaultStatusText;\n    this.url = init.url || null;\n\n    // Cache the ok value to avoid defining a getter.\n    this.ok = this.status >= 200 && this.status < 300;\n  }\n}\n\nfunction HttpResponseBase_tsickle_Closure_declarations() {\n/**\n * All response headers.\n * @type {?}\n */\nHttpResponseBase.prototype.headers;\n/**\n * Response status code.\n * @type {?}\n */\nHttpResponseBase.prototype.status;\n/**\n * Textual description of response status code.\n * \n * Do not depend on this.\n * @type {?}\n */\nHttpResponseBase.prototype.statusText;\n/**\n * URL of the resource retrieved, or null if not available.\n * @type {?}\n */\nHttpResponseBase.prototype.url;\n/**\n * Whether the status code falls in the 2xx range.\n * @type {?}\n */\nHttpResponseBase.prototype.ok;\n/**\n * Type of the response, narrowed to either the full response or the header.\n * @type {?}\n */\nHttpResponseBase.prototype.type;\n}\n\n/**\n * A partial HTTP response which only includes the status and header data,\n * but no response body.\n * \n * `HttpHeaderResponse` is a `HttpEvent` available on the response\n * event stream, only when progress events are requested.\n * \n * \\@experimental\n */\nexport class HttpHeaderResponse extends HttpResponseBase {\n/**\n * Create a new `HttpHeaderResponse` with the given parameters.\n * @param {?=} init\n */\nconstructor(init: {\n    headers?: HttpHeaders,\n    status?: number,\n    statusText?: string,\n    url?: string,\n  } = {}) {\n    super(init);\n  }\n\n  readonly type: HttpEventType.ResponseHeader = HttpEventType.ResponseHeader;\n/**\n * Copy this `HttpHeaderResponse`, overriding its contents with the\n * given parameter hash.\n * @param {?=} update\n * @return {?}\n */\nclone(update: {headers?: HttpHeaders; status?: number; statusText?: string; url?: string;} = {}):\n      HttpHeaderResponse {\n    // Perform a straightforward initialization of the new HttpHeaderResponse,\n    // overriding the current parameters with new ones if given.\n    return new HttpHeaderResponse({\n      headers: update.headers || this.headers,\n      status: update.status !== undefined ? update.status : this.status,\n      statusText: update.statusText || this.statusText,\n      url: update.url || this.url || undefined,\n    });\n  }\n}\n\nfunction HttpHeaderResponse_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpHeaderResponse.prototype.type;\n}\n\n/**\n * A full HTTP response, including a typed response body (which may be `null`\n * if one was not returned).\n * \n * `HttpResponse` is a `HttpEvent` available on the response event\n * stream.\n * \n * \\@experimental\n */\nexport class HttpResponse<T> extends HttpResponseBase {\n/**\n * The response body, or `null` if one was not returned.\n */\nreadonly body: T|null;\n/**\n * Construct a new `HttpResponse`.\n * @param {?=} init\n */\nconstructor(init: {\n    body?: T | null, headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  } = {}) {\n    super(init);\n    this.body = init.body || null;\n  }\n\n  readonly type: HttpEventType.Response = HttpEventType.Response;\n\n  clone(): HttpResponse<T>;\n  clone(update: {headers?: HttpHeaders; status?: number; statusText?: string; url?: string;}):\n      HttpResponse<T>;\n  clone<V>(update: {\n    body?: V | null, headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  }): HttpResponse<V>;\n/**\n * @param {?=} update\n * @return {?}\n */\nclone(update: {\n    body?: any | null; headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  } = {}): HttpResponse<any> {\n    return new HttpResponse<any>({\n      body: (update.body !== undefined) ? update.body : this.body,\n      headers: update.headers || this.headers,\n      status: (update.status !== undefined) ? update.status : this.status,\n      statusText: update.statusText || this.statusText,\n      url: update.url || this.url || undefined,\n    });\n  }\n}\n\nfunction HttpResponse_tsickle_Closure_declarations() {\n/**\n * The response body, or `null` if one was not returned.\n * @type {?}\n */\nHttpResponse.prototype.body;\n/** @type {?} */\nHttpResponse.prototype.type;\n}\n\n/**\n * A response that represents an error or failure, either from a\n * non-successful HTTP status, an error while executing the request,\n * or some other failure which occurred during the parsing of the response.\n * \n * Any error returned on the `Observable` response stream will be\n * wrapped in an `HttpErrorResponse` to provide additional context about\n * the state of the HTTP layer when the error occurred. The error property\n * will contain either a wrapped Error object or the error response returned\n * from the server.\n * \n * \\@experimental\n */\nexport class HttpErrorResponse extends HttpResponseBase implements Error {\n  readonly name = 'HttpErrorResponse';\n  readonly message: string;\n  readonly error: any|null;\n/**\n * Errors are never okay, even when the status code is in the 2xx success range.\n */\nreadonly ok = false;\n/**\n * @param {?} init\n */\nconstructor(init: {\n    error?: any; headers?: HttpHeaders; status?: number; statusText?: string; url?: string;\n  }) {\n    // Initialize with a default status of 0 / Unknown Error.\n    super(init, 0, 'Unknown Error');\n\n    // If the response was successful, then this was a parse error. Otherwise, it was\n    // a protocol-level failure of some sort. Either the request failed in transit\n    // or the server returned an unsuccessful status code.\n    if (this.status >= 200 && this.status < 300) {\n      this.message = `Http failure during parsing for ${init.url || '(unknown url)'}`;\n    } else {\n      this.message =\n          `Http failure response for ${init.url || '(unknown url)'}: ${init.status} ${init.statusText}`;\n    }\n    this.error = init.error || null;\n  }\n}\n\nfunction HttpErrorResponse_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpErrorResponse.prototype.name;\n/** @type {?} */\nHttpErrorResponse.prototype.message;\n/** @type {?} */\nHttpErrorResponse.prototype.error;\n/**\n * Errors are never okay, even when the status code is in the 2xx success range.\n * @type {?}\n */\nHttpErrorResponse.prototype.ok;\n}\n\n","/**\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\n\nimport {HttpHeaders} from './headers';\nimport {HttpParams} from './params';\n\n/**\n * Construction interface for `HttpRequest`s.\n *\n * All values are optional and will override default values if provided.\n */\ninterface HttpRequestInit {\n  headers?: HttpHeaders;\n  reportProgress?: boolean;\n  params?: HttpParams;\n  responseType?: 'arraybuffer'|'blob'|'json'|'text';\n  withCredentials?: boolean;\n}\n/**\n * Determine whether the given HTTP method may include a body.\n * @param {?} method\n * @return {?}\n */\nfunction mightHaveBody(method: string): boolean {\n  switch (method) {\n    case 'DELETE':\n    case 'GET':\n    case 'HEAD':\n    case 'OPTIONS':\n    case 'JSONP':\n      return false;\n    default:\n      return true;\n  }\n}\n/**\n * Safely assert whether the given value is an ArrayBuffer.\n * \n * In some execution environments ArrayBuffer is not defined.\n * @param {?} value\n * @return {?}\n */\nfunction isArrayBuffer(value: any): value is ArrayBuffer {\n  return typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;\n}\n/**\n * Safely assert whether the given value is a Blob.\n * \n * In some execution environments Blob is not defined.\n * @param {?} value\n * @return {?}\n */\nfunction isBlob(value: any): value is Blob {\n  return typeof Blob !== 'undefined' && value instanceof Blob;\n}\n/**\n * Safely assert whether the given value is a FormData instance.\n * \n * In some execution environments FormData is not defined.\n * @param {?} value\n * @return {?}\n */\nfunction isFormData(value: any): value is FormData {\n  return typeof FormData !== 'undefined' && value instanceof FormData;\n}\n/**\n * An outgoing HTTP request with an optional typed body.\n * \n * `HttpRequest` represents an outgoing request, including URL, method,\n * headers, body, and other request configuration options. Instances should be\n * assumed to be immutable. To modify a `HttpRequest`, the `clone`\n * method should be used.\n * \n * \\@experimental\n */\nexport class HttpRequest<T> {\n/**\n * The request body, or `null` if one isn't set.\n * \n * Bodies are not enforced to be immutable, as they can include a reference to any\n * user-defined data type. However, interceptors should take care to preserve\n * idempotence by treating them as such.\n */\nreadonly body: T|null = null;\n/**\n * Outgoing headers for this request.\n */\nreadonly headers: HttpHeaders;\n/**\n * Whether this request should be made in a way that exposes progress events.\n * \n * Progress events are expensive (change detection runs on each event) and so\n * they should only be requested if the consumer intends to monitor them.\n */\nreadonly reportProgress: boolean = false;\n/**\n * Whether this request should be sent with outgoing credentials (cookies).\n */\nreadonly withCredentials: boolean = false;\n/**\n * The expected response type of the server.\n * \n * This is used to parse the response appropriately before returning it to\n * the requestee.\n */\nreadonly responseType: 'arraybuffer'|'blob'|'json'|'text' = 'json';\n/**\n * The outgoing HTTP request method.\n */\nreadonly method: string;\n/**\n * Outgoing URL parameters.\n */\nreadonly params: HttpParams;\n/**\n * The outgoing URL with all URL parameters set.\n */\nreadonly urlWithParams: string;\n/**\n * @param {?} method\n * @param {?} url\n * @param {?=} init\n */\nconstructor(method: 'DELETE'|'GET'|'HEAD'|'JSONP'|'OPTIONS', url: string, init?: {\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    params?: HttpParams,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  });\n/**\n * @param {?} method\n * @param {?} url\n * @param {?} body\n * @param {?=} init\n */\nconstructor(method: 'POST'|'PUT'|'PATCH', url: string, body: T|null, init?: {\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    params?: HttpParams,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  });\n/**\n * @param {?} method\n * @param {?} url\n * @param {?} body\n * @param {?=} init\n */\nconstructor(method: string, url: string, body: T|null, init?: {\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    params?: HttpParams,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n  });\n/**\n * @param {?} method\n * @param {?} url\n * @param {?=} third\n * @param {?=} fourth\n */\nconstructor(\n      method: string, readonly url: string, third?: T|{\n        headers?: HttpHeaders,\n        reportProgress?: boolean,\n        params?: HttpParams,\n        responseType?: 'arraybuffer'|'blob'|'json'|'text',\n        withCredentials?: boolean,\n      }|null,\n      fourth?: {\n        headers?: HttpHeaders,\n        reportProgress?: boolean,\n        params?: HttpParams,\n        responseType?: 'arraybuffer'|'blob'|'json'|'text',\n        withCredentials?: boolean,\n      }) {\n    this.method = method.toUpperCase();\n    // Next, need to figure out which argument holds the HttpRequestInit\n    // options, if any.\n    let options: HttpRequestInit|undefined;\n\n    // Check whether a body argument is expected. The only valid way to omit\n    // the body argument is to use a known no-body method like GET.\n    if (mightHaveBody(this.method) || !!fourth) {\n      // Body is the third argument, options are the fourth.\n      this.body = third as T || null;\n      options = fourth;\n    } else {\n      // No body required, options are the third argument. The body stays null.\n      options = third as HttpRequestInit;\n    }\n\n    // If options have been passed, interpret them.\n    if (options) {\n      // Normalize reportProgress and withCredentials.\n      this.reportProgress = !!options.reportProgress;\n      this.withCredentials = !!options.withCredentials;\n\n      // Override default response type of 'json' if one is provided.\n      if (!!options.responseType) {\n        this.responseType = options.responseType;\n      }\n\n      // Override headers if they're provided.\n      if (!!options.headers) {\n        this.headers = options.headers;\n      }\n\n      if (!!options.params) {\n        this.params = options.params;\n      }\n    }\n\n    // If no headers have been passed in, construct a new HttpHeaders instance.\n    if (!this.headers) {\n      this.headers = new HttpHeaders();\n    }\n\n    // If no parameters have been passed in, construct a new HttpUrlEncodedParams instance.\n    if (!this.params) {\n      this.params = new HttpParams();\n      this.urlWithParams = url;\n    } else {\n      // Encode the parameters to a string in preparation for inclusion in the URL.\n      const params = this.params.toString();\n      if (params.length === 0) {\n        // No parameters, the visible URL is just the URL given at creation time.\n        this.urlWithParams = url;\n      } else {\n        // Does the URL already have query parameters? Look for '?'.\n        const qIdx = url.indexOf('?');\n        // There are 3 cases to handle:\n        // 1) No existing parameters -> append '?' followed by params.\n        // 2) '?' exists and is followed by existing query string ->\n        //    append '&' followed by params.\n        // 3) '?' exists at the end of the url -> append params directly.\n        // This basically amounts to determining the character, if any, with\n        // which to join the URL and parameters.\n        const sep: string = qIdx === -1 ? '?' : (qIdx < url.length - 1 ? '&' : '');\n        this.urlWithParams = url + sep + params;\n      }\n    }\n  }\n/**\n * Transform the free-form body into a serialized format suitable for\n * transmission to the server.\n * @return {?}\n */\nserializeBody(): ArrayBuffer|Blob|FormData|string|null {\n    // If no body is present, no need to serialize it.\n    if (this.body === null) {\n      return null;\n    }\n    // Check whether the body is already in a serialized form. If so,\n    // it can just be returned directly.\n    if (isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) ||\n        typeof this.body === 'string') {\n      return this.body;\n    }\n    // Check whether the body is an instance of HttpUrlEncodedParams.\n    if (this.body instanceof HttpParams) {\n      return this.body.toString();\n    }\n    // Check whether the body is an object or array, and serialize with JSON if so.\n    if (typeof this.body === 'object' || typeof this.body === 'boolean' ||\n        Array.isArray(this.body)) {\n      return JSON.stringify(this.body);\n    }\n    // Fall back on toString() for everything else.\n    return ( /** @type {?} */((this.body as any))).toString();\n  }\n/**\n * Examine the body and attempt to infer an appropriate MIME type\n * for it.\n * \n * If no such type can be inferred, this method will return `null`.\n * @return {?}\n */\ndetectContentTypeHeader(): string|null {\n    // An empty body has no content type.\n    if (this.body === null) {\n      return null;\n    }\n    // FormData bodies rely on the browser's content type assignment.\n    if (isFormData(this.body)) {\n      return null;\n    }\n    // Blobs usually have their own content type. If it doesn't, then\n    // no type can be inferred.\n    if (isBlob(this.body)) {\n      return this.body.type || null;\n    }\n    // Array buffers have unknown contents and thus no type can be inferred.\n    if (isArrayBuffer(this.body)) {\n      return null;\n    }\n    // Technically, strings could be a form of JSON data, but it's safe enough\n    // to assume they're plain strings.\n    if (typeof this.body === 'string') {\n      return 'text/plain';\n    }\n    // `HttpUrlEncodedParams` has its own content-type.\n    if (this.body instanceof HttpParams) {\n      return 'application/x-www-form-urlencoded;charset=UTF-8';\n    }\n    // Arrays, objects, and numbers will be encoded as JSON.\n    if (typeof this.body === 'object' || typeof this.body === 'number' ||\n        Array.isArray(this.body)) {\n      return 'application/json';\n    }\n    // No type could be inferred.\n    return null;\n  }\n\n  clone(): HttpRequest<T>;\n  clone(update: {\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    params?: HttpParams,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n    body?: T|null,\n    method?: string,\n    url?: string,\n    setHeaders?: {[name: string]: string | string[]},\n    setParams?: {[param: string]: string},\n  }): HttpRequest<T>;\n  clone<V>(update: {\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    params?: HttpParams,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n    body?: V|null,\n    method?: string,\n    url?: string,\n    setHeaders?: {[name: string]: string | string[]},\n    setParams?: {[param: string]: string},\n  }): HttpRequest<V>;\n/**\n * @param {?=} update\n * @return {?}\n */\nclone(update: {\n    headers?: HttpHeaders,\n    reportProgress?: boolean,\n    params?: HttpParams,\n    responseType?: 'arraybuffer'|'blob'|'json'|'text',\n    withCredentials?: boolean,\n    body?: any|null,\n    method?: string,\n    url?: string,\n    setHeaders?: {[name: string]: string | string[]},\n    setParams?: {[param: string]: string};\n  } = {}): HttpRequest<any> {\n    // For method, url, and responseType, take the current value unless\n    // it is overridden in the update hash.\n    const /** @type {?} */ method = update.method || this.method;\n    const /** @type {?} */ url = update.url || this.url;\n    const /** @type {?} */ responseType = update.responseType || this.responseType;\n\n    // The body is somewhat special - a `null` value in update.body means\n    // whatever current body is present is being overridden with an empty\n    // body, whereas an `undefined` value in update.body implies no\n    // override.\n    const /** @type {?} */ body = (update.body !== undefined) ? update.body : this.body;\n\n    // Carefully handle the boolean options to differentiate between\n    // `false` and `undefined` in the update args.\n    const /** @type {?} */ withCredentials =\n        (update.withCredentials !== undefined) ? update.withCredentials : this.withCredentials;\n    const /** @type {?} */ reportProgress =\n        (update.reportProgress !== undefined) ? update.reportProgress : this.reportProgress;\n\n    // Headers and params may be appended to if `setHeaders` or\n    // `setParams` are used.\n    let /** @type {?} */ headers = update.headers || this.headers;\n    let /** @type {?} */ params = update.params || this.params;\n\n    // Check whether the caller has asked to add headers.\n    if (update.setHeaders !== undefined) {\n      // Set every requested header.\n      headers =\n          Object.keys(update.setHeaders)\n              .reduce((headers, name) => headers.set(name, /** @type {?} */(( update.setHeaders))[name]), headers);\n    }\n\n    // Check whether the caller has asked to set params.\n    if (update.setParams) {\n      // Set every requested param.\n      params = Object.keys(update.setParams)\n                   .reduce((params, param) => params.set(param, /** @type {?} */(( update.setParams))[param]), params);\n    }\n\n    // Finally, construct the new HttpRequest using the pieces from above.\n    return new HttpRequest(\n        method, url, body, {\n                               params, headers, reportProgress, responseType, withCredentials,\n                           });\n  }\n}\n\nfunction HttpRequest_tsickle_Closure_declarations() {\n/**\n * The request body, or `null` if one isn't set.\n * \n * Bodies are not enforced to be immutable, as they can include a reference to any\n * user-defined data type. However, interceptors should take care to preserve\n * idempotence by treating them as such.\n * @type {?}\n */\nHttpRequest.prototype.body;\n/**\n * Outgoing headers for this request.\n * @type {?}\n */\nHttpRequest.prototype.headers;\n/**\n * Whether this request should be made in a way that exposes progress events.\n * \n * Progress events are expensive (change detection runs on each event) and so\n * they should only be requested if the consumer intends to monitor them.\n * @type {?}\n */\nHttpRequest.prototype.reportProgress;\n/**\n * Whether this request should be sent with outgoing credentials (cookies).\n * @type {?}\n */\nHttpRequest.prototype.withCredentials;\n/**\n * The expected response type of the server.\n * \n * This is used to parse the response appropriately before returning it to\n * the requestee.\n * @type {?}\n */\nHttpRequest.prototype.responseType;\n/**\n * The outgoing HTTP request method.\n * @type {?}\n */\nHttpRequest.prototype.method;\n/**\n * Outgoing URL parameters.\n * @type {?}\n */\nHttpRequest.prototype.params;\n/**\n * The outgoing URL with all URL parameters set.\n * @type {?}\n */\nHttpRequest.prototype.urlWithParams;\n}\n\n","/**\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\ninterface Update {\n  name: string;\n  value?: string|string[];\n  op: 'a'|'s'|'d';\n}\n/**\n * Immutable set of Http headers, with lazy parsing.\n * \\@experimental\n */\nexport class HttpHeaders {\n/**\n * Internal map of lowercase header names to values.\n */\nprivate headers: Map<string, string[]>;\n/**\n * Internal map of lowercased header names to the normalized\n * form of the name (the form seen first).\n */\nprivate normalizedNames: Map<string, string> = new Map();\n/**\n * Complete the lazy initialization of this object (needed before reading).\n */\nprivate lazyInit: HttpHeaders|Function|null;\n/**\n * Queued updates to be materialized the next initialization.\n */\nprivate lazyUpdate: Update[]|null = null;\n/**\n * @param {?=} headers\n */\nconstructor(headers?: string|{[name: string]: string | string[]}) {\n    if (!headers) {\n      this.headers = new Map<string, string[]>();\n    } else if (typeof headers === 'string') {\n      this.lazyInit = () => {\n        this.headers = new Map<string, string[]>();\n        headers.split('\\n').forEach(line => {\n          const index = line.indexOf(':');\n          if (index > 0) {\n            const name = line.slice(0, index);\n            const key = name.toLowerCase();\n            const value = line.slice(index + 1).trim();\n            this.maybeSetNormalizedName(name, key);\n            if (this.headers.has(key)) {\n              this.headers.get(key) !.push(value);\n            } else {\n              this.headers.set(key, [value]);\n            }\n          }\n        });\n      };\n    } else {\n      this.lazyInit = () => {\n        this.headers = new Map<string, string[]>();\n        Object.keys(headers).forEach(name => {\n          let values: string|string[] = headers[name];\n          const key = name.toLowerCase();\n          if (typeof values === 'string') {\n            values = [values];\n          }\n          if (values.length > 0) {\n            this.headers.set(key, values);\n            this.maybeSetNormalizedName(name, key);\n          }\n        });\n      };\n    }\n  }\n/**\n * Checks for existence of header by given name.\n * @param {?} name\n * @return {?}\n */\nhas(name: string): boolean {\n    this.init();\n\n    return this.headers.has(name.toLowerCase());\n  }\n/**\n * Returns first header that matches given name.\n * @param {?} name\n * @return {?}\n */\nget(name: string): string|null {\n    this.init();\n\n    const /** @type {?} */ values = this.headers.get(name.toLowerCase());\n    return values && values.length > 0 ? values[0] : null;\n  }\n/**\n * Returns the names of the headers\n * @return {?}\n */\nkeys(): string[] {\n    this.init();\n\n    return Array.from(this.normalizedNames.values());\n  }\n/**\n * Returns list of header values for a given name.\n * @param {?} name\n * @return {?}\n */\ngetAll(name: string): string[]|null {\n    this.init();\n\n    return this.headers.get(name.toLowerCase()) || null;\n  }\n/**\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nappend(name: string, value: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 'a'});\n  }\n/**\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\nset(name: string, value: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 's'});\n  }\n/**\n * @param {?} name\n * @param {?=} value\n * @return {?}\n */\ndelete (name: string, value?: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 'd'});\n  }\n/**\n * @param {?} name\n * @param {?} lcName\n * @return {?}\n */\nprivate maybeSetNormalizedName(name: string, lcName: string): void {\n    if (!this.normalizedNames.has(lcName)) {\n      this.normalizedNames.set(lcName, name);\n    }\n  }\n/**\n * @return {?}\n */\nprivate init(): void {\n    if (!!this.lazyInit) {\n      if (this.lazyInit instanceof HttpHeaders) {\n        this.copyFrom(this.lazyInit);\n      } else {\n        this.lazyInit();\n      }\n      this.lazyInit = null;\n      if (!!this.lazyUpdate) {\n        this.lazyUpdate.forEach(update => this.applyUpdate(update));\n        this.lazyUpdate = null;\n      }\n    }\n  }\n/**\n * @param {?} other\n * @return {?}\n */\nprivate copyFrom(other: HttpHeaders) {\n    other.init();\n    Array.from(other.headers.keys()).forEach(key => {\n      this.headers.set(key, /** @type {?} */(( other.headers.get(key))));\n      this.normalizedNames.set(key, /** @type {?} */(( other.normalizedNames.get(key))));\n    });\n  }\n/**\n * @param {?} update\n * @return {?}\n */\nprivate clone(update: Update): HttpHeaders {\n    const /** @type {?} */ clone = new HttpHeaders();\n    clone.lazyInit =\n        (!!this.lazyInit && this.lazyInit instanceof HttpHeaders) ? this.lazyInit : this;\n    clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);\n    return clone;\n  }\n/**\n * @param {?} update\n * @return {?}\n */\nprivate applyUpdate(update: Update): void {\n    const /** @type {?} */ key = update.name.toLowerCase();\n    switch (update.op) {\n      case 'a':\n      case 's':\n        let /** @type {?} */ value = /** @type {?} */(( update.value));\n        if (typeof value === 'string') {\n          value = [value];\n        }\n        if (value.length === 0) {\n          return;\n        }\n        this.maybeSetNormalizedName(update.name, key);\n        const /** @type {?} */ base = (update.op === 'a' ? this.headers.get(key) : undefined) || [];\n        base.push(...value);\n        this.headers.set(key, base);\n        break;\n      case 'd':\n        const /** @type {?} */ toDelete = /** @type {?} */(( update.value as string | undefined));\n        if (!toDelete) {\n          this.headers.delete(key);\n          this.normalizedNames.delete(key);\n        } else {\n          let /** @type {?} */ existing = this.headers.get(key);\n          if (!existing) {\n            return;\n          }\n          existing = existing.filter(value => toDelete.indexOf(value) === -1);\n          if (existing.length === 0) {\n            this.headers.delete(key);\n            this.normalizedNames.delete(key);\n          } else {\n            this.headers.set(key, existing);\n          }\n        }\n        break;\n    }\n  }\n/**\n * \\@internal\n * @param {?} fn\n * @return {?}\n */\nforEach(fn: (name: string, values: string[]) => void) {\n    this.init();\n    Array.from(this.normalizedNames.keys())\n        .forEach(key => fn( /** @type {?} */((this.normalizedNames.get(key))), /** @type {?} */(( this.headers.get(key)))));\n  }\n}\n\nfunction HttpHeaders_tsickle_Closure_declarations() {\n/**\n * Internal map of lowercase header names to values.\n * @type {?}\n */\nHttpHeaders.prototype.headers;\n/**\n * Internal map of lowercased header names to the normalized\n * form of the name (the form seen first).\n * @type {?}\n */\nHttpHeaders.prototype.normalizedNames;\n/**\n * Complete the lazy initialization of this object (needed before reading).\n * @type {?}\n */\nHttpHeaders.prototype.lazyInit;\n/**\n * Queued updates to be materialized the next initialization.\n * @type {?}\n */\nHttpHeaders.prototype.lazyUpdate;\n}\n\n","/**\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\n/**\n * A codec for encoding and decoding parameters in URLs.\n *\n * Used by `HttpParams`.\n *\n *  @experimental\n **/\nexport interface HttpParameterCodec {\n  encodeKey(key: string): string;\n  encodeValue(value: string): string;\n\n  decodeKey(key: string): string;\n  decodeValue(value: string): string;\n}\n/**\n * A `HttpParameterCodec` that uses `encodeURIComponent` and `decodeURIComponent` to\n * serialize and parse URL parameter keys and values.\n * \n * \\@experimental\n */\nexport class HttpUrlEncodingCodec implements HttpParameterCodec {\n/**\n * @param {?} k\n * @return {?}\n */\nencodeKey(k: string): string { return standardEncoding(k); }\n/**\n * @param {?} v\n * @return {?}\n */\nencodeValue(v: string): string { return standardEncoding(v); }\n/**\n * @param {?} k\n * @return {?}\n */\ndecodeKey(k: string): string { return decodeURIComponent(k); }\n/**\n * @param {?} v\n * @return {?}\n */\ndecodeValue(v: string) { return decodeURIComponent(v); }\n}\n/**\n * @param {?} rawParams\n * @param {?} codec\n * @return {?}\n */\nfunction paramParser(rawParams: string, codec: HttpParameterCodec): Map<string, string[]> {\n  const /** @type {?} */ map = new Map<string, string[]>();\n  if (rawParams.length > 0) {\n    const /** @type {?} */ params: string[] = rawParams.split('&');\n    params.forEach((param: string) => {\n      const /** @type {?} */ eqIdx = param.indexOf('=');\n      const [key, val]: string[] = eqIdx == -1 ?\n          [codec.decodeKey(param), ''] :\n          [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))];\n      const /** @type {?} */ list = map.get(key) || [];\n      list.push(val);\n      map.set(key, list);\n    });\n  }\n  return map;\n}\n/**\n * @param {?} v\n * @return {?}\n */\nfunction standardEncoding(v: string): string {\n  return encodeURIComponent(v)\n      .replace(/%40/gi, '@')\n      .replace(/%3A/gi, ':')\n      .replace(/%24/gi, '$')\n      .replace(/%2C/gi, ',')\n      .replace(/%3B/gi, ';')\n      .replace(/%2B/gi, '+')\n      .replace(/%3D/gi, '=')\n      .replace(/%3F/gi, '?')\n      .replace(/%2F/gi, '/');\n}\n\ninterface Update {\n  param: string;\n  value?: string;\n  op: 'a'|'d'|'s';\n}\n/**\n * An HTTP request/response body that represents serialized parameters,\n * per the MIME type `application/x-www-form-urlencoded`.\n * \n * This class is immuatable - all mutation operations return a new instance.\n * \n * \\@experimental\n */\nexport class HttpParams {\nprivate map: Map<string, string[]>|null;\nprivate encoder: HttpParameterCodec;\nprivate updates: Update[]|null = null;\nprivate cloneFrom: HttpParams|null = null;\n/**\n * @param {?=} options\n */\nconstructor(options: {\n    fromString?: string,\n    encoder?: HttpParameterCodec,\n  } = {}) {\n    this.encoder = options.encoder || new HttpUrlEncodingCodec();\n    this.map = !!options.fromString ? paramParser(options.fromString, this.encoder) : null;\n  }\n/**\n * Check whether the body has one or more values for the given parameter name.\n * @param {?} param\n * @return {?}\n */\nhas(param: string): boolean {\n    this.init();\n    return /** @type {?} */(( this.map)).has(param);\n  }\n/**\n * Get the first value for the given parameter name, or `null` if it's not present.\n * @param {?} param\n * @return {?}\n */\nget(param: string): string|null {\n    this.init();\n    const /** @type {?} */ res = /** @type {?} */(( this.map)).get(param);\n    return !!res ? res[0] : null;\n  }\n/**\n * Get all values for the given parameter name, or `null` if it's not present.\n * @param {?} param\n * @return {?}\n */\ngetAll(param: string): string[]|null {\n    this.init();\n    return /** @type {?} */(( this.map)).get(param) || null;\n  }\n/**\n * Get all the parameter names for this body.\n * @return {?}\n */\nkeys(): string[] {\n    this.init();\n    return Array.from( /** @type {?} */((this.map)).keys());\n  }\n/**\n * Construct a new body with an appended value for the given parameter name.\n * @param {?} param\n * @param {?} value\n * @return {?}\n */\nappend(param: string, value: string): HttpParams { return this.clone({param, value, op: 'a'}); }\n/**\n * Construct a new body with a new value for the given parameter name.\n * @param {?} param\n * @param {?} value\n * @return {?}\n */\nset(param: string, value: string): HttpParams { return this.clone({param, value, op: 's'}); }\n/**\n * Construct a new body with either the given value for the given parameter\n * removed, if a value is given, or all values for the given parameter removed\n * if not.\n * @param {?} param\n * @param {?=} value\n * @return {?}\n */\ndelete (param: string, value?: string): HttpParams { return this.clone({param, value, op: 'd'}); }\n/**\n * Serialize the body to an encoded string, where key-value pairs (separated by `=`) are\n * separated by `&`s.\n * @return {?}\n */\ntoString(): string {\n    this.init();\n    return this.keys()\n        .map(key => {\n          const /** @type {?} */ eKey = this.encoder.encodeKey(key);\n          return /** @type {?} */(( /** @type {?} */(( this.map)).get(key))).map(value => eKey + '=' + this.encoder.encodeValue(value))\n              .join('&');\n        })\n        .join('&');\n  }\n/**\n * @param {?} update\n * @return {?}\n */\nprivate clone(update: Update): HttpParams {\n    const /** @type {?} */ clone = new HttpParams({encoder: this.encoder});\n    clone.cloneFrom = this.cloneFrom || this;\n    clone.updates = (this.updates || []).concat([update]);\n    return clone;\n  }\n/**\n * @return {?}\n */\nprivate init() {\n    if (this.map === null) {\n      this.map = new Map<string, string[]>();\n    }\n    if (this.cloneFrom !== null) {\n      this.cloneFrom.init();\n      this.cloneFrom.keys().forEach(key => /** @type {?} */(( this.map)).set(key, /** @type {?} */(( /** @type {?} */(( /** @type {?} */(( this.cloneFrom)).map)).get(key))))); /** @type {?} */((\n      this.updates)).forEach(update => {\n        switch (update.op) {\n          case 'a':\n          case 's':\n            const /** @type {?} */ base = (update.op === 'a' ? /** @type {?} */(( this.map)).get(update.param) : undefined) || [];\n            base.push( /** @type {?} */((update.value))); /** @type {?} */((\n            this.map)).set(update.param, base);\n            break;\n          case 'd':\n            if (update.value !== undefined) {\n              let /** @type {?} */ base = /** @type {?} */(( this.map)).get(update.param) || [];\n              const /** @type {?} */ idx = base.indexOf(update.value);\n              if (idx !== -1) {\n                base.splice(idx, 1);\n              }\n              if (base.length > 0) { /** @type {?} */((\n                this.map)).set(update.param, base);\n              } else { /** @type {?} */((\n                this.map)).delete(update.param);\n              }\n            } else { /** @type {?} */((\n              this.map)).delete(update.param);\n              break;\n            }\n        }\n      });\n      this.cloneFrom = null;\n    }\n  }\n}\n\nfunction HttpParams_tsickle_Closure_declarations() {\n/** @type {?} */\nHttpParams.prototype.map;\n/** @type {?} */\nHttpParams.prototype.encoder;\n/** @type {?} */\nHttpParams.prototype.updates;\n/** @type {?} */\nHttpParams.prototype.cloneFrom;\n}\n\n","/**\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\n\nimport {Observable} from 'rxjs/Observable';\nimport {HttpRequest} from './request';\nimport {HttpEvent} from './response';\n/**\n * Transforms an `HttpRequest` into a stream of `HttpEvent`s, one of which will likely be a\n * `HttpResponse`.\n * \n * `HttpHandler` is injectable. When injected, the handler instance dispatches requests to the\n * first interceptor in the chain, which dispatches to the second, etc, eventually reaching the\n * `HttpBackend`.\n * \n * In an `HttpInterceptor`, the `HttpHandler` parameter is the next interceptor in the chain.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class HttpHandler {\n/**\n * @abstract\n * @param {?} req\n * @return {?}\n */\nhandle(req: HttpRequest<any>) {}\n}\n/**\n * A final `HttpHandler` which will dispatch the request via browser HTTP APIs to a backend.\n * \n * Interceptors sit between the `HttpClient` interface and the `HttpBackend`.\n * \n * When injected, `HttpBackend` dispatches requests directly to the backend, without going\n * through the interceptor chain.\n * \n * \\@experimental\n * @abstract\n */\nexport abstract class HttpBackend implements HttpHandler {\n/**\n * @abstract\n * @param {?} req\n * @return {?}\n */\nhandle(req: HttpRequest<any>) {}\n}\n"],"names":["parseCookieValue","map"],"mappings":"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"}