Elgato_dark/angular
1
0
Fork 0
mirror of https://github.com/angular/angular synced 2026-05-24 09:28:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
angular/goldens/public-api/common/http/index.api.md
Matthieu Riegler e8d9bc5119 refactor(http): rework the HttpEvent union to improve narrowing. (#63267) 
Prior to this change, `HttpProgressEvent` could not be narrowed to `HttpDownloadProgressEvent` or `HttpUploadProgressEvent`

PR Close #63267
2025-08-27 11:25:02 -07:00

3207 lines
114 KiB
Markdown
Raw Blame History

## API Report File for "@angular/common_http"
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
```ts
import { EnvironmentInjector } from '@angular/core';
import { EnvironmentProviders } from '@angular/core';
import * as i0 from '@angular/core';
import { InjectionToken } from '@angular/core';
import { Injector } from '@angular/core';
import { ModuleWithProviders } from '@angular/core';
import { Observable } from 'rxjs';
import { Provider } from '@angular/core';
import { ResourceRef } from '@angular/core';
import { Signal } from '@angular/core';
import { ValueEqualityFn } from '@angular/core';
import { WritableResource } from '@angular/core';
// @public
export class FetchBackend implements HttpBackend {
constructor();
// (undocumented)
handle(request: HttpRequest<any>): Observable<HttpEvent<any>>;
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<FetchBackend, never>;
// (undocumented)
static ɵprov: i0.ɵɵInjectableDeclaration<FetchBackend>;
}
// @public
export const HTTP_INTERCEPTORS: InjectionToken<readonly HttpInterceptor[]>;
// @public
export const HTTP_TRANSFER_CACHE_ORIGIN_MAP: InjectionToken<Record<string, string>>;
// @public
export abstract class HttpBackend implements HttpHandler {
// (undocumented)
abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
}
// @public
export class HttpClient {
constructor(handler: HttpHandler);
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
body?: any | null;
}): Observable<ArrayBuffer>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<Blob>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<string>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpEvent<ArrayBuffer>>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpEvent<Blob>>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpEvent<string>>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpEvent<Object>>;
delete<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | (string | number | boolean)[]>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpEvent<T>>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpResponse<ArrayBuffer>>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpResponse<Blob>>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpResponse<string>>;
delete(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpResponse<Object>>;
delete<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<HttpResponse<T>>;
delete(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<Object>;
delete<T>(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
body?: any | null;
}): Observable<T>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<ArrayBuffer>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Blob>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<string>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<ArrayBuffer>>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<Blob>>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<string>>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<Object>>;
get<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<T>>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<ArrayBuffer>>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Blob>>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<string>>;
get(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Object>>;
get<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<T>>;
get(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Object>;
get<T>(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<T>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<ArrayBuffer>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Blob>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<string>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<ArrayBuffer>>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<Blob>>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<string>>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<Object>>;
head<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<T>>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<ArrayBuffer>>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Blob>>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<string>>;
head(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Object>>;
head<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<T>>;
head(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Object>;
head<T>(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<T>;
jsonp(url: string, callbackParam: string): Observable<Object>;
jsonp<T>(url: string, callbackParam: string): Observable<T>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<ArrayBuffer>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<Blob>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<string>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<ArrayBuffer>>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<Blob>>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<string>>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<Object>>;
options<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<T>>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<ArrayBuffer>>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<Blob>>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<string>>;
options(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<Object>>;
options<T>(url: string, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<T>>;
options(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<Object>;
options<T>(url: string, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<T>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<ArrayBuffer>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<Blob>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<string>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<ArrayBuffer>>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<Blob>>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<string>>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<Object>>;
patch<T>(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<T>>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<ArrayBuffer>>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<Blob>>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<string>>;
patch(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<Object>>;
patch<T>(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<T>>;
patch(url: string, body: any | null, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<Object>;
patch<T>(url: string, body: any | null, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<T>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<ArrayBuffer>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Blob>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<string>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<ArrayBuffer>>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<Blob>>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<string>>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<Object>>;
post<T>(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<T>>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<ArrayBuffer>>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Blob>>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<string>>;
post(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Object>>;
post<T>(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<T>>;
post(url: string, body: any | null, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Object>;
post<T>(url: string, body: any | null, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<T>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<ArrayBuffer>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<Blob>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<string>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<ArrayBuffer>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<Blob>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<string>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<Object>>;
put<T>(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpEvent<T>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<ArrayBuffer>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<Blob>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<string>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<Object>>;
put<T>(url: string, body: any | null, options: {
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<HttpResponse<T>>;
put(url: string, body: any | null, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<Object>;
put<T>(url: string, body: any | null, options?: {
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
timeout?: number;
}): Observable<T>;
request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<ArrayBuffer>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Blob>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<string>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
observe: 'events';
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<ArrayBuffer>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<Blob>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'events';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<string>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
reportProgress?: boolean;
observe: 'events';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<any>>;
request<R>(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
reportProgress?: boolean;
observe: 'events';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpEvent<R>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'arraybuffer';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<ArrayBuffer>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'blob';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Blob>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
observe: 'response';
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
reportProgress?: boolean;
responseType: 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<string>>;
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
reportProgress?: boolean;
observe: 'response';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<HttpResponse<Object>>;
request<R>(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
reportProgress?: boolean;
observe: 'response';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
responseType?: 'json';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
}): Observable<HttpResponse<R>>;
request(method: string, url: string, options?: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
responseType?: 'json';
reportProgress?: boolean;
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<Object>;
request<R>(method: string, url: string, options?: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
observe?: 'body';
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
responseType?: 'json';
reportProgress?: boolean;
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<R>;
request(method: string, url: string, options?: {
body?: any;
headers?: HttpHeaders | Record<string, string | string[]>;
context?: HttpContext;
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
observe?: 'body' | 'events' | 'response';
reportProgress?: boolean;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
}): Observable<any>;
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<HttpClient, never>;
// (undocumented)
static ɵprov: i0.ɵɵInjectableDeclaration<HttpClient>;
}
// @public @deprecated
export class HttpClientJsonpModule {
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<HttpClientJsonpModule, never>;
// (undocumented)
static ɵinj: i0.ɵɵInjectorDeclaration<HttpClientJsonpModule>;
// (undocumented)
static ɵmod: i0.ɵɵNgModuleDeclaration<HttpClientJsonpModule, never, never, never>;
}
// @public @deprecated
export class HttpClientModule {
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<HttpClientModule, never>;
// (undocumented)
static ɵinj: i0.ɵɵInjectorDeclaration<HttpClientModule>;
// (undocumented)
static ɵmod: i0.ɵɵNgModuleDeclaration<HttpClientModule, never, never, never>;
}
// @public @deprecated
export class HttpClientXsrfModule {
static disable(): ModuleWithProviders<HttpClientXsrfModule>;
static withOptions(options?: {
cookieName?: string;
headerName?: string;
}): ModuleWithProviders<HttpClientXsrfModule>;
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<HttpClientXsrfModule, never>;
// (undocumented)
static ɵinj: i0.ɵɵInjectorDeclaration<HttpClientXsrfModule>;
// (undocumented)
static ɵmod: i0.ɵɵNgModuleDeclaration<HttpClientXsrfModule, never, never, never>;
}
// @public
export class HttpContext {
delete(token: HttpContextToken<unknown>): HttpContext;
get<T>(token: HttpContextToken<T>): T;
has(token: HttpContextToken<unknown>): boolean;
// (undocumented)
keys(): IterableIterator<HttpContextToken<unknown>>;
set<T>(token: HttpContextToken<T>, value: T): HttpContext;
}
// @public
export class HttpContextToken<T> {
constructor(defaultValue: () => T);
// (undocumented)
readonly defaultValue: () => T;
}
// @public
export interface HttpDownloadProgressEvent extends HttpProgressEvent {
partialText?: string;
// (undocumented)
type: HttpEventType.DownloadProgress;
}
// @public
export class HttpErrorResponse extends HttpResponseBase implements Error {
constructor(init: {
error?: any;
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
redirected?: boolean;
});
// (undocumented)
readonly error: any | null;
// (undocumented)
readonly message: string;
// (undocumented)
readonly name = "HttpErrorResponse";
readonly ok = false;
}
// @public
export type HttpEvent<T> = HttpSentEvent | HttpHeaderResponse | HttpResponse<T> | HttpDownloadProgressEvent | HttpUploadProgressEvent | HttpUserEvent<T>;
// @public
export enum HttpEventType {
DownloadProgress = 3,
Response = 4,
ResponseHeader = 2,
Sent = 0,
UploadProgress = 1,
User = 5
}
// @public
export interface HttpFeature<KindT extends HttpFeatureKind> {
// (undocumented)
ɵkind: KindT;
// (undocumented)
ɵproviders: Provider[];
}
// @public
export enum HttpFeatureKind {
// (undocumented)
CustomXsrfConfiguration = 2,
// (undocumented)
Fetch = 6,
// (undocumented)
Interceptors = 0,
// (undocumented)
JsonpSupport = 4,
// (undocumented)
LegacyInterceptors = 1,
// (undocumented)
NoXsrfProtection = 3,
// (undocumented)
RequestsMadeViaParent = 5
}
// @public
export abstract class HttpHandler {
// (undocumented)
abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
}
// @public
export type HttpHandlerFn = (req: HttpRequest<unknown>) => Observable<HttpEvent<unknown>>;
// @public
export class HttpHeaderResponse extends HttpResponseBase {
constructor(init?: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
});
clone(update?: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
}): HttpHeaderResponse;
// (undocumented)
readonly type: HttpEventType.ResponseHeader;
}
// @public
export class HttpHeaders {
constructor(headers?: string | {
[name: string]: string | number | (string | number)[];
} | Headers);
append(name: string, value: string | string[]): HttpHeaders;
delete(name: string, value?: string | string[]): HttpHeaders;
get(name: string): string | null;
getAll(name: string): string[] | null;
has(name: string): boolean;
keys(): string[];
set(name: string, value: string | string[]): HttpHeaders;
}
// @public
export interface HttpInterceptor {
intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
}
// @public
export type HttpInterceptorFn = (req: HttpRequest<unknown>, next: HttpHandlerFn) => Observable<HttpEvent<unknown>>;
// @public
export interface HttpParameterCodec {
// (undocumented)
decodeKey(key: string): string;
// (undocumented)
decodeValue(value: string): string;
// (undocumented)
encodeKey(key: string): string;
// (undocumented)
encodeValue(value: string): string;
}
// @public
export class HttpParams {
constructor(options?: HttpParamsOptions);
append(param: string, value: string | number | boolean): HttpParams;
appendAll(params: {
[param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
}): HttpParams;
delete(param: string, value?: string | number | boolean): HttpParams;
get(param: string): string | null;
getAll(param: string): string[] | null;
has(param: string): boolean;
keys(): string[];
set(param: string, value: string | number | boolean): HttpParams;
toString(): string;
}
// @public
export interface HttpParamsOptions {
encoder?: HttpParameterCodec;
fromObject?: {
[param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
};
fromString?: string;
}
// @public
export interface HttpProgressEvent {
loaded: number;
total?: number;
type: HttpEventType.DownloadProgress | HttpEventType.UploadProgress;
}
// @public
export class HttpRequest<T> {
constructor(method: 'GET' | 'HEAD', url: string, init?: {
headers?: HttpHeaders;
context?: HttpContext;
reportProgress?: boolean;
params?: HttpParams;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
});
constructor(method: 'DELETE' | 'JSONP' | 'OPTIONS', url: string, init?: {
headers?: HttpHeaders;
context?: HttpContext;
reportProgress?: boolean;
params?: HttpParams;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
timeout?: number;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
});
constructor(method: 'POST', url: string, body: T | null, init?: {
headers?: HttpHeaders;
context?: HttpContext;
reportProgress?: boolean;
params?: HttpParams;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
});
constructor(method: 'PUT' | 'PATCH', url: string, body: T | null, init?: {
headers?: HttpHeaders;
context?: HttpContext;
reportProgress?: boolean;
params?: HttpParams;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
timeout?: number;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
});
constructor(method: string, url: string, body: T | null, init?: {
headers?: HttpHeaders;
context?: HttpContext;
reportProgress?: boolean;
params?: HttpParams;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
});
readonly body: T | null;
readonly cache: RequestCache;
// (undocumented)
clone(): HttpRequest<T>;
// (undocumented)
clone(update: {
headers?: HttpHeaders;
context?: HttpContext;
reportProgress?: boolean;
params?: HttpParams;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
credentials?: RequestCredentials;
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
body?: T | null;
method?: string;
url?: string;
setHeaders?: {
[name: string]: string | string[];
};
setParams?: {
[param: string]: string;
};
}): HttpRequest<T>;
// (undocumented)
clone<V>(update: {
headers?: HttpHeaders;
context?: HttpContext;
reportProgress?: boolean;
params?: HttpParams;
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
keepalive?: boolean;
priority?: RequestPriority;
cache?: RequestCache;
mode?: RequestMode;
redirect?: RequestRedirect;
referrer?: string;
integrity?: string;
withCredentials?: boolean;
credentials?: RequestCredentials;
transferCache?: {
includeHeaders?: string[];
} | boolean;
timeout?: number;
body?: V | null;
method?: string;
url?: string;
setHeaders?: {
[name: string]: string | string[];
};
setParams?: {
[param: string]: string;
};
}): HttpRequest<V>;
readonly context: HttpContext;
readonly credentials: RequestCredentials;
detectContentTypeHeader(): string | null;
readonly headers: HttpHeaders;
readonly integrity: string;
readonly keepalive: boolean;
readonly method: string;
readonly mode: RequestMode;
readonly params: HttpParams;
readonly priority: RequestPriority;
readonly redirect: RequestRedirect;
readonly referrer: string;
readonly reportProgress: boolean;
readonly responseType: 'arraybuffer' | 'blob' | 'json' | 'text';
serializeBody(): ArrayBuffer | Blob | FormData | URLSearchParams | string | null;
readonly timeout?: number;
readonly transferCache?: {
includeHeaders?: string[];
} | boolean;
// (undocumented)
readonly url: string;
readonly urlWithParams: string;
readonly withCredentials: boolean;
}
// @public
export const httpResource: HttpResourceFn;
// @public
export interface HttpResourceFn {
<TResult = unknown>(url: () => string | undefined, options: HttpResourceOptions<TResult, unknown> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = unknown>(url: () => string | undefined, options?: HttpResourceOptions<TResult, unknown>): HttpResourceRef<TResult | undefined>;
<TResult = unknown>(request: () => HttpResourceRequest | undefined, options: HttpResourceOptions<TResult, unknown> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = unknown>(request: () => HttpResourceRequest | undefined, options?: HttpResourceOptions<TResult, unknown>): HttpResourceRef<TResult | undefined>;
arrayBuffer: {
<TResult = ArrayBuffer>(url: () => string | undefined, options: HttpResourceOptions<TResult, ArrayBuffer> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = ArrayBuffer>(url: () => string | undefined, options?: HttpResourceOptions<TResult, ArrayBuffer>): HttpResourceRef<TResult | undefined>;
<TResult = ArrayBuffer>(request: () => HttpResourceRequest | undefined, options: HttpResourceOptions<TResult, ArrayBuffer> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = ArrayBuffer>(request: () => HttpResourceRequest | undefined, options?: HttpResourceOptions<TResult, ArrayBuffer>): HttpResourceRef<TResult | undefined>;
};
blob: {
<TResult = Blob>(url: () => string | undefined, options: HttpResourceOptions<TResult, Blob> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = Blob>(url: () => string | undefined, options?: HttpResourceOptions<TResult, Blob>): HttpResourceRef<TResult | undefined>;
<TResult = Blob>(request: () => HttpResourceRequest | undefined, options: HttpResourceOptions<TResult, Blob> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = Blob>(request: () => HttpResourceRequest | undefined, options?: HttpResourceOptions<TResult, Blob>): HttpResourceRef<TResult | undefined>;
};
text: {
<TResult = string>(url: () => string | undefined, options: HttpResourceOptions<TResult, string> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = string>(url: () => string | undefined, options?: HttpResourceOptions<TResult, string>): HttpResourceRef<TResult | undefined>;
<TResult = string>(request: () => HttpResourceRequest | undefined, options: HttpResourceOptions<TResult, string> & {
defaultValue: NoInfer<TResult>;
}): HttpResourceRef<TResult>;
<TResult = string>(request: () => HttpResourceRequest | undefined, options?: HttpResourceOptions<TResult, string>): HttpResourceRef<TResult | undefined>;
};
}
// @public
export interface HttpResourceOptions<TResult, TRaw> {
defaultValue?: NoInfer<TResult>;
equal?: ValueEqualityFn<NoInfer<TResult>>;
injector?: Injector;
parse?: (value: TRaw) => TResult;
}
// @public
export interface HttpResourceRef<T> extends WritableResource<T>, ResourceRef<T> {
// (undocumented)
destroy(): void;
// (undocumented)
hasValue(): this is HttpResourceRef<Exclude<T, undefined>>;
readonly headers: Signal<HttpHeaders | undefined>;
readonly progress: Signal<HttpProgressEvent | undefined>;
readonly statusCode: Signal<number | undefined>;
}
// @public
export interface HttpResourceRequest {
body?: unknown;
cache?: RequestCache | (string & {});
context?: HttpContext;
credentials?: RequestCredentials | (string & {});
headers?: HttpHeaders | Record<string, string | ReadonlyArray<string>>;
integrity?: string;
keepalive?: boolean;
method?: string;
mode?: RequestMode | (string & {});
params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
priority?: RequestPriority | (string & {});
redirect?: RequestRedirect | (string & {});
referrer?: string;
reportProgress?: boolean;
timeout?: number;
transferCache?: {
includeHeaders?: string[];
} | boolean;
url: string;
withCredentials?: boolean;
}
// @public
export class HttpResponse<T> extends HttpResponseBase {
constructor(init?: {
body?: T | null;
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
redirected?: boolean;
});
readonly body: T | null;
// (undocumented)
clone(): HttpResponse<T>;
// (undocumented)
clone(update: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
redirected?: boolean;
}): HttpResponse<T>;
// (undocumented)
clone<V>(update: {
body?: V | null;
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
redirected?: boolean;
}): HttpResponse<V>;
// (undocumented)
readonly type: HttpEventType.Response;
}
// @public
export abstract class HttpResponseBase {
constructor(init: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
redirected?: boolean;
}, defaultStatus?: number, defaultStatusText?: string);
readonly headers: HttpHeaders;
readonly ok: boolean;
readonly redirected?: boolean;
readonly status: number;
readonly statusText: string;
readonly type: HttpEventType.Response | HttpEventType.ResponseHeader;
readonly url: string | null;
}
// @public
export interface HttpSentEvent {
// (undocumented)
type: HttpEventType.Sent;
}
// @public
export enum HttpStatusCode {
// (undocumented)
Accepted = 202,
// (undocumented)
AlreadyReported = 208,
// (undocumented)
BadGateway = 502,
// (undocumented)
BadRequest = 400,
// (undocumented)
Conflict = 409,
// (undocumented)
Continue = 100,
// (undocumented)
Created = 201,
// (undocumented)
EarlyHints = 103,
// (undocumented)
ExpectationFailed = 417,
// (undocumented)
FailedDependency = 424,
// (undocumented)
Forbidden = 403,
// (undocumented)
Found = 302,
// (undocumented)
GatewayTimeout = 504,
// (undocumented)
Gone = 410,
// (undocumented)
HttpVersionNotSupported = 505,
// (undocumented)
ImATeapot = 418,
// (undocumented)
ImUsed = 226,
// (undocumented)
InsufficientStorage = 507,
// (undocumented)
InternalServerError = 500,
// (undocumented)
LengthRequired = 411,
// (undocumented)
Locked = 423,
// (undocumented)
LoopDetected = 508,
// (undocumented)
MethodNotAllowed = 405,
// (undocumented)
MisdirectedRequest = 421,
// (undocumented)
MovedPermanently = 301,
// (undocumented)
MultipleChoices = 300,
// (undocumented)
MultiStatus = 207,
// (undocumented)
NetworkAuthenticationRequired = 511,
// (undocumented)
NoContent = 204,
// (undocumented)
NonAuthoritativeInformation = 203,
// (undocumented)
NotAcceptable = 406,
// (undocumented)
NotExtended = 510,
// (undocumented)
NotFound = 404,
// (undocumented)
NotImplemented = 501,
// (undocumented)
NotModified = 304,
// (undocumented)
Ok = 200,
// (undocumented)
PartialContent = 206,
// (undocumented)
PayloadTooLarge = 413,
// (undocumented)
PaymentRequired = 402,
// (undocumented)
PermanentRedirect = 308,
// (undocumented)
PreconditionFailed = 412,
// (undocumented)
PreconditionRequired = 428,
// (undocumented)
Processing = 102,
// (undocumented)
ProxyAuthenticationRequired = 407,
// (undocumented)
RangeNotSatisfiable = 416,
// (undocumented)
RequestHeaderFieldsTooLarge = 431,
// (undocumented)
RequestTimeout = 408,
// (undocumented)
ResetContent = 205,
// (undocumented)
SeeOther = 303,
// (undocumented)
ServiceUnavailable = 503,
// (undocumented)
SwitchingProtocols = 101,
// (undocumented)
TemporaryRedirect = 307,
// (undocumented)
TooEarly = 425,
// (undocumented)
TooManyRequests = 429,
// (undocumented)
Unauthorized = 401,
// (undocumented)
UnavailableForLegalReasons = 451,
// (undocumented)
UnprocessableEntity = 422,
// (undocumented)
UnsupportedMediaType = 415,
// (undocumented)
Unused = 306,
// (undocumented)
UpgradeRequired = 426,
// (undocumented)
UriTooLong = 414,
// (undocumented)
UseProxy = 305,
// (undocumented)
VariantAlsoNegotiates = 506
}
// @public
export type HttpTransferCacheOptions = {
includeHeaders?: string[];
filter?: (req: HttpRequest<unknown>) => boolean;
includePostRequests?: boolean;
includeRequestsWithAuthHeaders?: boolean;
};
// @public
export interface HttpUploadProgressEvent extends HttpProgressEvent {
// (undocumented)
type: HttpEventType.UploadProgress;
}
// @public
export class HttpUrlEncodingCodec implements HttpParameterCodec {
decodeKey(key: string): string;
decodeValue(value: string): string;
encodeKey(key: string): string;
encodeValue(value: string): string;
}
// @public
export interface HttpUserEvent<T> {
// (undocumented)
type: HttpEventType.User;
}
// @public
export class HttpXhrBackend implements HttpBackend {
constructor(xhrFactory: XhrFactory);
handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<HttpXhrBackend, never>;
// (undocumented)
static ɵprov: i0.ɵɵInjectableDeclaration<HttpXhrBackend>;
}
// @public
export abstract class HttpXsrfTokenExtractor {
abstract getToken(): string | null;
}
// @public
export class JsonpClientBackend implements HttpBackend {
constructor(callbackMap: JsonpCallbackContext, document: any);
handle(req: HttpRequest<never>): Observable<HttpEvent<any>>;
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<JsonpClientBackend, never>;
// (undocumented)
static ɵprov: i0.ɵɵInjectableDeclaration<JsonpClientBackend>;
}
// @public
export class JsonpInterceptor {
constructor(injector: EnvironmentInjector);
intercept(initialRequest: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
// (undocumented)
static ɵfac: i0.ɵɵFactoryDeclaration<JsonpInterceptor, never>;
// (undocumented)
static ɵprov: i0.ɵɵInjectableDeclaration<JsonpInterceptor>;
}
// @public
export function provideHttpClient(...features: HttpFeature<HttpFeatureKind>[]): EnvironmentProviders;
// @public
export function withFetch(): HttpFeature<HttpFeatureKind.Fetch>;
// @public
export function withInterceptors(interceptorFns: HttpInterceptorFn[]): HttpFeature<HttpFeatureKind.Interceptors>;
// @public
export function withInterceptorsFromDi(): HttpFeature<HttpFeatureKind.LegacyInterceptors>;
// @public
export function withJsonpSupport(): HttpFeature<HttpFeatureKind.JsonpSupport>;
// @public
export function withNoXsrfProtection(): HttpFeature<HttpFeatureKind.NoXsrfProtection>;
// @public
export function withRequestsMadeViaParent(): HttpFeature<HttpFeatureKind.RequestsMadeViaParent>;
// @public
export function withXsrfConfiguration({ cookieName, headerName, }: {
cookieName?: string;
headerName?: string;
}): HttpFeature<HttpFeatureKind.CustomXsrfConfiguration>;
// (No @packageDocumentation comment for this package)
```
Reference in a new issue View git blame Copy permalink