Options
All
  • Public
  • Public/Protected
  • All
Menu

Class HttpClient

Perform 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 according to which signature is called (mainly the values of observe and responseType).

Hierarchy

  • HttpClient

Index

Constructors

constructor

Methods

delete

  • delete(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<Object>>
  • delete<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<T>>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • delete(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • delete<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<T>>
  • delete(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • delete<T>(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<T>
  • Construct a DELETE request which interprets the body as an ArrayBuffer and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Construct a DELETE request which interprets the body as a Blob and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

    an Observable of the body as a Blob.

  • Construct a DELETE request which interprets the body as text and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct a DELETE request which interprets the body as an ArrayBuffer and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct a DELETE request which interprets the body as a Blob and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct a DELETE request which interprets the body as text and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct a DELETE request which interprets the body as JSON and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Object>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct a DELETE request which interprets the body as JSON and returns the full event stream.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<T>>

    an Observable of all HttpEvents for the request, with a body type of T.

  • Construct a DELETE request which interprets the body as an ArrayBuffer and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct a DELETE request which interprets the body as a Blob and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct a DELETE request which interprets the body as text and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct a DELETE request which interprets the body as JSON and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a DELETE request which interprets the body as JSON and returns the full response.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<T>>

    an Observable of the HttpResponse for the request, with a body type of T.

  • Construct a DELETE request which interprets the body as JSON and returns it.

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the body as an Object.

  • Construct a DELETE request which interprets the body as JSON and returns it.

    Type parameters

    • T

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<T>

    an Observable of the body as type T.

get

  • get(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<Object>>
  • get<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<T>>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • get(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • get<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<T>>
  • get(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • get<T>(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<T>
  • Construct a GET request which interprets the body as an ArrayBuffer and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Construct a GET request which interprets the body as a Blob and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

    an Observable of the body as a Blob.

  • Construct a GET request which interprets the body as text and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct a GET request which interprets the body as an ArrayBuffer and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct a GET request which interprets the body as a Blob and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct a GET request which interprets the body as text and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct a GET request which interprets the body as JSON and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Object>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct a GET request which interprets the body as JSON and returns the full event stream.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<T>>

    an Observable of all HttpEvents for the request, with a body type of T.

  • Construct a GET request which interprets the body as an ArrayBuffer and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct a GET request which interprets the body as a Blob and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct a GET request which interprets the body as text and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct a GET request which interprets the body as JSON and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a GET request which interprets the body as JSON and returns the full response.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<T>>

    an Observable of the HttpResponse for the request, with a body type of T.

  • Construct a GET request which interprets the body as JSON and returns it.

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the body as an Object.

  • Construct a GET request which interprets the body as JSON and returns it.

    Type parameters

    • T

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<T>

    an Observable of the body as type T.

head

  • head(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<Object>>
  • head<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<T>>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • head(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • head<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<T>>
  • head(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • head<T>(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<T>
  • Construct a HEAD request which interprets the body as an ArrayBuffer and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Constructs an Observable which, when subscribed, will cause the configured HEAD request to be executed on the server. See the individual overloads for details of head()'s return type based on the provided options.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

  • Construct a HEAD request which interprets the body as text and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct a HEAD request which interprets the body as an ArrayBuffer and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct a HEAD request which interprets the body as a Blob and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct a HEAD request which interprets the body as text and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct a HEAD request which interprets the body as JSON and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Object>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct a HEAD request which interprets the body as JSON and returns the full event stream.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<T>>

    an Observable of all HttpEvents for the request, with a body type of T.

  • Construct a HEAD request which interprets the body as an ArrayBuffer and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct a HEAD request which interprets the body as a Blob and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct a HEAD request which interprets the body as text and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct a HEAD request which interprets the body as JSON and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a HEAD request which interprets the body as JSON and returns the full response.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<T>>

    an Observable of the HttpResponse for the request, with a body type of T.

  • Construct a HEAD request which interprets the body as JSON and returns it.

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the body as an Object.

  • Construct a HEAD request which interprets the body as JSON and returns it.

    Type parameters

    • T

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<T>

    an Observable of the body as type T.

jsonp

  • jsonp(url: string, callbackParam: string): Observable<Object>
  • jsonp<T>(url: string, callbackParam: string): Observable<T>
  • Construct a JSONP request for the given URL and name of the callback parameter.

    A suitable interceptor must be installed (e.g. via the HttpClientJsonpModule). If no such interceptor is reached, then the JSONP request will likely be rejected by the configured backend.

    Parameters

    • url: string
    • callbackParam: string

    Returns Observable<Object>

    an Observable of the response object as an Object

  • Construct a JSONP request for the given URL and name of the callback parameter.

    A suitable interceptor must be installed (e.g. via the HttpClientJsonpModule). If no such interceptor is reached, then the JSONP request will likely be rejected by the configured backend.

    Type parameters

    • T

    Parameters

    • url: string
    • callbackParam: string

    Returns Observable<T>

    an Observable of the response object as type T.

options

  • options(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<Object>>
  • options<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<T>>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • options(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • options<T>(url: string, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<T>>
  • options(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • options<T>(url: string, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<T>
  • Make an OPTIONS request which interprets the body as an ArrayBuffer and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Construct an OPTIONS request which interprets the body as a Blob and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

    an Observable of the body as a Blob.

  • Construct an OPTIONS request which interprets the body as text and returns it.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct an OPTIONS request which interprets the body as an ArrayBuffer and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct an OPTIONS request which interprets the body as a Blob and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct an OPTIONS request which interprets the body as text and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct an OPTIONS request which interprets the body as JSON and returns the full event stream.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Object>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct an OPTIONS request which interprets the body as JSON and returns the full event stream.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<T>>

    an Observable of all HttpEvents for the request, with a body type of T.

  • Construct an OPTIONS request which interprets the body as an ArrayBuffer and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct an OPTIONS request which interprets the body as a Blob and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct an OPTIONS request which interprets the body as text and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct an OPTIONS request which interprets the body as JSON and returns the full response.

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct an OPTIONS request which interprets the body as JSON and returns the full response.

    Type parameters

    • T

    Parameters

    • url: string
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<T>>

    an Observable of the HttpResponse for the request, with a body type of T.

  • Construct an OPTIONS request which interprets the body as JSON and returns it.

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the body as an Object.

  • Construct an OPTIONS request which interprets the body as JSON and returns it.

    Type parameters

    • T

    Parameters

    • url: string
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<T>

    an Observable of the body as type T.

patch

  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<Object>>
  • patch<T>(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<T>>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • patch(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • patch<T>(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<T>>
  • patch(url: string, body: any | null, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • patch<T>(url: string, body: any | null, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<T>
  • Construct a PATCH request which interprets the body as an ArrayBuffer and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Construct a PATCH request which interprets the body as a Blob and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

    an Observable of the body as a Blob.

  • Construct a PATCH request which interprets the body as text and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct a PATCH request which interprets the body as an ArrayBuffer and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct a PATCH request which interprets the body as a Blob and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct a PATCH request which interprets the body as text and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct a PATCH request which interprets the body as JSON and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Object>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct a PATCH request which interprets the body as JSON and returns the full event stream.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<T>>

    an Observable of all HttpEvents for the request, with a body type of T.

  • Construct a PATCH request which interprets the body as an ArrayBuffer and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct a PATCH request which interprets the body as a Blob and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct a PATCH request which interprets the body as text and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct a PATCH request which interprets the body as JSON and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a PATCH request which interprets the body as JSON and returns the full response.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<T>>

    an Observable of the HttpResponse for the request, with a body type of T.

  • Construct a PATCH request which interprets the body as JSON and returns it.

    Parameters

    • url: string
    • body: any | null
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the body as an Object.

  • Construct a PATCH request which interprets the body as JSON and returns it.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<T>

    an Observable of the body as type T.

post

  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<Object>>
  • post<T>(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<T>>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • post(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • post<T>(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<T>>
  • post(url: string, body: any | null, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • post<T>(url: string, body: any | null, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<T>
  • Construct a POST request which interprets the body as an ArrayBuffer and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Construct a POST request which interprets the body as a Blob and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

    an Observable of the body as a Blob.

  • Construct a POST request which interprets the body as text and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct a POST request which interprets the body as an ArrayBuffer and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct a POST request which interprets the body as a Blob and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct a POST request which interprets the body as text and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct a POST request which interprets the body as JSON and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Object>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct a POST request which interprets the body as JSON and returns the full event stream.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<T>>

    an Observable of all HttpEvents for the request, with a body type of T.

  • Construct a POST request which interprets the body as an ArrayBuffer and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct a POST request which interprets the body as a Blob and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct a POST request which interprets the body as text and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct a POST request which interprets the body as JSON and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a POST request which interprets the body as JSON and returns the full response.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<T>>

    an Observable of the HttpResponse for the request, with a body type of T.

  • Construct a POST request which interprets the body as JSON and returns it.

    Parameters

    • url: string
    • body: any | null
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the body as an Object.

  • Construct a POST request which interprets the body as JSON and returns it.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<T>

    an Observable of the body as type T.

put

  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<Object>>
  • put<T>(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "events"; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<T>>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • put(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • put<T>(url: string, body: any | null, options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<T>>
  • put(url: string, body: any | null, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • put<T>(url: string, body: any | null, options?: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<T>
  • Construct a PUT request which interprets the body as an ArrayBuffer and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Construct a PUT request which interprets the body as a Blob and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

    an Observable of the body as a Blob.

  • Construct a PUT request which interprets the body as text and returns it.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct a PUT request which interprets the body as an ArrayBuffer and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct a PUT request which interprets the body as a Blob and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct a PUT request which interprets the body as text and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct a PUT request which interprets the body as JSON and returns the full event stream.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Object>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct a PUT request which interprets the body as JSON and returns the full event stream.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "events"; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<T>>

    an Observable of all HttpEvents for the request, with a body type of T.

  • Construct a PUT request which interprets the body as an ArrayBuffer and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct a PUT request which interprets the body as a Blob and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct a PUT request which interprets the body as text and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct a PUT request which interprets the body as JSON and returns the full response.

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a PUT request which interprets the body as JSON and returns the full response.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • options: { headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<T>>

    an Observable of the HttpResponse for the request, with a body type of T.

  • Construct a PUT request which interprets the body as JSON and returns it.

    Parameters

    • url: string
    • body: any | null
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the body as an Object.

  • Construct a PUT request which interprets the body as JSON and returns it.

    Type parameters

    • T

    Parameters

    • url: string
    • body: any | null
    • Optional options: { headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<T>

    an Observable of the body as type T.

request

  • request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<ArrayBuffer>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<Blob>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<string>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpEvent<ArrayBuffer>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpEvent<Blob>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpEvent<string>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<any>>
  • request<R>(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpEvent<R>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }): Observable<HttpResponse<ArrayBuffer>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }): Observable<HttpResponse<Blob>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }): Observable<HttpResponse<string>>
  • request(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<Object>>
  • request<R>(method: string, url: string, options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<HttpResponse<R>>
  • request(method: string, url: string, options?: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<Object>
  • request<R>(method: string, url: string, options?: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }): Observable<R>
  • request(method: string, url: string, options?: { body?: any; headers?: HttpHeaders | {}; observe?: HttpObserve; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "arraybuffer" | "blob" | "json" | "text"; withCredentials?: boolean }): Observable<any>
  • Send the given HttpRequest and return a stream of HttpEvents.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Type parameters

    • R

    Parameters

    Returns Observable<HttpEvent<R>>

  • Construct a request which interprets the body as an ArrayBuffer and returns it.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<ArrayBuffer>

    an Observable of the body as an ArrayBuffer.

  • Construct a request which interprets the body as a Blob and returns it.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<Blob>

    an Observable of the body as a Blob.

  • Construct a request which interprets the body as text and returns it.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<string>

    an Observable of the body as a string.

  • Construct a request which interprets the body as an ArrayBuffer and returns the full event stream.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<ArrayBuffer>>

    an Observable of all HttpEvents for the request, with a body type of ArrayBuffer.

  • Construct a request which interprets the body as an Blob and returns the full event stream.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<Blob>>

    an Observable of all HttpEvents for the request, with a body type of Blob.

  • Construct a request which interprets the body as text and returns the full event stream.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<string>>

    an Observable of all HttpEvents for the request, with a body type of string.

  • Construct a request which interprets the body as JSON and returns the full event stream.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<any>>

    an Observable of all HttpEvents for the request, with a body type of Object.

  • Construct a request which interprets the body as JSON and returns the full event stream.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Type parameters

    • R

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "events"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "events"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpEvent<R>>

    an Observable of all HttpEvents for the request, with a body type of R.

  • Construct a request which interprets the body as an ArrayBuffer and returns the full response.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "arraybuffer"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "arraybuffer"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<ArrayBuffer>>

    an Observable of the HttpResponse for the request, with a body type of ArrayBuffer.

  • Construct a request which interprets the body as a Blob and returns the full response.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "blob"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "blob"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Blob>>

    an Observable of the HttpResponse for the request, with a body type of Blob.

  • Construct a request which interprets the body as text and returns the full response.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType: "text"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • responseType: "text"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<string>>

    an Observable of the HttpResponse for the request, with a body type of string.

  • Construct a request which interprets the body as JSON and returns the full response.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<Object>>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a request which interprets the body as JSON and returns the full response.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Type parameters

    • R

    Parameters

    • method: string
    • url: string
    • options: { body?: any; headers?: HttpHeaders | {}; observe: "response"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • observe: "response"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<HttpResponse<R>>

    an Observable of the HttpResponse for the request, with a body type of R.

  • Construct a request which interprets the body as JSON and returns it.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • Optional options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<Object>

    an Observable of the HttpResponse for the request, with a body type of Object.

  • Construct a request which interprets the body as JSON and returns it.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Type parameters

    • R

    Parameters

    • method: string
    • url: string
    • Optional options: { body?: any; headers?: HttpHeaders | {}; observe?: "body"; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "json"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: "body"
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "json"
      • Optional withCredentials?: boolean

    Returns Observable<R>

    an Observable of the HttpResponse for the request, with a body type of R.

  • Construct a request in a manner where response type and requested Observable are not known statically.

    This method can be called in one of two ways. Either an HttpRequest instance can be passed directly as the only parameter, or a method can be passed as the first parameter, a string URL as the second, and an options hash as the third.

    If a HttpRequest object is passed directly, an Observable of the raw HttpEvent stream will be returned.

    If a request is instead built by providing a URL, the options object determines the return type of request(). In addition to configuring request parameters such as the outgoing headers and/or the body, the options hash specifies two key pieces of information about the request: the responseType and what to observe.

    The responseType value determines how a successful response body will be parsed. If responseType is the default json, a type interface for the resulting object may be passed as a type parameter to request().

    The observe value determines the return type of request(), based on what the consumer is interested in observing. A value of events will return an Observable<HttpEvent> representing the raw HttpEvent stream, including progress events by default. A value of response will return an Observable<HttpResponse<T>> where the T parameter of HttpResponse depends on the responseType and any optionally provided type parameter. A value of body will return an Observable<T> with the same T body type.

    Parameters

    • method: string
    • url: string
    • Optional options: { body?: any; headers?: HttpHeaders | {}; observe?: HttpObserve; params?: HttpParams | {}; reportProgress?: boolean; responseType?: "arraybuffer" | "blob" | "json" | "text"; withCredentials?: boolean }
      • Optional body?: any
      • Optional headers?: HttpHeaders | {}
      • Optional observe?: HttpObserve
      • Optional params?: HttpParams | {}
      • Optional reportProgress?: boolean
      • Optional responseType?: "arraybuffer" | "blob" | "json" | "text"
      • Optional withCredentials?: boolean

    Returns Observable<any>

    an Observable of whatever was requested, typed to any.

Generated using TypeDoc