honeymoose/angular-cn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
angular-cn/goldens/public-api/common/http/http.d.ts

1815 lines
57 KiB
TypeScript
Raw Normal View History

feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
export declare const HTTP_INTERCEPTORS: InjectionToken<HttpInterceptor[]>;
export declare abstract class HttpBackend implements HttpHandler {
abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
}
export declare class HttpClient {
constructor(handler: HttpHandler);
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<ArrayBuffer>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<Blob>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<string>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<ArrayBuffer>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<Blob>>;
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'text';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<string>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<Object>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
delete<T>(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<T>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpResponse<ArrayBuffer>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpResponse<Blob>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpResponse<string>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
delete(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpResponse<Object>>;
delete<T>(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpResponse<T>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
delete(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<Object>;
delete<T>(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<T>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<ArrayBuffer>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<Blob>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<string>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpEvent<ArrayBuffer>>;
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpEvent<Blob>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'text';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<string>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<Object>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
get<T>(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<T>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpResponse<ArrayBuffer>>;
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpResponse<Blob>>;
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpResponse<string>>;
get(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<Object>>;
get<T>(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<T>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
get(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<Object>;
get<T>(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<T>;
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<ArrayBuffer>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<Blob>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'text';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<string>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<ArrayBuffer>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<Blob>>;
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'text';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<string>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<Object>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
head<T>(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<T>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<ArrayBuffer>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'blob';
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<Blob>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<string>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
head(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<Object>>;
head<T>(url: string, options: {
headers?: HttpHeaders | {
[header: string]: string | string[];
};
observe: 'response';
params?: HttpParams | {
[param: string]: string | string[];
};
reportProgress?: boolean;
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<T>>;
head(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<Object>;
head<T>(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<T>;
jsonp(url: string, callbackParam: string): Observable<Object>;
jsonp<T>(url: string, callbackParam: string): Observable<T>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<ArrayBuffer>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<Blob>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<string>;
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpEvent<ArrayBuffer>>;
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpEvent<Blob>>;
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpEvent<string>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<Object>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
options<T>(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<T>>;
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpResponse<ArrayBuffer>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpResponse<Blob>>;
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpResponse<string>>;
options(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<Object>>;
options<T>(url: string, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<T>>;
options(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<Object>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
options<T>(url: string, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<T>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<ArrayBuffer>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<Blob>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<string>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpEvent<ArrayBuffer>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<Blob>>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'text';
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<string>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<Object>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
patch<T>(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<T>>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpResponse<ArrayBuffer>>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpResponse<Blob>>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpResponse<string>>;
patch(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<Object>>;
patch<T>(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<T>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
patch(url: string, body: any | null, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<Object>;
patch<T>(url: string, body: any | null, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<T>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<ArrayBuffer>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<Blob>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<string>;
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpEvent<ArrayBuffer>>;
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpEvent<Blob>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'text';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<string>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<Object>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
post<T>(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
}): Observable<HttpEvent<T>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpResponse<ArrayBuffer>>;
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpResponse<Blob>>;
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpResponse<string>>;
post(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<Object>>;
post<T>(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<T>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
post(url: string, body: any | null, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<Object>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
post<T>(url: string, body: any | null, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<T>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'arraybuffer';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<ArrayBuffer>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<Blob>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'text';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<string>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<ArrayBuffer>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<Blob>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpEvent<string>>;
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpEvent<Object>>;
put<T>(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
fix(common): add `params` and `reportProgress` options to `HttpClient.put()` overload (#37873) When the response type is JSON, the `put()` overload signature did not have `reportProgress` and `params` options. This makes it difficult to type-check this overload. This commit adds them to the overload signature. Fixes #23600 PR Close #37873
2020-07-18 17:28:37 +05:30
params?: HttpParams | {
[param: string]: string | string[];
};
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<T>>;
put(url: string, body: any | null, options: {
headers?: HttpHeaders | {
[header: string]: string | string[];
};
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<ArrayBuffer>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'blob';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<Blob>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType: 'text';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<string>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
put(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<Object>>;
put<T>(url: string, body: any | null, options: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<HttpResponse<T>>;
put(url: string, body: any | null, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<Object>;
put<T>(url: string, body: any | null, options?: {
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
responseType?: 'json';
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
}): Observable<T>;
request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<ArrayBuffer>;
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<Blob>;
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<string>;
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
params?: HttpParams | {
[param: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpEvent<ArrayBuffer>>;
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpEvent<Blob>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpEvent<string>>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
request(method: string, url: string, options: {
body?: any;
headers?: HttpHeaders | {
[header: string]: string | string[];
};
reportProgress?: boolean;
observe: 'events';
params?: HttpParams | {
[param: string]: string | string[];
};
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<any>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
request<R>(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'events';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpEvent<R>>;
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'arraybuffer';
withCredentials?: boolean;
}): Observable<HttpResponse<ArrayBuffer>>;
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'blob';
withCredentials?: boolean;
}): Observable<HttpResponse<Blob>>;
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType: 'text';
withCredentials?: boolean;
}): Observable<HttpResponse<string>>;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
request(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
fix(common): document HttpClient, fixing a few other issues
2017-07-12 17:00:23 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<Object>>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
request<R>(method: string, url: string, options: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe: 'response';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
withCredentials?: boolean;
}): Observable<HttpResponse<R>>;
request(method: string, url: string, options?: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
observe?: 'body';
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
params?: HttpParams | {
[param: string]: string | string[];
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'json';
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
withCredentials?: boolean;
}): Observable<Object>;
build: update API Golden files after node 12 update (#34955) PR Close #34955
2020-01-24 10:55:39 -08:00
request<R>(method: string, url: string, options?: {
body?: any;
headers?: HttpHeaders | {
[header: string]: string | string[];
};
observe?: 'body';
params?: HttpParams | {
[param: string]: string | string[];
};
responseType?: 'json';
reportProgress?: boolean;
withCredentials?: boolean;
}): Observable<R>;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
request(method: string, url: string, options?: {
body?: any;
feat(common): accept object map for HttpClient headers & params (#18490) Today, constructing a new GET request with headers looks like: const headers = new HttpHeaders({ 'My-Header': 'header value', }); http.get('/url', {headers}).subscribe(...); This indirection is unnecessary. It'd be more ergonomic to write: http.get('/url', {headers: {'My-Header': 'header value'}}).subscribe(...); This commit allows that new syntax, both for HttpHeaders and HttpParams. In the HttpParams case it also allows construction of HttpParams with a map. PR Close #18490
2017-08-01 15:43:39 -07:00
headers?: HttpHeaders | {
[header: string]: string | string[];
};
params?: HttpParams | {
[param: string]: string | string[];
};
refactor(http): inline HttpObserve (#18417) Inline `HttpObserve` for better type safety. Fix #18146 PR Close #18417
2017-07-31 18:40:01 +12:00
observe?: 'body' | 'events' | 'response';
fix(common): expose reportProgress option on HttpClient API (#18083)
2017-07-13 16:19:52 -07:00
reportProgress?: boolean;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
}): Observable<any>;
}
export declare class HttpClientJsonpModule {
}
export declare class HttpClientModule {
}
fix(common): rename HttpXsrfModule to HttpClientXsrfModule
2017-07-14 09:44:33 -07:00
export declare class HttpClientXsrfModule {
refactor(ivy): pre-factor: set explicit type parameters for ModuleWithProviders (#25970) Ivy depends on having the generic type token later when reading the ModuleWithProviders from a .d.ts file. PR Close #25970
2018-09-14 14:55:16 -07:00
static disable(): ModuleWithProviders<HttpClientXsrfModule>;
fix(common): rename HttpXsrfModule to HttpClientXsrfModule
2017-07-14 09:44:33 -07:00
static withOptions(options?: {
cookieName?: string;
headerName?: string;
refactor(ivy): pre-factor: set explicit type parameters for ModuleWithProviders (#25970) Ivy depends on having the generic type token later when reading the ModuleWithProviders from a .d.ts file. PR Close #25970
2018-09-14 14:55:16 -07:00
}): ModuleWithProviders<HttpClientXsrfModule>;
fix(common): rename HttpXsrfModule to HttpClientXsrfModule
2017-07-14 09:44:33 -07:00
}
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
export declare interface HttpDownloadProgressEvent extends HttpProgressEvent {
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
partialText?: string;
type: HttpEventType.DownloadProgress;
}
export declare class HttpErrorResponse extends HttpResponseBase implements Error {
readonly error: any | null;
readonly message: string;
feat: add support for TypeScript 3.1 (#26151) PR Close #26151
2018-09-27 16:47:19 -07:00
readonly name = "HttpErrorResponse";
readonly ok = false;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
constructor(init: {
error?: any;
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
});
}
export declare type HttpEvent<T> = HttpSentEvent | HttpHeaderResponse | HttpResponse<T> | HttpProgressEvent | HttpUserEvent<T>;
export declare enum HttpEventType {
Sent = 0,
UploadProgress = 1,
ResponseHeader = 2,
DownloadProgress = 3,
Response = 4,
feat: typescript 2.9 support (#24652) PR Close #24652
2018-06-25 11:11:22 +02:00
User = 5
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
}
export declare abstract class HttpHandler {
abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
}
export declare class HttpHeaderResponse extends HttpResponseBase {
readonly type: HttpEventType.ResponseHeader;
constructor(init?: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
});
clone(update?: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
}): HttpHeaderResponse;
}
export declare class HttpHeaders {
constructor(headers?: string | {
[name: string]: string | string[];
});
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;
}
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
export declare interface HttpInterceptor {
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
}
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
export declare interface HttpParameterCodec {
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
decodeKey(key: string): string;
decodeValue(value: string): string;
encodeKey(key: string): string;
encodeValue(value: string): string;
}
export declare class HttpParams {
revert: docs(common): add `HttpParamsOptions` to the public API (#20332) This reverts commit 7b7757dd3d38a95ed20a6dd2d6db44f269eec087.
2018-03-26 14:43:14 -04:00
constructor(options?: HttpParamsOptions);
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
append(param: string, value: string): HttpParams;
feat(common): implement `appendAll()` method on `HttpParams` (#20930) Adds an `appendAll()` method to `HttpParams` that can construct the HTTP request/response body from an object of parameters and values. This avoids calling `append()` multiple times when multiple parameters need to be added. Fixes #20798 PR Close #20930
2020-12-06 18:19:58 +01:00
appendAll(params: {
[param: string]: string | string[];
}): HttpParams;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
delete(param: string, value?: string): HttpParams;
get(param: string): string | null;
getAll(param: string): string[] | null;
has(param: string): boolean;
keys(): string[];
set(param: string, value: string): HttpParams;
toString(): string;
}
fix(common): add `HttpParamsOptions` to the public api (#35829) The `HttpParamsOptions` was not documented or included in the public API even though it is a constructor argument of `HttpParams` which is a part of the public API. This commit adds the `HttpParamsOptions` into the exports, thus making it a part of the public API. Resolves #20276 PR Close #35829
2020-03-03 10:51:32 -05:00
export declare interface HttpParamsOptions {
encoder?: HttpParameterCodec;
fromObject?: {
[param: string]: string | ReadonlyArray<string>;
};
fromString?: string;
}
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
export declare interface HttpProgressEvent {
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
loaded: number;
total?: number;
type: HttpEventType.DownloadProgress | HttpEventType.UploadProgress;
}
export declare class HttpRequest<T> {
readonly body: T | null;
readonly headers: HttpHeaders;
readonly method: string;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
readonly params: HttpParams;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
readonly reportProgress: boolean;
readonly responseType: 'arraybuffer' | 'blob' | 'json' | 'text';
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
readonly url: string;
readonly urlWithParams: string;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
readonly withCredentials: boolean;
constructor(method: 'DELETE' | 'GET' | 'HEAD' | 'JSONP' | 'OPTIONS', url: string, init?: {
headers?: HttpHeaders;
reportProgress?: boolean;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
params?: HttpParams;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
});
constructor(method: 'POST' | 'PUT' | 'PATCH', url: string, body: T | null, init?: {
headers?: HttpHeaders;
reportProgress?: boolean;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
params?: HttpParams;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
});
constructor(method: string, url: string, body: T | null, init?: {
headers?: HttpHeaders;
reportProgress?: boolean;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
params?: HttpParams;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
});
clone(): HttpRequest<T>;
clone(update: {
headers?: HttpHeaders;
reportProgress?: boolean;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
params?: HttpParams;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
body?: T | null;
method?: string;
url?: string;
setHeaders?: {
[name: string]: string | string[];
};
setParams?: {
[param: string]: string;
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
}): HttpRequest<T>;
clone<V>(update: {
headers?: HttpHeaders;
reportProgress?: boolean;
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
params?: HttpParams;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
withCredentials?: boolean;
body?: V | null;
method?: string;
url?: string;
setHeaders?: {
[name: string]: string | string[];
};
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
setParams?: {
[param: string]: string;
};
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
}): HttpRequest<V>;
detectContentTypeHeader(): string | null;
serializeBody(): ArrayBuffer | Blob | FormData | string | null;
}
export declare class HttpResponse<T> extends HttpResponseBase {
readonly body: T | null;
readonly type: HttpEventType.Response;
constructor(init?: {
body?: T | null;
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
});
clone(): HttpResponse<T>;
clone(update: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
}): HttpResponse<T>;
clone<V>(update: {
body?: V | null;
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
}): HttpResponse<V>;
}
export declare abstract class HttpResponseBase {
readonly headers: HttpHeaders;
readonly ok: boolean;
readonly status: number;
readonly statusText: string;
readonly type: HttpEventType.Response | HttpEventType.ResponseHeader;
readonly url: string | null;
constructor(init: {
headers?: HttpHeaders;
status?: number;
statusText?: string;
url?: string;
}, defaultStatus?: number, defaultStatusText?: string);
}
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
export declare interface HttpSentEvent {
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
type: HttpEventType.Sent;
fix(common): expose the `HttpUploadProgressEvent` interface as public API (#30852) Fixes #30814 PR Close #30852
2019-06-05 13:36:06 +05:30
}
feat(http): expose a list of human-readable http status codes (#23548) They aim to improve code readability. Since they are defined by `const enum` they have zero runtime performance impact over just using constant literals. Fixes #23543 PR Close #23548
2021-01-26 19:06:42 +01:00
export declare const enum HttpStatusCode {
Continue = 100,
SwitchingProtocols = 101,
Processing = 102,
EarlyHints = 103,
Ok = 200,
Created = 201,
Accepted = 202,
NonAuthoritativeInformation = 203,
NoContent = 204,
ResetContent = 205,
PartialContent = 206,
MultiStatus = 207,
AlreadyReported = 208,
ImUsed = 226,
MultipleChoices = 300,
MovedPermanently = 301,
Found = 302,
SeeOther = 303,
NotModified = 304,
UseProxy = 305,
Unused = 306,
TemporaryRedirect = 307,
PermanentRedirect = 308,
BadRequest = 400,
Unauthorized = 401,
PaymentRequired = 402,
Forbidden = 403,
NotFound = 404,
MethodNotAllowed = 405,
NotAcceptable = 406,
ProxyAuthenticationRequired = 407,
RequestTimeout = 408,
Conflict = 409,
Gone = 410,
LengthRequired = 411,
PreconditionFailed = 412,
PayloadTooLarge = 413,
UriTooLong = 414,
UnsupportedMediaType = 415,
RangeNotSatisfiable = 416,
ExpectationFailed = 417,
ImATeapot = 418,
MisdirectedRequest = 421,
UnprocessableEntity = 422,
Locked = 423,
FailedDependency = 424,
TooEarly = 425,
UpgradeRequired = 426,
PreconditionRequired = 428,
TooManyRequests = 429,
RequestHeaderFieldsTooLarge = 431,
UnavailableForLegalReasons = 451,
InternalServerError = 500,
NotImplemented = 501,
BadGateway = 502,
ServiceUnavailable = 503,
GatewayTimeout = 504,
HttpVersionNotSupported = 505,
VariantAlsoNegotiates = 506,
InsufficientStorage = 507,
LoopDetected = 508,
NotExtended = 510,
NetworkAuthenticationRequired = 511
}
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
export declare interface HttpUploadProgressEvent extends HttpProgressEvent {
fix(common): expose the `HttpUploadProgressEvent` interface as public API (#30852) Fixes #30814 PR Close #30852
2019-06-05 13:36:06 +05:30
type: HttpEventType.UploadProgress;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
}
feat(common): two missing features in HttpClient (#17996) - Add params to HttpRequest API - Add optional description to testing APIs
2017-07-07 14:56:36 -07:00
export declare class HttpUrlEncodingCodec implements HttpParameterCodec {
style(common): fix short param names (#23667) PR Close #23667
2018-05-03 09:53:12 +01:00
decodeKey(key: string): string;
decodeValue(value: string): string;
encodeKey(key: string): string;
encodeValue(value: string): string;
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
}
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
export declare interface HttpUserEvent<T> {
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
type: HttpEventType.User;
}
export declare class HttpXhrBackend implements HttpBackend {
constructor(xhrFactory: XhrFactory);
handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
}
feat(common): on-by-default XSRF support in HttpClient (#18108) Fixes #18100
2017-07-13 17:22:02 -07:00
export declare abstract class HttpXsrfTokenExtractor {
abstract getToken(): string | null;
}
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
export declare class JsonpClientBackend implements HttpBackend {
ci: move public-api goldens to goldens directory (#35768) Moves the public api .d.ts files from tools/public_api_guard to goldens/public-api. Additionally, provides a README in the goldens directory and a script assist in testing the current state of the repo against the goldens as well as a command for accepting all changes to the goldens in a single command. PR Close #35768
2020-02-26 09:09:35 -08:00
constructor(callbackMap: ɵangular_packages_common_http_http_b, document: any);
feat(common): new HttpClient API HttpClient is an evolution of the existing Angular HTTP API, which exists alongside of it in a separate package, @angular/common/http. This structure ensures that existing codebases can slowly migrate to the new API. The new API improves significantly on the ergonomics and features of the legacy API. A partial list of new features includes: * Typed, synchronous response body access, including support for JSON body types * JSON is an assumed default and no longer needs to be explicitly parsed * Interceptors allow middleware logic to be inserted into the pipeline * Immutable request/response objects * Progress events for both request upload and response download * Post-request verification & flush based testing framework
2017-03-22 17:13:24 -07:00
handle(req: HttpRequest<never>): Observable<HttpEvent<any>>;
}
export declare class JsonpInterceptor {
constructor(jsonp: JsonpClientBackend);
intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
}
export declare abstract class XhrFactory {
abstract build(): XMLHttpRequest;
}
Reference in New Issue Copy Permalink