| /** |
| * @license Angular v8.1.1 |
| * (c) 2010-2019 Google LLC. https://angular.io/ |
| * License: MIT |
| */ |
| |
| import { InjectionToken } from '@angular/core';
|
| import { Injector } from '@angular/core';
|
| import { ModuleWithProviders } from '@angular/core';
|
| import { Observable } from 'rxjs';
|
|
|
| /**
|
| * A multi-provider token which represents the array of `HttpInterceptor`s that
|
| * are registered.
|
| *
|
| * @publicApi
|
| */
|
| export declare const HTTP_INTERCEPTORS: InjectionToken<HttpInterceptor[]>;
|
|
|
| /**
|
| * A final `HttpHandler` which will dispatch the request via browser HTTP APIs to a backend.
|
| *
|
| * Interceptors sit between the `HttpClient` interface and the `HttpBackend`.
|
| *
|
| * When injected, `HttpBackend` dispatches requests directly to the backend, without going
|
| * through the interceptor chain.
|
| *
|
| * @publicApi
|
| */
|
| export declare abstract class HttpBackend implements HttpHandler {
|
| abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
|
| }
|
|
|
| /**
|
| * Performs HTTP requests.
|
| *
|
| * `HttpClient` is available as an injectable class, with methods to perform HTTP requests.
|
| * Each request method has multiple signatures, and the return type varies based on
|
| * the signature that is called (mainly the values of `observe` and `responseType`).
|
| *
|
| *
|
| * @see [HTTP Guide](guide/http)
|
| *
|
| *
|
| * @usageNotes
|
| * Sample HTTP requests for the [Tour of Heroes](/tutorial/toh-pt0) application.
|
| *
|
| * ### HTTP Request Example
|
| *
|
| * ```
|
| * // GET heroes whose name contains search term
|
| * searchHeroes(term: string): observable<Hero[]>{
|
| *
|
| * const params = new HttpParams({fromString: 'name=term'});
|
| * return this.httpClient.request('GET', this.heroesUrl, {responseType:'json', params});
|
| * }
|
| * ```
|
| * ### JSONP Example
|
| * ```
|
| * requestJsonp(url, callback = 'callback') {
|
| * return this.httpClient.jsonp(this.heroesURL, callback);
|
| * }
|
| * ```
|
| *
|
| *
|
| * ### PATCH Example
|
| * ```
|
| * // PATCH one of the heroes' name
|
| * patchHero (id: number, heroName: string): Observable<{}> {
|
| * const url = `${this.heroesUrl}/${id}`; // PATCH api/heroes/42
|
| * return this.httpClient.patch(url, {name: heroName}, httpOptions)
|
| * .pipe(catchError(this.handleError('patchHero')));
|
| * }
|
| * ```
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpClient {
|
| private handler;
|
| constructor(handler: HttpHandler);
|
| /**
|
| * Sends an `HTTPRequest` and returns a stream of `HTTPEvents`.
|
| *
|
| * @return An `Observable` of the response, with the response body as a stream of `HTTPEvents`.
|
| */
|
| request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;
|
| /**
|
| * Constructs a request that interprets the body as an `ArrayBuffer` and returns the response in an
|
| * `ArrayBuffer`.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| *
|
| * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs a request that interprets the body as a blob and returns
|
| * the response as a blob.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type `Blob`.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs a request that interprets the body as a text string and
|
| * returns a string value.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type string.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs a request that interprets the body as an `ArrayBuffer` and returns the
|
| * the full event stream.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body as an array of `HTTPEvents` for the
|
| * request.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| observe: 'events';
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs a request that interprets the body as a `Blob` and returns
|
| * the full event stream.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of of all `HttpEvents` for the request,
|
| * with the response body of type `Blob`.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs a request which interprets the body as a text string and returns the full event stream.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the reques,
|
| * with the response body of type string.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs a request which interprets the body as a JSON object and returns the full event stream.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body of type `Object`.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<any>>;
|
| /**
|
| * Constructs a request which interprets the body as a JSON object and returns the full event stream.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body of type `R`.
|
| */
|
| request<R>(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<R>>;
|
| /**
|
| * Constructs a request which interprets the body as an `ArrayBuffer`
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with the response body as an `ArrayBuffer`.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs a request which interprets the body as a `Blob` and returns the full `HTTPResponse`.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with the response body of type `Blob`.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs a request which interprets the body as a text stream and returns the full `HTTPResponse`.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the HTTP response, with the response body of type string.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs a request which interprets the body as a JSON object and returns the full `HTTPResponse`.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the full `HTTPResponse`,
|
| * with the response body of type `Object`.
|
| */
|
| request(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs a request which interprets the body as a JSON object and returns
|
| * the full `HTTPResponse` with the response body in the requested type.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the full `HTTPResponse`, with the response body of type `R`.
|
| */
|
| request<R>(method: string, url: string, options: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<R>>;
|
| /**
|
| * Constructs a request which interprets the body as a JSON object and returns the full
|
| * `HTTPResponse` as a JSON object.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with the response body of type `Object`.
|
| */
|
| request(method: string, url: string, options?: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| responseType?: 'json';
|
| reportProgress?: boolean;
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs a request which interprets the body as a JSON object
|
| * with the response body of the requested type.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with the response body of type `R`.
|
| */
|
| request<R>(method: string, url: string, options?: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| responseType?: 'json';
|
| reportProgress?: boolean;
|
| withCredentials?: boolean;
|
| }): Observable<R>;
|
| /**
|
| * Constructs a request where response type and requested observable are not known statically.
|
| *
|
| * @param method The HTTP method.
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the reuested response, wuth body of type `any`.
|
| */
|
| request(method: string, url: string, options?: {
|
| body?: any;
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| observe?: HttpObserve;
|
| reportProgress?: boolean;
|
| responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
|
| withCredentials?: boolean;
|
| }): Observable<any>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
|
| * and returns the response as an `ArrayBuffer`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response body as an `ArrayBuffer`.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a `Blob` and returns
|
| * the response as a `Blob`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response body as a `Blob`.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a text string and returns
|
| * a string.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type string.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HTTPEvents` for the request,
|
| * with response body as an `ArrayBuffer`.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a `Blob`
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all the `HTTPEvents` for the request, with the response body as a
|
| * `Blob`.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a text string
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HTTPEvents` for the request, with the response
|
| * body of type string.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a JSON object
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HTTPEvents` for the request, with response body of
|
| * type `Object`.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Object>>;
|
| /**
|
| * Constructs a `DELETE`request that interprets the body as a JSON object
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all the `HTTPEvents` for the request, with a response
|
| * body in the requested type.
|
| */
|
| delete<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<T>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer` and returns
|
| * the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the full `HTTPResponse`, with the response body as an `ArrayBuffer`.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a `Blob` and returns the full
|
| * `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with the response body of type `Blob`.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a text stream and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the full `HTTPResponse`, with the response body of type string.
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs a `DELETE` request the interprets the body as a JSON object and returns
|
| * the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with the response body of type `Object`.
|
| *
|
| */
|
| delete(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a JSON object
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with the response body of the requested type.
|
| */
|
| delete<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<T>>;
|
| /**
|
| * Constructs a `DELETE` request that interprets the body as a JSON object and
|
| * returns the response body as a JSON object.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type `Object`.
|
| */
|
| delete(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs a DELETE request that interprets the body as a JSON object and returns
|
| * the response in a given type.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with response body in the requested type.
|
| */
|
| delete<T>(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<T>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the response in
|
| * an `ArrayBuffer`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a `Blob`
|
| * and returns the response as a `Blob`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body as a `Blob`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a text string
|
| * and returns the response as a string value.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type string.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns
|
| * the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request, with the response
|
| * body as an `ArrayBuffer`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a `Blob` and
|
| * returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body as a `Blob`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a text string and returns
|
| * the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type string.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a JSON object
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type `Object`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Object>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a JSON object and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with a response body in the requested type.
|
| */
|
| get<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<T>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a `Blob` and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a text stream and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body of type string.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a JSON object and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the full `HttpResponse`,
|
| * with the response body of type `Object`.
|
| */
|
| get(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a JSON object and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the full `HTTPResponse` for the request,
|
| * with a response body in the requested type.
|
| */
|
| get<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<T>>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a JSON object and
|
| * returns the response body as a JSON object.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| *
|
| * @return An `Observable` of the response body as a JSON object.
|
| */
|
| get(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs a `GET` request that interprets the body as a JSON object and returns
|
| * the response body in a given type.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with a response body in the requested type.
|
| */
|
| get<T>(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<T>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
|
| * returns the response as an `ArrayBuffer`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a `Blob` and returns
|
| * the response as a `Blob`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body as a `Blob`.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a text string and returns the response
|
| * as a string value.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body of type string.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer`
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of tall `HttpEvents` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a `Blob` and
|
| * returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a text string
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all HttpEvents for the request, with the response body of type string.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a JSON object
|
| * and returns the full HTTP event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of all `HTTPEvents` for the request, with a response body of
|
| * type `Object`.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Object>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a JSON object and
|
| * returns the full event stream.
|
| *
|
| * @return An `Observable` of all the `HTTPEvents` for the request
|
| * , with a response body in the requested type.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| */
|
| head<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<T>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer`
|
| * and returns the full HTTP response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a `Blob` and returns
|
| * the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body as a blob.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as text stream
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body of type string.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a JSON object and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body of type `Object`.
|
| */
|
| head(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a JSON object
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with a responmse body of the requested type.
|
| */
|
| head<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<T>>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a JSON object and
|
| * returns the response body as a JSON object.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the response, with the response body as a JSON object.
|
| */
|
| head(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs a `HEAD` request that interprets the body as a JSON object and returns
|
| * the response in a given type.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options The HTTP options to send with the request.
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with a response body of the given type.
|
| */
|
| head<T>(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<T>;
|
| /**
|
| * Constructs a `JSONP` request for the given URL and name of the callback parameter.
|
| *
|
| * @param url The resource URL.
|
| * @param callbackParam The callback function name.
|
| *
|
| * @return An `Observable` of the response object, with response body as an object.
|
| */
|
| jsonp(url: string, callbackParam: string): Observable<Object>;
|
| /**
|
| * Constructs a `JSONP` request for the given URL and name of the callback parameter.
|
| *
|
| * @param url The resource URL.
|
| * @param callbackParam The callback function name.
|
| *
|
| * You must install a suitable interceptor, such as one provided by `HttpClientJsonpModule`.
|
| * If no such interceptor is reached,
|
| * then the `JSONP` request can be rejected by the configured backend.
|
| *
|
| * @return An `Observable` of the response object, with response body in the requested type.
|
| */
|
| jsonp<T>(url: string, callbackParam: string): Observable<T>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as an
|
| * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a `Blob` and returns
|
| * the response as a `Blob`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body as a `Blob`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a text string and
|
| * returns a string value.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body of type string.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a `Blob` and
|
| * returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a text string
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HTTPEvents` for the request,
|
| * with the response body of type string.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a JSON object
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HttpEvents` for the request with the response
|
| * body of type `Object`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Object>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a JSON object and
|
| * returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HttpEvents` for the request,
|
| * with a response body in the requested type.
|
| */
|
| options<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<T>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`
|
| * and returns the full HTTP response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a `Blob`
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as text stream
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with the response body of type string.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a JSON object
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with the response body of type `Object`.
|
| */
|
| options(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a JSON object and
|
| * returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with a response body in the requested type.
|
| */
|
| options<T>(url: string, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<T>>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a JSON object and returns the response
|
| * body as a JSON object.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body as a JSON object.
|
| */
|
| options(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs an `OPTIONS` request that interprets the body as a JSON object and returns the response
|
| * in a given type.
|
| *
|
| * @param url The endpoint URL.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HTTPResponse`, with a response body of the given type.
|
| */
|
| options<T>(url: string, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<T>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
|
| * the response as an `ArrayBuffer`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a `Blob` and returns the response
|
| * as a `Blob`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body as a `Blob`.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as as a text string and
|
| * returns the response as a string value.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with a response body of type string.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and
|
| * returns the the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HTTPevents` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a `Blob`
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HTTPevents` for the request, with the
|
| * response body as `Blob`.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a text string and
|
| * returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HTTPevents`for the request, with a
|
| * response body of type string.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a JSON object
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HTTPevents` for the request,
|
| * with a response body of type `Object`.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Object>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a JSON object
|
| * and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of all the `HTTPevents` for the request,
|
| * with a response body in the requested type.
|
| */
|
| patch<T>(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<T>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer`
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a `Blob` and returns the full
|
| * `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a text stream and returns the
|
| * full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with a response body of type string.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a JSON object
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with a response body in the requested type.
|
| */
|
| patch(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a JSON object
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with a response body in the given type.
|
| */
|
| patch<T>(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<T>>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a JSON object and
|
| * returns the response body as a JSON object.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body as a JSON object.
|
| */
|
| patch(url: string, body: any | null, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs a `PATCH` request that interprets the body as a JSON object
|
| * and returns the response in a given type.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to edit.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the `HttpResponse` for the request,
|
| * with a response body in the given type.
|
| */
|
| patch<T>(url: string, body: any | null, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<T>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as an as an `ArrayBuffer` and returns
|
| * an `ArrayBuffer`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options.
|
| *
|
| * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a `Blob` and returns the
|
| * response as a `Blob`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the response, with the response body as a `Blob`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a text string and
|
| * returns the response as a string value.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the response, with a response body of type string.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and
|
| * returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a `Blob`
|
| * and returns the response in an observable of the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request, with the response body as `Blob`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a text string and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with a response body of type string.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs a POST request that interprets the body as a JSON object and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with a response body of type `Object`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Object>>;
|
| /**
|
| * Constructs a POST request that interprets the body as a JSON object and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with a response body in the requested type.
|
| */
|
| post<T>(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<T>>;
|
| /**
|
| * Constructs a POST request that interprets the body as an `ArrayBuffer`
|
| * and returns the full `HTTPresponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with the response body as an `ArrayBuffer`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a `Blob` and returns the full
|
| * `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a text stream and returns
|
| * the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with a response body of type string.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a JSON object
|
| * and returns the full `HTTPResponse`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with a response body of type
|
| * `Object`.
|
| */
|
| post(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a JSON object and returns the full
|
| * `HTTPResponse`.
|
| *
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with a response body in the requested type.
|
| */
|
| post<T>(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<T>>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a
|
| * JSON object and returns the response body as a JSON object.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the response, with the response body as a JSON object.
|
| */
|
| post(url: string, body: any | null, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs a `POST` request that interprets the body as a JSON object
|
| * and returns an observable of the response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The content to replace with.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with a response body in the requested type.
|
| */
|
| post<T>(url: string, body: any | null, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<T>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
|
| * response as an `ArrayBuffer`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<ArrayBuffer>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a `Blob` and returns
|
| * the response as a `Blob`.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the response, with the response body as a `Blob`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<Blob>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a text string and
|
| * returns the response as a string value.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the response, with a response body of type string.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<string>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and
|
| * returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body as an `ArrayBuffer`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<ArrayBuffer>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a `Blob` and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Blob>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a text string and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all HttpEvents for the request, with a response body
|
| * of type string.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<string>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a JSON object and returns the full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request, with a response body of
|
| * type `Object`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<Object>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a JSON object and returns the
|
| * full event stream.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of all `HttpEvents` for the request,
|
| * with a response body in the requested type.
|
| */
|
| put<T>(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'events';
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpEvent<T>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as an
|
| * `ArrayBuffer` and returns an observable of the full HTTP response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with the response body as an `ArrayBuffer`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'arraybuffer';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<ArrayBuffer>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a `Blob` and returns the
|
| * full HTTP response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with the response body as a `Blob`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'blob';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Blob>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a text stream and returns the
|
| * full HTTP response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with a response body of type string.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType: 'text';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<string>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a JSON object and returns the full HTTP response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with a response body
|
| * of type 'Object`.
|
| */
|
| put(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<Object>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a JSON object and returns the full HTTP response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request,
|
| * with a response body in the requested type.
|
| */
|
| put<T>(url: string, body: any | null, options: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe: 'response';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<HttpResponse<T>>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a JSON object and returns the response
|
| * body as a JSON object.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the response, with the response body as a JSON object.
|
| */
|
| put(url: string, body: any | null, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<Object>;
|
| /**
|
| * Constructs a `PUT` request that interprets the body as a JSON object
|
| * and returns an observable of the response.
|
| *
|
| * @param url The endpoint URL.
|
| * @param body The resources to add/update.
|
| * @param options HTTP options
|
| *
|
| * @return An `Observable` of the `HTTPResponse` for the request, with a response body in the requested type.
|
| */
|
| put<T>(url: string, body: any | null, options?: {
|
| headers?: HttpHeaders | {
|
| [header: string]: string | string[];
|
| };
|
| observe?: 'body';
|
| params?: HttpParams | {
|
| [param: string]: string | string[];
|
| };
|
| reportProgress?: boolean;
|
| responseType?: 'json';
|
| withCredentials?: boolean;
|
| }): Observable<T>;
|
| }
|
|
|
| /**
|
| * Configures the [dependency injector](guide/glossary#injector) for `HttpClient`
|
| * with supporting services for JSONP.
|
| * Without this module, Jsonp requests reach the backend
|
| * with method JSONP, where they are rejected.
|
| *
|
| * You can add interceptors to the chain behind `HttpClient` by binding them to the
|
| * multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpClientJsonpModule {
|
| }
|
|
|
| /**
|
| * Configures the [dependency injector](guide/glossary#injector) for `HttpClient`
|
| * with supporting services for XSRF. Automatically imported by `HttpClientModule`.
|
| *
|
| * You can add interceptors to the chain behind `HttpClient` by binding them to the
|
| * multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpClientModule {
|
| }
|
|
|
| /**
|
| * Configures XSRF protection support for outgoing requests.
|
| *
|
| * For a server that supports a cookie-based XSRF protection system,
|
| * use directly to configure XSRF protection with the correct
|
| * cookie and header names.
|
| *
|
| * If no names are supplied, the default cookie name is `XSRF-TOKEN`
|
| * and the default header name is `X-XSRF-TOKEN`.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpClientXsrfModule {
|
| /**
|
| * Disable the default XSRF protection.
|
| */
|
| static disable(): ModuleWithProviders<HttpClientXsrfModule>;
|
| /**
|
| * Configure XSRF protection.
|
| * @param options An object that can specify either or both
|
| * cookie name or header name.
|
| * - Cookie name default is `XSRF-TOKEN`.
|
| * - Header name default is `X-XSRF-TOKEN`.
|
| *
|
| */
|
| static withOptions(options?: {
|
| cookieName?: string;
|
| headerName?: string;
|
| }): ModuleWithProviders<HttpClientXsrfModule>;
|
| }
|
|
|
| /**
|
| * A download progress event.
|
| *
|
| * @publicApi
|
| */
|
| export declare interface HttpDownloadProgressEvent extends HttpProgressEvent {
|
| type: HttpEventType.DownloadProgress;
|
| /**
|
| * The partial response body as downloaded so far.
|
| *
|
| * Only present if the responseType was `text`.
|
| */
|
| partialText?: string;
|
| }
|
|
|
| /**
|
| * A response that represents an error or failure, either from a
|
| * non-successful HTTP status, an error while executing the request,
|
| * or some other failure which occurred during the parsing of the response.
|
| *
|
| * Any error returned on the `Observable` response stream will be
|
| * wrapped in an `HttpErrorResponse` to provide additional context about
|
| * the state of the HTTP layer when the error occurred. The error property
|
| * will contain either a wrapped Error object or the error response returned
|
| * from the server.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpErrorResponse extends HttpResponseBase implements Error {
|
| readonly name = "HttpErrorResponse";
|
| readonly message: string;
|
| readonly error: any | null;
|
| /**
|
| * Errors are never okay, even when the status code is in the 2xx success range.
|
| */
|
| readonly ok = false;
|
| constructor(init: {
|
| error?: any;
|
| headers?: HttpHeaders;
|
| status?: number;
|
| statusText?: string;
|
| url?: string;
|
| });
|
| }
|
|
|
| /**
|
| * Union type for all possible events on the response stream.
|
| *
|
| * Typed according to the expected type of the response.
|
| *
|
| * @publicApi
|
| */
|
| export declare type HttpEvent<T> = HttpSentEvent | HttpHeaderResponse | HttpResponse<T> | HttpProgressEvent | HttpUserEvent<T>;
|
|
|
| /**
|
| * Type enumeration for the different kinds of `HttpEvent`.
|
| *
|
| * @publicApi
|
| */
|
| export declare enum HttpEventType {
|
| /**
|
| * The request was sent out over the wire.
|
| */
|
| Sent = 0,
|
| /**
|
| * An upload progress event was received.
|
| */
|
| UploadProgress = 1,
|
| /**
|
| * The response status code and headers were received.
|
| */
|
| ResponseHeader = 2,
|
| /**
|
| * A download progress event was received.
|
| */
|
| DownloadProgress = 3,
|
| /**
|
| * The full response including the body was received.
|
| */
|
| Response = 4,
|
| /**
|
| * A custom event from an interceptor or a backend.
|
| */
|
| User = 5
|
| }
|
|
|
| /**
|
| * Transforms an `HttpRequest` into a stream of `HttpEvent`s, one of which will likely be a
|
| * `HttpResponse`.
|
| *
|
| * `HttpHandler` is injectable. When injected, the handler instance dispatches requests to the
|
| * first interceptor in the chain, which dispatches to the second, etc, eventually reaching the
|
| * `HttpBackend`.
|
| *
|
| * In an `HttpInterceptor`, the `HttpHandler` parameter is the next interceptor in the chain.
|
| *
|
| * @publicApi
|
| */
|
| export declare abstract class HttpHandler {
|
| abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
|
| }
|
|
|
| /**
|
| * A partial HTTP response which only includes the status and header data,
|
| * but no response body.
|
| *
|
| * `HttpHeaderResponse` is a `HttpEvent` available on the response
|
| * event stream, only when progress events are requested.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpHeaderResponse extends HttpResponseBase {
|
| /**
|
| * Create a new `HttpHeaderResponse` with the given parameters.
|
| */
|
| constructor(init?: {
|
| headers?: HttpHeaders;
|
| status?: number;
|
| statusText?: string;
|
| url?: string;
|
| });
|
| readonly type: HttpEventType.ResponseHeader;
|
| /**
|
| * Copy this `HttpHeaderResponse`, overriding its contents with the
|
| * given parameter hash.
|
| */
|
| clone(update?: {
|
| headers?: HttpHeaders;
|
| status?: number;
|
| statusText?: string;
|
| url?: string;
|
| }): HttpHeaderResponse;
|
| }
|
|
|
|
|
| /**
|
| * `HttpHeaders` class represents the header configuration options for an HTTP request.
|
| * Instances should be assumed immutable with lazy parsing.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpHeaders {
|
| /**
|
| * Internal map of lowercase header names to values.
|
| */
|
| private headers;
|
| /**
|
| * Internal map of lowercased header names to the normalized
|
| * form of the name (the form seen first).
|
| */
|
| private normalizedNames;
|
| /**
|
| * Complete the lazy initialization of this object (needed before reading).
|
| */
|
| private lazyInit;
|
| /**
|
| * Queued updates to be materialized the next initialization.
|
| */
|
| private lazyUpdate;
|
| /** Constructs a new HTTP header object with the given values.*/
|
| constructor(headers?: string | {
|
| [name: string]: string | string[];
|
| });
|
| /**
|
| * Checks for existence of a header by a given name.
|
| *
|
| * @param name The header name to check for existence.
|
| *
|
| * @returns Whether the header exits.
|
| */
|
| has(name: string): boolean;
|
| /**
|
| * Returns the first header value that matches a given name.
|
| *
|
| * @param name The header name to retrieve.
|
| *
|
| * @returns A string if the header exists, null otherwise
|
| */
|
| get(name: string): string | null;
|
| /**
|
| * Returns the names of the headers.
|
| *
|
| * @returns A list of header names.
|
| */
|
| keys(): string[];
|
| /**
|
| * Returns a list of header values for a given header name.
|
| *
|
| * @param name The header name from which to retrieve the values.
|
| *
|
| * @returns A string of values if the header exists, null otherwise.
|
| */
|
| getAll(name: string): string[] | null;
|
| /**
|
| * Appends a new header value to the existing set of
|
| * header values.
|
| *
|
| * @param name The header name for which to append the values.
|
| *
|
| * @returns A clone of the HTTP header object with the value appended.
|
| */
|
| append(name: string, value: string | string[]): HttpHeaders;
|
| /**
|
| * Sets a header value for a given name. If the header name already exists,
|
| * its value is replaced with the given value.
|
| *
|
| * @param name The header name.
|
| * @param value Provides the value to set or overide for a given name.
|
| *
|
| * @returns A clone of the HTTP header object with the newly set header value.
|
| */
|
| set(name: string, value: string | string[]): HttpHeaders;
|
| /**
|
| * Deletes all header values for a given name.
|
| *
|
| * @param name The header name.
|
| * @param value The header values to delete for a given name.
|
| *
|
| * @returns A clone of the HTTP header object.
|
| */
|
| delete(name: string, value?: string | string[]): HttpHeaders;
|
| private maybeSetNormalizedName;
|
| private init;
|
| private copyFrom;
|
| private clone;
|
| private applyUpdate;
|
| }
|
|
|
| /**
|
| * Intercepts `HttpRequest` or `HttpResponse` and handles them.
|
| *
|
| * Most interceptors transform the outgoing request before passing it to the
|
| * next interceptor in the chain, by calling `next.handle(transformedReq)`.
|
| * An interceptor may transform the
|
| * response event stream as well, by applying additional RxJS operators on the stream
|
| * returned by `next.handle()`.
|
| *
|
| * More rarely, an interceptor may handle the request entirely,
|
| * and compose a new event stream instead of invoking `next.handle()`. This is an
|
| * acceptable behavior, but keep in mind that further interceptors will be skipped entirely.
|
| *
|
| * It is also rare but valid for an interceptor to return multiple responses on the
|
| * event stream for a single request.
|
| *
|
| * @publicApi
|
| *
|
| * @see [HTTP Guide](guide/http#intercepting-requests-and-responses)
|
| *
|
| * @usageNotes
|
| *
|
| * To use the same instance of `HttpInterceptors` for the entire app, import the `HttpClientModule`
|
| * only in your `AppModule`, and add the interceptors to the root application injector .
|
| * If you import `HttpClientModule` multiple times across different modules (for example, in lazy
|
| * loading modules), each import creates a new copy of the `HttpClientModule`, which overwrites the interceptors
|
| * provided in the root module.
|
| *
|
| */
|
| export declare interface HttpInterceptor {
|
| /**
|
| * * **req**: The outgoing request to handle
|
| * * **next**: The next interceptor in the chain, or the backend if no interceptors in the chain.
|
| *
|
| */
|
| intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
|
| }
|
|
|
| declare type HttpObserve = 'body' | 'events' | 'response';
|
|
|
|
|
| /**
|
| * A codec for encoding and decoding parameters in URLs.
|
| *
|
| * Used by `HttpParams`.
|
| *
|
| * @publicApi
|
| **/
|
| export declare interface HttpParameterCodec {
|
| encodeKey(key: string): string;
|
| encodeValue(value: string): string;
|
| decodeKey(key: string): string;
|
| decodeValue(value: string): string;
|
| }
|
|
|
| /**
|
| * An HTTP request/response body that represents serialized parameters,
|
| * per the MIME type `application/x-www-form-urlencoded`.
|
| *
|
| * This class is immutable - all mutation operations return a new instance.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpParams {
|
| private map;
|
| private encoder;
|
| private updates;
|
| private cloneFrom;
|
| constructor(options?: HttpParamsOptions);
|
| /**
|
| * Check whether the body has one or more values for the given parameter name.
|
| */
|
| has(param: string): boolean;
|
| /**
|
| * Get the first value for the given parameter name, or `null` if it's not present.
|
| */
|
| get(param: string): string | null;
|
| /**
|
| * Get all values for the given parameter name, or `null` if it's not present.
|
| */
|
| getAll(param: string): string[] | null;
|
| /**
|
| * Get all the parameter names for this body.
|
| */
|
| keys(): string[];
|
| /**
|
| * Construct a new body with an appended value for the given parameter name.
|
| */
|
| append(param: string, value: string): HttpParams;
|
| /**
|
| * Construct a new body with a new value for the given parameter name.
|
| */
|
| set(param: string, value: string): HttpParams;
|
| /**
|
| * Construct a new body with either the given value for the given parameter
|
| * removed, if a value is given, or all values for the given parameter removed
|
| * if not.
|
| */
|
| delete(param: string, value?: string): HttpParams;
|
| /**
|
| * Serialize the body to an encoded string, where key-value pairs (separated by `=`) are
|
| * separated by `&`s.
|
| */
|
| toString(): string;
|
| private clone;
|
| private init;
|
| }
|
|
|
| /** Options used to construct an `HttpParams` instance. */
|
| declare interface HttpParamsOptions {
|
| /**
|
| * String representation of the HTTP params in URL-query-string format. Mutually exclusive with
|
| * `fromObject`.
|
| */
|
| fromString?: string;
|
| /** Object map of the HTTP params. Mutually exclusive with `fromString`. */
|
| fromObject?: {
|
| [param: string]: string | string[];
|
| };
|
| /** Encoding codec used to parse and serialize the params. */
|
| encoder?: HttpParameterCodec;
|
| }
|
|
|
| /**
|
| * Base interface for progress events.
|
| *
|
| * @publicApi
|
| */
|
| export declare interface HttpProgressEvent {
|
| /**
|
| * Progress event type is either upload or download.
|
| */
|
| type: HttpEventType.DownloadProgress | HttpEventType.UploadProgress;
|
| /**
|
| * Number of bytes uploaded or downloaded.
|
| */
|
| loaded: number;
|
| /**
|
| * Total number of bytes to upload or download. Depending on the request or
|
| * response, this may not be computable and thus may not be present.
|
| */
|
| total?: number;
|
| }
|
|
|
| /**
|
| * An outgoing HTTP request with an optional typed body.
|
| *
|
| * `HttpRequest` represents an outgoing request, including URL, method,
|
| * headers, body, and other request configuration options. Instances should be
|
| * assumed to be immutable. To modify a `HttpRequest`, the `clone`
|
| * method should be used.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpRequest<T> {
|
| readonly url: string;
|
| /**
|
| * The request body, or `null` if one isn't set.
|
| *
|
| * Bodies are not enforced to be immutable, as they can include a reference to any
|
| * user-defined data type. However, interceptors should take care to preserve
|
| * idempotence by treating them as such.
|
| */
|
| readonly body: T | null;
|
| /**
|
| * Outgoing headers for this request.
|
| */
|
| readonly headers: HttpHeaders;
|
| /**
|
| * Whether this request should be made in a way that exposes progress events.
|
| *
|
| * Progress events are expensive (change detection runs on each event) and so
|
| * they should only be requested if the consumer intends to monitor them.
|
| */
|
| readonly reportProgress: boolean;
|
| /**
|
| * Whether this request should be sent with outgoing credentials (cookies).
|
| */
|
| readonly withCredentials: boolean;
|
| /**
|
| * The expected response type of the server.
|
| *
|
| * This is used to parse the response appropriately before returning it to
|
| * the requestee.
|
| */
|
| readonly responseType: 'arraybuffer' | 'blob' | 'json' | 'text';
|
| /**
|
| * The outgoing HTTP request method.
|
| */
|
| readonly method: string;
|
| /**
|
| * Outgoing URL parameters.
|
| */
|
| readonly params: HttpParams;
|
| /**
|
| * The outgoing URL with all URL parameters set.
|
| */
|
| readonly urlWithParams: string;
|
| constructor(method: 'DELETE' | 'GET' | 'HEAD' | 'JSONP' | 'OPTIONS', url: string, init?: {
|
| headers?: HttpHeaders;
|
| reportProgress?: boolean;
|
| params?: HttpParams;
|
| responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
|
| withCredentials?: boolean;
|
| });
|
| constructor(method: 'POST' | 'PUT' | 'PATCH', url: string, body: T | null, init?: {
|
| headers?: HttpHeaders;
|
| reportProgress?: boolean;
|
| params?: HttpParams;
|
| responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
|
| withCredentials?: boolean;
|
| });
|
| constructor(method: string, url: string, body: T | null, init?: {
|
| headers?: HttpHeaders;
|
| reportProgress?: boolean;
|
| params?: HttpParams;
|
| responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
|
| withCredentials?: boolean;
|
| });
|
| /**
|
| * Transform the free-form body into a serialized format suitable for
|
| * transmission to the server.
|
| */
|
| serializeBody(): ArrayBuffer | Blob | FormData | string | null;
|
| /**
|
| * Examine the body and attempt to infer an appropriate MIME type
|
| * for it.
|
| *
|
| * If no such type can be inferred, this method will return `null`.
|
| */
|
| detectContentTypeHeader(): string | null;
|
| clone(): HttpRequest<T>;
|
| clone(update: {
|
| headers?: HttpHeaders;
|
| reportProgress?: boolean;
|
| params?: HttpParams;
|
| responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
|
| withCredentials?: boolean;
|
| body?: T | null;
|
| method?: string;
|
| url?: string;
|
| setHeaders?: {
|
| [name: string]: string | string[];
|
| };
|
| setParams?: {
|
| [param: string]: string;
|
| };
|
| }): HttpRequest<T>;
|
| clone<V>(update: {
|
| headers?: HttpHeaders;
|
| reportProgress?: boolean;
|
| params?: HttpParams;
|
| responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
|
| withCredentials?: boolean;
|
| body?: V | null;
|
| method?: string;
|
| url?: string;
|
| setHeaders?: {
|
| [name: string]: string | string[];
|
| };
|
| setParams?: {
|
| [param: string]: string;
|
| };
|
| }): HttpRequest<V>;
|
| }
|
|
|
| /**
|
| * A full HTTP response, including a typed response body (which may be `null`
|
| * if one was not returned).
|
| *
|
| * `HttpResponse` is a `HttpEvent` available on the response event
|
| * stream.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpResponse<T> extends HttpResponseBase {
|
| /**
|
| * The response body, or `null` if one was not returned.
|
| */
|
| readonly body: T | null;
|
| /**
|
| * Construct a new `HttpResponse`.
|
| */
|
| constructor(init?: {
|
| body?: T | null;
|
| headers?: HttpHeaders;
|
| status?: number;
|
| statusText?: string;
|
| url?: string;
|
| });
|
| readonly type: HttpEventType.Response;
|
| clone(): HttpResponse<T>;
|
| clone(update: {
|
| headers?: HttpHeaders;
|
| status?: number;
|
| statusText?: string;
|
| url?: string;
|
| }): HttpResponse<T>;
|
| clone<V>(update: {
|
| body?: V | null;
|
| headers?: HttpHeaders;
|
| status?: number;
|
| statusText?: string;
|
| url?: string;
|
| }): HttpResponse<V>;
|
| }
|
|
|
| /**
|
| * Base class for both `HttpResponse` and `HttpHeaderResponse`.
|
| *
|
| * @publicApi
|
| */
|
| export declare abstract class HttpResponseBase {
|
| /**
|
| * All response headers.
|
| */
|
| readonly headers: HttpHeaders;
|
| /**
|
| * Response status code.
|
| */
|
| readonly status: number;
|
| /**
|
| * Textual description of response status code.
|
| *
|
| * Do not depend on this.
|
| */
|
| readonly statusText: string;
|
| /**
|
| * URL of the resource retrieved, or null if not available.
|
| */
|
| readonly url: string | null;
|
| /**
|
| * Whether the status code falls in the 2xx range.
|
| */
|
| readonly ok: boolean;
|
| /**
|
| * Type of the response, narrowed to either the full response or the header.
|
| */
|
| readonly type: HttpEventType.Response | HttpEventType.ResponseHeader;
|
| /**
|
| * Super-constructor for all responses.
|
| *
|
| * The single parameter accepted is an initialization hash. Any properties
|
| * of the response passed there will override the default values.
|
| */
|
| constructor(init: {
|
| headers?: HttpHeaders;
|
| status?: number;
|
| statusText?: string;
|
| url?: string;
|
| }, defaultStatus?: number, defaultStatusText?: string);
|
| }
|
|
|
| /**
|
| * An event indicating that the request was sent to the server. Useful
|
| * when a request may be retried multiple times, to distinguish between
|
| * retries on the final event stream.
|
| *
|
| * @publicApi
|
| */
|
| export declare interface HttpSentEvent {
|
| type: HttpEventType.Sent;
|
| }
|
|
|
| /**
|
| * An upload progress event.
|
| *
|
| * @publicApi
|
| */
|
| export declare interface HttpUploadProgressEvent extends HttpProgressEvent {
|
| type: HttpEventType.UploadProgress;
|
| }
|
|
|
| /**
|
| * A class that uses `encodeURIComponent` and `decodeURIComponent` to
|
| * serialize and parse URL parameter keys and values. If you pass URL query parameters
|
| * without encoding, the query parameters can get misinterpreted at the receiving end.
|
| * Use the `HttpParameterCodec` class to encode and decode the query-string values.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpUrlEncodingCodec implements HttpParameterCodec {
|
| encodeKey(key: string): string;
|
| encodeValue(value: string): string;
|
| decodeKey(key: string): string;
|
| decodeValue(value: string): string;
|
| }
|
|
|
| /**
|
| * A user-defined event.
|
| *
|
| * Grouping all custom events under this type ensures they will be handled
|
| * and forwarded by all implementations of interceptors.
|
| *
|
| * @publicApi
|
| */
|
| export declare interface HttpUserEvent<T> {
|
| type: HttpEventType.User;
|
| }
|
|
|
| /**
|
| * An `HttpBackend` which uses the XMLHttpRequest API to send
|
| * requests to a backend server.
|
| *
|
| * @publicApi
|
| */
|
| export declare class HttpXhrBackend implements HttpBackend {
|
| private xhrFactory;
|
| constructor(xhrFactory: XhrFactory);
|
| /**
|
| * Process a request and return a stream of response events.
|
| */
|
| handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
|
| }
|
|
|
| /**
|
| * Retrieves the current XSRF token to use with the next outgoing request.
|
| *
|
| * @publicApi
|
| */
|
| export declare abstract class HttpXsrfTokenExtractor {
|
| /**
|
| * Get the XSRF token to use with an outgoing request.
|
| *
|
| * Will be called for every request, so the token may change between requests.
|
| */
|
| abstract getToken(): string | null;
|
| }
|
|
|
| /**
|
| * `HttpBackend` that only processes `HttpRequest` with the JSONP method,
|
| * by performing JSONP style requests.
|
| *
|
| * @publicApi
|
| */
|
| export declare class JsonpClientBackend implements HttpBackend {
|
| private callbackMap;
|
| private document;
|
| constructor(callbackMap: ɵangular_packages_common_http_http_b, document: any);
|
| /**
|
| * Get the name of the next callback method, by incrementing the global `nextRequestId`.
|
| */
|
| private nextCallback;
|
| /**
|
| * Process a JSONP request and return an event stream of the results.
|
| */
|
| handle(req: HttpRequest<never>): Observable<HttpEvent<any>>;
|
| }
|
|
|
| /**
|
| * An `HttpInterceptor` which identifies requests with the method JSONP and
|
| * shifts them to the `JsonpClientBackend`.
|
| *
|
| * @publicApi
|
| */
|
| export declare class JsonpInterceptor {
|
| private jsonp;
|
| constructor(jsonp: JsonpClientBackend);
|
| intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
|
| }
|
|
|
| /**
|
| * A wrapper around the `XMLHttpRequest` constructor.
|
| *
|
| * @publicApi
|
| */
|
| export declare abstract class XhrFactory {
|
| abstract build(): XMLHttpRequest;
|
| }
|
|
|
| export declare class ɵangular_packages_common_http_http_a implements HttpInterceptor {
|
| intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
|
| }
|
|
|
| /**
|
| * DI token/abstract type representing a map of JSONP callbacks.
|
| *
|
| * In the browser, this should always be the `window` object.
|
| *
|
| *
|
| */
|
| export declare abstract class ɵangular_packages_common_http_http_b {
|
| [key: string]: (data: any) => void;
|
| }
|
|
|
| /**
|
| * Factory function that determines where to store JSONP callbacks.
|
| *
|
| * Ordinarily JSONP callbacks are stored on the `window` object, but this may not exist
|
| * in test environments. In that case, callbacks are stored on an anonymous object instead.
|
| *
|
| *
|
| */
|
| export declare function ɵangular_packages_common_http_http_c(): Object;
|
|
|
| /**
|
| * A factory for @{link HttpXhrBackend} that uses the `XMLHttpRequest` browser API.
|
| *
|
| *
|
| */
|
| export declare class ɵangular_packages_common_http_http_d implements XhrFactory {
|
| constructor();
|
| build(): any;
|
| }
|
|
|
| export declare const ɵangular_packages_common_http_http_e: InjectionToken<string>;
|
|
|
| export declare const ɵangular_packages_common_http_http_f: InjectionToken<string>;
|
|
|
| /**
|
| * `HttpXsrfTokenExtractor` which retrieves the token from a cookie.
|
| */
|
| export declare class ɵangular_packages_common_http_http_g implements HttpXsrfTokenExtractor {
|
| private doc;
|
| private platform;
|
| private cookieName;
|
| private lastCookieString;
|
| private lastToken;
|
| constructor(doc: any, platform: string, cookieName: string);
|
| getToken(): string | null;
|
| }
|
|
|
| /**
|
| * `HttpInterceptor` which adds an XSRF token to eligible outgoing requests.
|
| */
|
| export declare class ɵangular_packages_common_http_http_h implements HttpInterceptor {
|
| private tokenService;
|
| private headerName;
|
| constructor(tokenService: HttpXsrfTokenExtractor, headerName: string);
|
| intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
|
| }
|
|
|
| /**
|
| * An injectable `HttpHandler` that applies multiple interceptors
|
| * to a request before passing it to the given `HttpBackend`.
|
| *
|
| * The interceptors are loaded lazily from the injector, to allow
|
| * interceptors to themselves inject classes depending indirectly
|
| * on `HttpInterceptingHandler` itself.
|
| * @see `HttpInterceptor`
|
| */
|
| export declare class ɵHttpInterceptingHandler implements HttpHandler {
|
| private backend;
|
| private injector;
|
| private chain;
|
| constructor(backend: HttpBackend, injector: Injector);
|
| handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
|
| }
|
|
|
| export { }
|