@angular/common 20.1.0-next.1 → 20.1.0-next.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/{common_module.d-Cpp8wYHt.d.ts → common_module.d.d.ts} +11 -11
- package/fesm2022/common.mjs +31 -20
- package/fesm2022/common.mjs.map +1 -1
- package/fesm2022/{common_module-D4mHDfs1.mjs → common_module.mjs} +97 -97
- package/fesm2022/common_module.mjs.map +1 -0
- package/fesm2022/http/testing.mjs +10 -10
- package/fesm2022/http/testing.mjs.map +1 -1
- package/fesm2022/http.mjs +23 -17
- package/fesm2022/http.mjs.map +1 -1
- package/fesm2022/{location-BIEtBxGx.mjs → location.mjs} +17 -17
- package/fesm2022/location.mjs.map +1 -0
- package/fesm2022/{module-CBsxN_3E.mjs → module.mjs} +70 -39
- package/fesm2022/module.mjs.map +1 -0
- package/fesm2022/{platform_navigation-B45Jeakb.mjs → platform_navigation.mjs} +5 -5
- package/fesm2022/platform_navigation.mjs.map +1 -0
- package/fesm2022/testing.mjs +15 -15
- package/fesm2022/testing.mjs.map +1 -1
- package/fesm2022/upgrade.mjs +7 -7
- package/fesm2022/upgrade.mjs.map +1 -1
- package/fesm2022/{xhr-CEmSPUGj.mjs → xhr.mjs} +2 -2
- package/fesm2022/xhr.mjs.map +1 -0
- package/http/index.d.ts +250 -5
- package/http/testing/index.d.ts +2 -2
- package/index.d.ts +6 -6
- package/{module.d-yNBsZ8gb.d.ts → module.d.d.ts} +24 -1
- package/package.json +2 -2
- package/{platform_location.d-Lbv6Ueec.d.ts → platform_location.d.d.ts} +1 -1
- package/testing/index.d.ts +2 -2
- package/upgrade/index.d.ts +3 -3
- package/{xhr.d-D_1kTQR5.d.ts → xhr.d.d.ts} +1 -1
- package/fesm2022/common_module-D4mHDfs1.mjs.map +0 -1
- package/fesm2022/location-BIEtBxGx.mjs.map +0 -1
- package/fesm2022/module-CBsxN_3E.mjs.map +0 -1
- package/fesm2022/platform_navigation-B45Jeakb.mjs.map +0 -1
- package/fesm2022/xhr-CEmSPUGj.mjs.map +0 -1
package/http/index.d.ts
CHANGED
|
@@ -1,15 +1,15 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* @license Angular v20.1.0-next.
|
|
2
|
+
* @license Angular v20.1.0-next.3
|
|
3
3
|
* (c) 2010-2025 Google LLC. https://angular.io/
|
|
4
4
|
* License: MIT
|
|
5
5
|
*/
|
|
6
6
|
|
|
7
7
|
import { Observable } from 'rxjs';
|
|
8
|
-
import { HttpRequest, HttpEvent, HttpHeaders, HttpContext, HttpParams, HttpResponse, HttpProgressEvent } from '../module.d
|
|
9
|
-
export { HttpClientJsonpModule, HttpClientModule, HttpClientXsrfModule, HttpContextToken, HttpDownloadProgressEvent, HttpErrorResponse, HttpEventType, HttpHeaderResponse, HttpParameterCodec, HttpParamsOptions, HttpResponseBase, HttpSentEvent, HttpStatusCode, HttpUploadProgressEvent, HttpUrlEncodingCodec, HttpUserEvent } from '../module.d
|
|
8
|
+
import { HttpRequest, HttpEvent, HttpHeaders, HttpContext, HttpParams, HttpResponse, HttpProgressEvent } from '../module.d.js';
|
|
9
|
+
export { HttpClientJsonpModule, HttpClientModule, HttpClientXsrfModule, HttpContextToken, HttpDownloadProgressEvent, HttpErrorResponse, HttpEventType, HttpHeaderResponse, HttpParameterCodec, HttpParamsOptions, HttpResponseBase, HttpSentEvent, HttpStatusCode, HttpUploadProgressEvent, HttpUrlEncodingCodec, HttpUserEvent } from '../module.d.js';
|
|
10
10
|
import * as i0 from '@angular/core';
|
|
11
11
|
import { InjectionToken, EnvironmentInjector, Provider, EnvironmentProviders, Injector, ValueEqualityFn, WritableResource, ResourceRef, Signal } from '@angular/core';
|
|
12
|
-
import { XhrFactory } from '../xhr.d
|
|
12
|
+
import { XhrFactory } from '../xhr.d.js';
|
|
13
13
|
|
|
14
14
|
/**
|
|
15
15
|
* Transforms an `HttpRequest` into a stream of `HttpEvent`s, one of which will likely be a
|
|
@@ -122,7 +122,8 @@ declare class HttpClient {
|
|
|
122
122
|
reportProgress?: boolean;
|
|
123
123
|
responseType: 'arraybuffer';
|
|
124
124
|
withCredentials?: boolean;
|
|
125
|
-
|
|
125
|
+
priority?: RequestPriority;
|
|
126
|
+
cache?: RequestCache;
|
|
126
127
|
transferCache?: {
|
|
127
128
|
includeHeaders?: string[];
|
|
128
129
|
} | boolean;
|
|
@@ -147,6 +148,8 @@ declare class HttpClient {
|
|
|
147
148
|
responseType: 'blob';
|
|
148
149
|
withCredentials?: boolean;
|
|
149
150
|
keepalive?: boolean;
|
|
151
|
+
priority?: RequestPriority;
|
|
152
|
+
cache?: RequestCache;
|
|
150
153
|
transferCache?: {
|
|
151
154
|
includeHeaders?: string[];
|
|
152
155
|
} | boolean;
|
|
@@ -171,6 +174,8 @@ declare class HttpClient {
|
|
|
171
174
|
responseType: 'text';
|
|
172
175
|
withCredentials?: boolean;
|
|
173
176
|
keepalive?: boolean;
|
|
177
|
+
priority?: RequestPriority;
|
|
178
|
+
cache?: RequestCache;
|
|
174
179
|
transferCache?: {
|
|
175
180
|
includeHeaders?: string[];
|
|
176
181
|
} | boolean;
|
|
@@ -196,6 +201,8 @@ declare class HttpClient {
|
|
|
196
201
|
responseType: 'arraybuffer';
|
|
197
202
|
withCredentials?: boolean;
|
|
198
203
|
keepalive?: boolean;
|
|
204
|
+
priority?: RequestPriority;
|
|
205
|
+
cache?: RequestCache;
|
|
199
206
|
transferCache?: {
|
|
200
207
|
includeHeaders?: string[];
|
|
201
208
|
} | boolean;
|
|
@@ -221,6 +228,8 @@ declare class HttpClient {
|
|
|
221
228
|
responseType: 'blob';
|
|
222
229
|
withCredentials?: boolean;
|
|
223
230
|
keepalive?: boolean;
|
|
231
|
+
priority?: RequestPriority;
|
|
232
|
+
cache?: RequestCache;
|
|
224
233
|
transferCache?: {
|
|
225
234
|
includeHeaders?: string[];
|
|
226
235
|
} | boolean;
|
|
@@ -246,6 +255,8 @@ declare class HttpClient {
|
|
|
246
255
|
responseType: 'text';
|
|
247
256
|
withCredentials?: boolean;
|
|
248
257
|
keepalive?: boolean;
|
|
258
|
+
priority?: RequestPriority;
|
|
259
|
+
cache?: RequestCache;
|
|
249
260
|
transferCache?: {
|
|
250
261
|
includeHeaders?: string[];
|
|
251
262
|
} | boolean;
|
|
@@ -271,6 +282,8 @@ declare class HttpClient {
|
|
|
271
282
|
responseType?: 'json';
|
|
272
283
|
withCredentials?: boolean;
|
|
273
284
|
keepalive?: boolean;
|
|
285
|
+
priority?: RequestPriority;
|
|
286
|
+
cache?: RequestCache;
|
|
274
287
|
transferCache?: {
|
|
275
288
|
includeHeaders?: string[];
|
|
276
289
|
} | boolean;
|
|
@@ -296,6 +309,8 @@ declare class HttpClient {
|
|
|
296
309
|
responseType?: 'json';
|
|
297
310
|
withCredentials?: boolean;
|
|
298
311
|
keepalive?: boolean;
|
|
312
|
+
priority?: RequestPriority;
|
|
313
|
+
cache?: RequestCache;
|
|
299
314
|
transferCache?: {
|
|
300
315
|
includeHeaders?: string[];
|
|
301
316
|
} | boolean;
|
|
@@ -320,6 +335,8 @@ declare class HttpClient {
|
|
|
320
335
|
responseType: 'arraybuffer';
|
|
321
336
|
withCredentials?: boolean;
|
|
322
337
|
keepalive?: boolean;
|
|
338
|
+
priority?: RequestPriority;
|
|
339
|
+
cache?: RequestCache;
|
|
323
340
|
transferCache?: {
|
|
324
341
|
includeHeaders?: string[];
|
|
325
342
|
} | boolean;
|
|
@@ -343,6 +360,8 @@ declare class HttpClient {
|
|
|
343
360
|
responseType: 'blob';
|
|
344
361
|
withCredentials?: boolean;
|
|
345
362
|
keepalive?: boolean;
|
|
363
|
+
priority?: RequestPriority;
|
|
364
|
+
cache?: RequestCache;
|
|
346
365
|
transferCache?: {
|
|
347
366
|
includeHeaders?: string[];
|
|
348
367
|
} | boolean;
|
|
@@ -367,6 +386,8 @@ declare class HttpClient {
|
|
|
367
386
|
responseType: 'text';
|
|
368
387
|
withCredentials?: boolean;
|
|
369
388
|
keepalive?: boolean;
|
|
389
|
+
priority?: RequestPriority;
|
|
390
|
+
cache?: RequestCache;
|
|
370
391
|
transferCache?: {
|
|
371
392
|
includeHeaders?: string[];
|
|
372
393
|
} | boolean;
|
|
@@ -392,6 +413,8 @@ declare class HttpClient {
|
|
|
392
413
|
responseType?: 'json';
|
|
393
414
|
withCredentials?: boolean;
|
|
394
415
|
keepalive?: boolean;
|
|
416
|
+
priority?: RequestPriority;
|
|
417
|
+
cache?: RequestCache;
|
|
395
418
|
}): Observable<HttpResponse<Object>>;
|
|
396
419
|
/**
|
|
397
420
|
* Constructs a request which interprets the body as a JavaScript object and returns
|
|
@@ -413,6 +436,8 @@ declare class HttpClient {
|
|
|
413
436
|
responseType?: 'json';
|
|
414
437
|
withCredentials?: boolean;
|
|
415
438
|
keepalive?: boolean;
|
|
439
|
+
priority?: RequestPriority;
|
|
440
|
+
cache?: RequestCache;
|
|
416
441
|
transferCache?: {
|
|
417
442
|
includeHeaders?: string[];
|
|
418
443
|
} | boolean;
|
|
@@ -437,6 +462,8 @@ declare class HttpClient {
|
|
|
437
462
|
reportProgress?: boolean;
|
|
438
463
|
withCredentials?: boolean;
|
|
439
464
|
keepalive?: boolean;
|
|
465
|
+
priority?: RequestPriority;
|
|
466
|
+
cache?: RequestCache;
|
|
440
467
|
transferCache?: {
|
|
441
468
|
includeHeaders?: string[];
|
|
442
469
|
} | boolean;
|
|
@@ -461,6 +488,8 @@ declare class HttpClient {
|
|
|
461
488
|
reportProgress?: boolean;
|
|
462
489
|
withCredentials?: boolean;
|
|
463
490
|
keepalive?: boolean;
|
|
491
|
+
priority?: RequestPriority;
|
|
492
|
+
cache?: RequestCache;
|
|
464
493
|
transferCache?: {
|
|
465
494
|
includeHeaders?: string[];
|
|
466
495
|
} | boolean;
|
|
@@ -484,6 +513,8 @@ declare class HttpClient {
|
|
|
484
513
|
responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
|
|
485
514
|
withCredentials?: boolean;
|
|
486
515
|
keepalive?: boolean;
|
|
516
|
+
priority?: RequestPriority;
|
|
517
|
+
cache?: RequestCache;
|
|
487
518
|
transferCache?: {
|
|
488
519
|
includeHeaders?: string[];
|
|
489
520
|
} | boolean;
|
|
@@ -506,6 +537,8 @@ declare class HttpClient {
|
|
|
506
537
|
responseType: 'arraybuffer';
|
|
507
538
|
withCredentials?: boolean;
|
|
508
539
|
keepalive?: boolean;
|
|
540
|
+
priority?: RequestPriority;
|
|
541
|
+
cache?: RequestCache;
|
|
509
542
|
body?: any | null;
|
|
510
543
|
}): Observable<ArrayBuffer>;
|
|
511
544
|
/**
|
|
@@ -526,6 +559,8 @@ declare class HttpClient {
|
|
|
526
559
|
responseType: 'blob';
|
|
527
560
|
withCredentials?: boolean;
|
|
528
561
|
keepalive?: boolean;
|
|
562
|
+
priority?: RequestPriority;
|
|
563
|
+
cache?: RequestCache;
|
|
529
564
|
body?: any | null;
|
|
530
565
|
}): Observable<Blob>;
|
|
531
566
|
/**
|
|
@@ -546,6 +581,8 @@ declare class HttpClient {
|
|
|
546
581
|
responseType: 'text';
|
|
547
582
|
withCredentials?: boolean;
|
|
548
583
|
keepalive?: boolean;
|
|
584
|
+
priority?: RequestPriority;
|
|
585
|
+
cache?: RequestCache;
|
|
549
586
|
body?: any | null;
|
|
550
587
|
}): Observable<string>;
|
|
551
588
|
/**
|
|
@@ -567,6 +604,8 @@ declare class HttpClient {
|
|
|
567
604
|
responseType: 'arraybuffer';
|
|
568
605
|
withCredentials?: boolean;
|
|
569
606
|
keepalive?: boolean;
|
|
607
|
+
priority?: RequestPriority;
|
|
608
|
+
cache?: RequestCache;
|
|
570
609
|
body?: any | null;
|
|
571
610
|
}): Observable<HttpEvent<ArrayBuffer>>;
|
|
572
611
|
/**
|
|
@@ -588,6 +627,8 @@ declare class HttpClient {
|
|
|
588
627
|
responseType: 'blob';
|
|
589
628
|
withCredentials?: boolean;
|
|
590
629
|
keepalive?: boolean;
|
|
630
|
+
priority?: RequestPriority;
|
|
631
|
+
cache?: RequestCache;
|
|
591
632
|
body?: any | null;
|
|
592
633
|
}): Observable<HttpEvent<Blob>>;
|
|
593
634
|
/**
|
|
@@ -609,6 +650,8 @@ declare class HttpClient {
|
|
|
609
650
|
responseType: 'text';
|
|
610
651
|
withCredentials?: boolean;
|
|
611
652
|
keepalive?: boolean;
|
|
653
|
+
priority?: RequestPriority;
|
|
654
|
+
cache?: RequestCache;
|
|
612
655
|
body?: any | null;
|
|
613
656
|
}): Observable<HttpEvent<string>>;
|
|
614
657
|
/**
|
|
@@ -630,6 +673,8 @@ declare class HttpClient {
|
|
|
630
673
|
responseType?: 'json';
|
|
631
674
|
withCredentials?: boolean;
|
|
632
675
|
keepalive?: boolean;
|
|
676
|
+
priority?: RequestPriority;
|
|
677
|
+
cache?: RequestCache;
|
|
633
678
|
body?: any | null;
|
|
634
679
|
}): Observable<HttpEvent<Object>>;
|
|
635
680
|
/**
|
|
@@ -651,6 +696,8 @@ declare class HttpClient {
|
|
|
651
696
|
responseType?: 'json';
|
|
652
697
|
withCredentials?: boolean;
|
|
653
698
|
keepalive?: boolean;
|
|
699
|
+
priority?: RequestPriority;
|
|
700
|
+
cache?: RequestCache;
|
|
654
701
|
body?: any | null;
|
|
655
702
|
}): Observable<HttpEvent<T>>;
|
|
656
703
|
/**
|
|
@@ -671,6 +718,8 @@ declare class HttpClient {
|
|
|
671
718
|
responseType: 'arraybuffer';
|
|
672
719
|
withCredentials?: boolean;
|
|
673
720
|
keepalive?: boolean;
|
|
721
|
+
priority?: RequestPriority;
|
|
722
|
+
cache?: RequestCache;
|
|
674
723
|
body?: any | null;
|
|
675
724
|
}): Observable<HttpResponse<ArrayBuffer>>;
|
|
676
725
|
/**
|
|
@@ -691,6 +740,8 @@ declare class HttpClient {
|
|
|
691
740
|
responseType: 'blob';
|
|
692
741
|
withCredentials?: boolean;
|
|
693
742
|
keepalive?: boolean;
|
|
743
|
+
priority?: RequestPriority;
|
|
744
|
+
cache?: RequestCache;
|
|
694
745
|
body?: any | null;
|
|
695
746
|
}): Observable<HttpResponse<Blob>>;
|
|
696
747
|
/**
|
|
@@ -711,6 +762,8 @@ declare class HttpClient {
|
|
|
711
762
|
responseType: 'text';
|
|
712
763
|
withCredentials?: boolean;
|
|
713
764
|
keepalive?: boolean;
|
|
765
|
+
priority?: RequestPriority;
|
|
766
|
+
cache?: RequestCache;
|
|
714
767
|
body?: any | null;
|
|
715
768
|
}): Observable<HttpResponse<string>>;
|
|
716
769
|
/**
|
|
@@ -732,6 +785,8 @@ declare class HttpClient {
|
|
|
732
785
|
responseType?: 'json';
|
|
733
786
|
withCredentials?: boolean;
|
|
734
787
|
keepalive?: boolean;
|
|
788
|
+
priority?: RequestPriority;
|
|
789
|
+
cache?: RequestCache;
|
|
735
790
|
body?: any | null;
|
|
736
791
|
}): Observable<HttpResponse<Object>>;
|
|
737
792
|
/**
|
|
@@ -752,6 +807,8 @@ declare class HttpClient {
|
|
|
752
807
|
responseType?: 'json';
|
|
753
808
|
withCredentials?: boolean;
|
|
754
809
|
keepalive?: boolean;
|
|
810
|
+
priority?: RequestPriority;
|
|
811
|
+
cache?: RequestCache;
|
|
755
812
|
body?: any | null;
|
|
756
813
|
}): Observable<HttpResponse<T>>;
|
|
757
814
|
/**
|
|
@@ -772,6 +829,8 @@ declare class HttpClient {
|
|
|
772
829
|
responseType?: 'json';
|
|
773
830
|
withCredentials?: boolean;
|
|
774
831
|
keepalive?: boolean;
|
|
832
|
+
priority?: RequestPriority;
|
|
833
|
+
cache?: RequestCache;
|
|
775
834
|
body?: any | null;
|
|
776
835
|
}): Observable<Object>;
|
|
777
836
|
/**
|
|
@@ -792,6 +851,8 @@ declare class HttpClient {
|
|
|
792
851
|
responseType?: 'json';
|
|
793
852
|
withCredentials?: boolean;
|
|
794
853
|
keepalive?: boolean;
|
|
854
|
+
priority?: RequestPriority;
|
|
855
|
+
cache?: RequestCache;
|
|
795
856
|
body?: any | null;
|
|
796
857
|
}): Observable<T>;
|
|
797
858
|
/**
|
|
@@ -812,6 +873,8 @@ declare class HttpClient {
|
|
|
812
873
|
responseType: 'arraybuffer';
|
|
813
874
|
withCredentials?: boolean;
|
|
814
875
|
keepalive?: boolean;
|
|
876
|
+
priority?: RequestPriority;
|
|
877
|
+
cache?: RequestCache;
|
|
815
878
|
transferCache?: {
|
|
816
879
|
includeHeaders?: string[];
|
|
817
880
|
} | boolean;
|
|
@@ -834,6 +897,8 @@ declare class HttpClient {
|
|
|
834
897
|
responseType: 'blob';
|
|
835
898
|
withCredentials?: boolean;
|
|
836
899
|
keepalive?: boolean;
|
|
900
|
+
priority?: RequestPriority;
|
|
901
|
+
cache?: RequestCache;
|
|
837
902
|
transferCache?: {
|
|
838
903
|
includeHeaders?: string[];
|
|
839
904
|
} | boolean;
|
|
@@ -856,6 +921,8 @@ declare class HttpClient {
|
|
|
856
921
|
responseType: 'text';
|
|
857
922
|
withCredentials?: boolean;
|
|
858
923
|
keepalive?: boolean;
|
|
924
|
+
priority?: RequestPriority;
|
|
925
|
+
cache?: RequestCache;
|
|
859
926
|
transferCache?: {
|
|
860
927
|
includeHeaders?: string[];
|
|
861
928
|
} | boolean;
|
|
@@ -879,6 +946,8 @@ declare class HttpClient {
|
|
|
879
946
|
responseType: 'arraybuffer';
|
|
880
947
|
withCredentials?: boolean;
|
|
881
948
|
keepalive?: boolean;
|
|
949
|
+
priority?: RequestPriority;
|
|
950
|
+
cache?: RequestCache;
|
|
882
951
|
transferCache?: {
|
|
883
952
|
includeHeaders?: string[];
|
|
884
953
|
} | boolean;
|
|
@@ -901,6 +970,8 @@ declare class HttpClient {
|
|
|
901
970
|
responseType: 'blob';
|
|
902
971
|
withCredentials?: boolean;
|
|
903
972
|
keepalive?: boolean;
|
|
973
|
+
priority?: RequestPriority;
|
|
974
|
+
cache?: RequestCache;
|
|
904
975
|
transferCache?: {
|
|
905
976
|
includeHeaders?: string[];
|
|
906
977
|
} | boolean;
|
|
@@ -923,6 +994,8 @@ declare class HttpClient {
|
|
|
923
994
|
responseType: 'text';
|
|
924
995
|
withCredentials?: boolean;
|
|
925
996
|
keepalive?: boolean;
|
|
997
|
+
priority?: RequestPriority;
|
|
998
|
+
cache?: RequestCache;
|
|
926
999
|
transferCache?: {
|
|
927
1000
|
includeHeaders?: string[];
|
|
928
1001
|
} | boolean;
|
|
@@ -945,6 +1018,8 @@ declare class HttpClient {
|
|
|
945
1018
|
responseType?: 'json';
|
|
946
1019
|
withCredentials?: boolean;
|
|
947
1020
|
keepalive?: boolean;
|
|
1021
|
+
priority?: RequestPriority;
|
|
1022
|
+
cache?: RequestCache;
|
|
948
1023
|
transferCache?: {
|
|
949
1024
|
includeHeaders?: string[];
|
|
950
1025
|
} | boolean;
|
|
@@ -967,6 +1042,8 @@ declare class HttpClient {
|
|
|
967
1042
|
responseType?: 'json';
|
|
968
1043
|
withCredentials?: boolean;
|
|
969
1044
|
keepalive?: boolean;
|
|
1045
|
+
priority?: RequestPriority;
|
|
1046
|
+
cache?: RequestCache;
|
|
970
1047
|
transferCache?: {
|
|
971
1048
|
includeHeaders?: string[];
|
|
972
1049
|
} | boolean;
|
|
@@ -990,6 +1067,8 @@ declare class HttpClient {
|
|
|
990
1067
|
responseType: 'arraybuffer';
|
|
991
1068
|
withCredentials?: boolean;
|
|
992
1069
|
keepalive?: boolean;
|
|
1070
|
+
priority?: RequestPriority;
|
|
1071
|
+
cache?: RequestCache;
|
|
993
1072
|
transferCache?: {
|
|
994
1073
|
includeHeaders?: string[];
|
|
995
1074
|
} | boolean;
|
|
@@ -1013,6 +1092,8 @@ declare class HttpClient {
|
|
|
1013
1092
|
responseType: 'blob';
|
|
1014
1093
|
withCredentials?: boolean;
|
|
1015
1094
|
keepalive?: boolean;
|
|
1095
|
+
priority?: RequestPriority;
|
|
1096
|
+
cache?: RequestCache;
|
|
1016
1097
|
transferCache?: {
|
|
1017
1098
|
includeHeaders?: string[];
|
|
1018
1099
|
} | boolean;
|
|
@@ -1036,6 +1117,8 @@ declare class HttpClient {
|
|
|
1036
1117
|
responseType: 'text';
|
|
1037
1118
|
withCredentials?: boolean;
|
|
1038
1119
|
keepalive?: boolean;
|
|
1120
|
+
priority?: RequestPriority;
|
|
1121
|
+
cache?: RequestCache;
|
|
1039
1122
|
transferCache?: {
|
|
1040
1123
|
includeHeaders?: string[];
|
|
1041
1124
|
} | boolean;
|
|
@@ -1059,6 +1142,8 @@ declare class HttpClient {
|
|
|
1059
1142
|
responseType?: 'json';
|
|
1060
1143
|
withCredentials?: boolean;
|
|
1061
1144
|
keepalive?: boolean;
|
|
1145
|
+
priority?: RequestPriority;
|
|
1146
|
+
cache?: RequestCache;
|
|
1062
1147
|
transferCache?: {
|
|
1063
1148
|
includeHeaders?: string[];
|
|
1064
1149
|
} | boolean;
|
|
@@ -1082,6 +1167,8 @@ declare class HttpClient {
|
|
|
1082
1167
|
responseType?: 'json';
|
|
1083
1168
|
withCredentials?: boolean;
|
|
1084
1169
|
keepalive?: boolean;
|
|
1170
|
+
priority?: RequestPriority;
|
|
1171
|
+
cache?: RequestCache;
|
|
1085
1172
|
transferCache?: {
|
|
1086
1173
|
includeHeaders?: string[];
|
|
1087
1174
|
} | boolean;
|
|
@@ -1105,6 +1192,8 @@ declare class HttpClient {
|
|
|
1105
1192
|
responseType?: 'json';
|
|
1106
1193
|
withCredentials?: boolean;
|
|
1107
1194
|
keepalive?: boolean;
|
|
1195
|
+
priority?: RequestPriority;
|
|
1196
|
+
cache?: RequestCache;
|
|
1108
1197
|
transferCache?: {
|
|
1109
1198
|
includeHeaders?: string[];
|
|
1110
1199
|
} | boolean;
|
|
@@ -1127,6 +1216,8 @@ declare class HttpClient {
|
|
|
1127
1216
|
responseType?: 'json';
|
|
1128
1217
|
withCredentials?: boolean;
|
|
1129
1218
|
keepalive?: boolean;
|
|
1219
|
+
priority?: RequestPriority;
|
|
1220
|
+
cache?: RequestCache;
|
|
1130
1221
|
transferCache?: {
|
|
1131
1222
|
includeHeaders?: string[];
|
|
1132
1223
|
} | boolean;
|
|
@@ -1149,6 +1240,8 @@ declare class HttpClient {
|
|
|
1149
1240
|
responseType: 'arraybuffer';
|
|
1150
1241
|
withCredentials?: boolean;
|
|
1151
1242
|
keepalive?: boolean;
|
|
1243
|
+
priority?: RequestPriority;
|
|
1244
|
+
cache?: RequestCache;
|
|
1152
1245
|
transferCache?: {
|
|
1153
1246
|
includeHeaders?: string[];
|
|
1154
1247
|
} | boolean;
|
|
@@ -1171,6 +1264,8 @@ declare class HttpClient {
|
|
|
1171
1264
|
responseType: 'blob';
|
|
1172
1265
|
withCredentials?: boolean;
|
|
1173
1266
|
keepalive?: boolean;
|
|
1267
|
+
priority?: RequestPriority;
|
|
1268
|
+
cache?: RequestCache;
|
|
1174
1269
|
transferCache?: {
|
|
1175
1270
|
includeHeaders?: string[];
|
|
1176
1271
|
} | boolean;
|
|
@@ -1193,6 +1288,8 @@ declare class HttpClient {
|
|
|
1193
1288
|
responseType: 'text';
|
|
1194
1289
|
withCredentials?: boolean;
|
|
1195
1290
|
keepalive?: boolean;
|
|
1291
|
+
priority?: RequestPriority;
|
|
1292
|
+
cache?: RequestCache;
|
|
1196
1293
|
transferCache?: {
|
|
1197
1294
|
includeHeaders?: string[];
|
|
1198
1295
|
} | boolean;
|
|
@@ -1216,6 +1313,8 @@ declare class HttpClient {
|
|
|
1216
1313
|
responseType: 'arraybuffer';
|
|
1217
1314
|
withCredentials?: boolean;
|
|
1218
1315
|
keepalive?: boolean;
|
|
1316
|
+
priority?: RequestPriority;
|
|
1317
|
+
cache?: RequestCache;
|
|
1219
1318
|
transferCache?: {
|
|
1220
1319
|
includeHeaders?: string[];
|
|
1221
1320
|
} | boolean;
|
|
@@ -1239,6 +1338,8 @@ declare class HttpClient {
|
|
|
1239
1338
|
responseType: 'blob';
|
|
1240
1339
|
withCredentials?: boolean;
|
|
1241
1340
|
keepalive?: boolean;
|
|
1341
|
+
priority?: RequestPriority;
|
|
1342
|
+
cache?: RequestCache;
|
|
1242
1343
|
transferCache?: {
|
|
1243
1344
|
includeHeaders?: string[];
|
|
1244
1345
|
} | boolean;
|
|
@@ -1262,6 +1363,8 @@ declare class HttpClient {
|
|
|
1262
1363
|
responseType: 'text';
|
|
1263
1364
|
withCredentials?: boolean;
|
|
1264
1365
|
keepalive?: boolean;
|
|
1366
|
+
priority?: RequestPriority;
|
|
1367
|
+
cache?: RequestCache;
|
|
1265
1368
|
transferCache?: {
|
|
1266
1369
|
includeHeaders?: string[];
|
|
1267
1370
|
} | boolean;
|
|
@@ -1285,6 +1388,8 @@ declare class HttpClient {
|
|
|
1285
1388
|
responseType?: 'json';
|
|
1286
1389
|
withCredentials?: boolean;
|
|
1287
1390
|
keepalive?: boolean;
|
|
1391
|
+
priority?: RequestPriority;
|
|
1392
|
+
cache?: RequestCache;
|
|
1288
1393
|
transferCache?: {
|
|
1289
1394
|
includeHeaders?: string[];
|
|
1290
1395
|
} | boolean;
|
|
@@ -1308,6 +1413,8 @@ declare class HttpClient {
|
|
|
1308
1413
|
responseType?: 'json';
|
|
1309
1414
|
withCredentials?: boolean;
|
|
1310
1415
|
keepalive?: boolean;
|
|
1416
|
+
priority?: RequestPriority;
|
|
1417
|
+
cache?: RequestCache;
|
|
1311
1418
|
transferCache?: {
|
|
1312
1419
|
includeHeaders?: string[];
|
|
1313
1420
|
} | boolean;
|
|
@@ -1331,6 +1438,8 @@ declare class HttpClient {
|
|
|
1331
1438
|
responseType: 'arraybuffer';
|
|
1332
1439
|
withCredentials?: boolean;
|
|
1333
1440
|
keepalive?: boolean;
|
|
1441
|
+
priority?: RequestPriority;
|
|
1442
|
+
cache?: RequestCache;
|
|
1334
1443
|
transferCache?: {
|
|
1335
1444
|
includeHeaders?: string[];
|
|
1336
1445
|
} | boolean;
|
|
@@ -1354,6 +1463,8 @@ declare class HttpClient {
|
|
|
1354
1463
|
responseType: 'blob';
|
|
1355
1464
|
withCredentials?: boolean;
|
|
1356
1465
|
keepalive?: boolean;
|
|
1466
|
+
priority?: RequestPriority;
|
|
1467
|
+
cache?: RequestCache;
|
|
1357
1468
|
transferCache?: {
|
|
1358
1469
|
includeHeaders?: string[];
|
|
1359
1470
|
} | boolean;
|
|
@@ -1377,6 +1488,8 @@ declare class HttpClient {
|
|
|
1377
1488
|
responseType: 'text';
|
|
1378
1489
|
withCredentials?: boolean;
|
|
1379
1490
|
keepalive?: boolean;
|
|
1491
|
+
priority?: RequestPriority;
|
|
1492
|
+
cache?: RequestCache;
|
|
1380
1493
|
transferCache?: {
|
|
1381
1494
|
includeHeaders?: string[];
|
|
1382
1495
|
} | boolean;
|
|
@@ -1400,6 +1513,8 @@ declare class HttpClient {
|
|
|
1400
1513
|
responseType?: 'json';
|
|
1401
1514
|
withCredentials?: boolean;
|
|
1402
1515
|
keepalive?: boolean;
|
|
1516
|
+
priority?: RequestPriority;
|
|
1517
|
+
cache?: RequestCache;
|
|
1403
1518
|
transferCache?: {
|
|
1404
1519
|
includeHeaders?: string[];
|
|
1405
1520
|
} | boolean;
|
|
@@ -1423,6 +1538,8 @@ declare class HttpClient {
|
|
|
1423
1538
|
responseType?: 'json';
|
|
1424
1539
|
withCredentials?: boolean;
|
|
1425
1540
|
keepalive?: boolean;
|
|
1541
|
+
priority?: RequestPriority;
|
|
1542
|
+
cache?: RequestCache;
|
|
1426
1543
|
transferCache?: {
|
|
1427
1544
|
includeHeaders?: string[];
|
|
1428
1545
|
} | boolean;
|
|
@@ -1446,6 +1563,8 @@ declare class HttpClient {
|
|
|
1446
1563
|
responseType?: 'json';
|
|
1447
1564
|
withCredentials?: boolean;
|
|
1448
1565
|
keepalive?: boolean;
|
|
1566
|
+
priority?: RequestPriority;
|
|
1567
|
+
cache?: RequestCache;
|
|
1449
1568
|
transferCache?: {
|
|
1450
1569
|
includeHeaders?: string[];
|
|
1451
1570
|
} | boolean;
|
|
@@ -1469,6 +1588,8 @@ declare class HttpClient {
|
|
|
1469
1588
|
responseType?: 'json';
|
|
1470
1589
|
withCredentials?: boolean;
|
|
1471
1590
|
keepalive?: boolean;
|
|
1591
|
+
priority?: RequestPriority;
|
|
1592
|
+
cache?: RequestCache;
|
|
1472
1593
|
transferCache?: {
|
|
1473
1594
|
includeHeaders?: string[];
|
|
1474
1595
|
} | boolean;
|
|
@@ -1513,6 +1634,8 @@ declare class HttpClient {
|
|
|
1513
1634
|
responseType: 'arraybuffer';
|
|
1514
1635
|
withCredentials?: boolean;
|
|
1515
1636
|
keepalive?: boolean;
|
|
1637
|
+
priority?: RequestPriority;
|
|
1638
|
+
cache?: RequestCache;
|
|
1516
1639
|
}): Observable<ArrayBuffer>;
|
|
1517
1640
|
/**
|
|
1518
1641
|
* Constructs an `OPTIONS` request that interprets the body as a `Blob` and returns
|
|
@@ -1532,6 +1655,8 @@ declare class HttpClient {
|
|
|
1532
1655
|
responseType: 'blob';
|
|
1533
1656
|
withCredentials?: boolean;
|
|
1534
1657
|
keepalive?: boolean;
|
|
1658
|
+
priority?: RequestPriority;
|
|
1659
|
+
cache?: RequestCache;
|
|
1535
1660
|
}): Observable<Blob>;
|
|
1536
1661
|
/**
|
|
1537
1662
|
* Constructs an `OPTIONS` request that interprets the body as a text string and
|
|
@@ -1551,6 +1676,8 @@ declare class HttpClient {
|
|
|
1551
1676
|
responseType: 'text';
|
|
1552
1677
|
withCredentials?: boolean;
|
|
1553
1678
|
keepalive?: boolean;
|
|
1679
|
+
priority?: RequestPriority;
|
|
1680
|
+
cache?: RequestCache;
|
|
1554
1681
|
}): Observable<string>;
|
|
1555
1682
|
/**
|
|
1556
1683
|
* Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`
|
|
@@ -1571,6 +1698,8 @@ declare class HttpClient {
|
|
|
1571
1698
|
responseType: 'arraybuffer';
|
|
1572
1699
|
withCredentials?: boolean;
|
|
1573
1700
|
keepalive?: boolean;
|
|
1701
|
+
priority?: RequestPriority;
|
|
1702
|
+
cache?: RequestCache;
|
|
1574
1703
|
}): Observable<HttpEvent<ArrayBuffer>>;
|
|
1575
1704
|
/**
|
|
1576
1705
|
* Constructs an `OPTIONS` request that interprets the body as a `Blob` and
|
|
@@ -1591,6 +1720,8 @@ declare class HttpClient {
|
|
|
1591
1720
|
responseType: 'blob';
|
|
1592
1721
|
withCredentials?: boolean;
|
|
1593
1722
|
keepalive?: boolean;
|
|
1723
|
+
priority?: RequestPriority;
|
|
1724
|
+
cache?: RequestCache;
|
|
1594
1725
|
}): Observable<HttpEvent<Blob>>;
|
|
1595
1726
|
/**
|
|
1596
1727
|
* Constructs an `OPTIONS` request that interprets the body as a text string
|
|
@@ -1611,6 +1742,8 @@ declare class HttpClient {
|
|
|
1611
1742
|
responseType: 'text';
|
|
1612
1743
|
withCredentials?: boolean;
|
|
1613
1744
|
keepalive?: boolean;
|
|
1745
|
+
priority?: RequestPriority;
|
|
1746
|
+
cache?: RequestCache;
|
|
1614
1747
|
}): Observable<HttpEvent<string>>;
|
|
1615
1748
|
/**
|
|
1616
1749
|
* Constructs an `OPTIONS` request that interprets the body as JSON
|
|
@@ -1631,6 +1764,8 @@ declare class HttpClient {
|
|
|
1631
1764
|
responseType?: 'json';
|
|
1632
1765
|
withCredentials?: boolean;
|
|
1633
1766
|
keepalive?: boolean;
|
|
1767
|
+
priority?: RequestPriority;
|
|
1768
|
+
cache?: RequestCache;
|
|
1634
1769
|
}): Observable<HttpEvent<Object>>;
|
|
1635
1770
|
/**
|
|
1636
1771
|
* Constructs an `OPTIONS` request that interprets the body as JSON and
|
|
@@ -1651,6 +1786,8 @@ declare class HttpClient {
|
|
|
1651
1786
|
responseType?: 'json';
|
|
1652
1787
|
withCredentials?: boolean;
|
|
1653
1788
|
keepalive?: boolean;
|
|
1789
|
+
priority?: RequestPriority;
|
|
1790
|
+
cache?: RequestCache;
|
|
1654
1791
|
}): Observable<HttpEvent<T>>;
|
|
1655
1792
|
/**
|
|
1656
1793
|
* Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`
|
|
@@ -1671,6 +1808,8 @@ declare class HttpClient {
|
|
|
1671
1808
|
responseType: 'arraybuffer';
|
|
1672
1809
|
withCredentials?: boolean;
|
|
1673
1810
|
keepalive?: boolean;
|
|
1811
|
+
priority?: RequestPriority;
|
|
1812
|
+
cache?: RequestCache;
|
|
1674
1813
|
}): Observable<HttpResponse<ArrayBuffer>>;
|
|
1675
1814
|
/**
|
|
1676
1815
|
* Constructs an `OPTIONS` request that interprets the body as a `Blob`
|
|
@@ -1691,6 +1830,8 @@ declare class HttpClient {
|
|
|
1691
1830
|
responseType: 'blob';
|
|
1692
1831
|
withCredentials?: boolean;
|
|
1693
1832
|
keepalive?: boolean;
|
|
1833
|
+
priority?: RequestPriority;
|
|
1834
|
+
cache?: RequestCache;
|
|
1694
1835
|
}): Observable<HttpResponse<Blob>>;
|
|
1695
1836
|
/**
|
|
1696
1837
|
* Constructs an `OPTIONS` request that interprets the body as text stream
|
|
@@ -1711,6 +1852,8 @@ declare class HttpClient {
|
|
|
1711
1852
|
responseType: 'text';
|
|
1712
1853
|
withCredentials?: boolean;
|
|
1713
1854
|
keepalive?: boolean;
|
|
1855
|
+
priority?: RequestPriority;
|
|
1856
|
+
cache?: RequestCache;
|
|
1714
1857
|
}): Observable<HttpResponse<string>>;
|
|
1715
1858
|
/**
|
|
1716
1859
|
* Constructs an `OPTIONS` request that interprets the body as JSON
|
|
@@ -1731,6 +1874,8 @@ declare class HttpClient {
|
|
|
1731
1874
|
responseType?: 'json';
|
|
1732
1875
|
withCredentials?: boolean;
|
|
1733
1876
|
keepalive?: boolean;
|
|
1877
|
+
priority?: RequestPriority;
|
|
1878
|
+
cache?: RequestCache;
|
|
1734
1879
|
}): Observable<HttpResponse<Object>>;
|
|
1735
1880
|
/**
|
|
1736
1881
|
* Constructs an `OPTIONS` request that interprets the body as JSON and
|
|
@@ -1751,6 +1896,8 @@ declare class HttpClient {
|
|
|
1751
1896
|
responseType?: 'json';
|
|
1752
1897
|
withCredentials?: boolean;
|
|
1753
1898
|
keepalive?: boolean;
|
|
1899
|
+
priority?: RequestPriority;
|
|
1900
|
+
cache?: RequestCache;
|
|
1754
1901
|
}): Observable<HttpResponse<T>>;
|
|
1755
1902
|
/**
|
|
1756
1903
|
|
|
@@ -1771,6 +1918,8 @@ declare class HttpClient {
|
|
|
1771
1918
|
responseType?: 'json';
|
|
1772
1919
|
withCredentials?: boolean;
|
|
1773
1920
|
keepalive?: boolean;
|
|
1921
|
+
priority?: RequestPriority;
|
|
1922
|
+
cache?: RequestCache;
|
|
1774
1923
|
}): Observable<Object>;
|
|
1775
1924
|
/**
|
|
1776
1925
|
* Constructs an `OPTIONS` request that interprets the body as JSON and returns the
|
|
@@ -1790,6 +1939,8 @@ declare class HttpClient {
|
|
|
1790
1939
|
responseType?: 'json';
|
|
1791
1940
|
withCredentials?: boolean;
|
|
1792
1941
|
keepalive?: boolean;
|
|
1942
|
+
priority?: RequestPriority;
|
|
1943
|
+
cache?: RequestCache;
|
|
1793
1944
|
}): Observable<T>;
|
|
1794
1945
|
/**
|
|
1795
1946
|
* Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
|
|
@@ -1810,6 +1961,8 @@ declare class HttpClient {
|
|
|
1810
1961
|
responseType: 'arraybuffer';
|
|
1811
1962
|
withCredentials?: boolean;
|
|
1812
1963
|
keepalive?: boolean;
|
|
1964
|
+
priority?: RequestPriority;
|
|
1965
|
+
cache?: RequestCache;
|
|
1813
1966
|
}): Observable<ArrayBuffer>;
|
|
1814
1967
|
/**
|
|
1815
1968
|
* Constructs a `PATCH` request that interprets the body as a `Blob` and returns the response
|
|
@@ -1830,6 +1983,8 @@ declare class HttpClient {
|
|
|
1830
1983
|
responseType: 'blob';
|
|
1831
1984
|
withCredentials?: boolean;
|
|
1832
1985
|
keepalive?: boolean;
|
|
1986
|
+
priority?: RequestPriority;
|
|
1987
|
+
cache?: RequestCache;
|
|
1833
1988
|
}): Observable<Blob>;
|
|
1834
1989
|
/**
|
|
1835
1990
|
* Constructs a `PATCH` request that interprets the body as a text string and
|
|
@@ -1850,6 +2005,8 @@ declare class HttpClient {
|
|
|
1850
2005
|
responseType: 'text';
|
|
1851
2006
|
withCredentials?: boolean;
|
|
1852
2007
|
keepalive?: boolean;
|
|
2008
|
+
priority?: RequestPriority;
|
|
2009
|
+
cache?: RequestCache;
|
|
1853
2010
|
}): Observable<string>;
|
|
1854
2011
|
/**
|
|
1855
2012
|
* Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and
|
|
@@ -1871,6 +2028,8 @@ declare class HttpClient {
|
|
|
1871
2028
|
responseType: 'arraybuffer';
|
|
1872
2029
|
withCredentials?: boolean;
|
|
1873
2030
|
keepalive?: boolean;
|
|
2031
|
+
priority?: RequestPriority;
|
|
2032
|
+
cache?: RequestCache;
|
|
1874
2033
|
}): Observable<HttpEvent<ArrayBuffer>>;
|
|
1875
2034
|
/**
|
|
1876
2035
|
* Constructs a `PATCH` request that interprets the body as a `Blob`
|
|
@@ -1892,6 +2051,8 @@ declare class HttpClient {
|
|
|
1892
2051
|
responseType: 'blob';
|
|
1893
2052
|
withCredentials?: boolean;
|
|
1894
2053
|
keepalive?: boolean;
|
|
2054
|
+
priority?: RequestPriority;
|
|
2055
|
+
cache?: RequestCache;
|
|
1895
2056
|
}): Observable<HttpEvent<Blob>>;
|
|
1896
2057
|
/**
|
|
1897
2058
|
* Constructs a `PATCH` request that interprets the body as a text string and
|
|
@@ -1913,6 +2074,8 @@ declare class HttpClient {
|
|
|
1913
2074
|
responseType: 'text';
|
|
1914
2075
|
withCredentials?: boolean;
|
|
1915
2076
|
keepalive?: boolean;
|
|
2077
|
+
priority?: RequestPriority;
|
|
2078
|
+
cache?: RequestCache;
|
|
1916
2079
|
}): Observable<HttpEvent<string>>;
|
|
1917
2080
|
/**
|
|
1918
2081
|
* Constructs a `PATCH` request that interprets the body as JSON
|
|
@@ -1934,6 +2097,8 @@ declare class HttpClient {
|
|
|
1934
2097
|
responseType?: 'json';
|
|
1935
2098
|
withCredentials?: boolean;
|
|
1936
2099
|
keepalive?: boolean;
|
|
2100
|
+
priority?: RequestPriority;
|
|
2101
|
+
cache?: RequestCache;
|
|
1937
2102
|
}): Observable<HttpEvent<Object>>;
|
|
1938
2103
|
/**
|
|
1939
2104
|
* Constructs a `PATCH` request that interprets the body as JSON
|
|
@@ -1955,6 +2120,8 @@ declare class HttpClient {
|
|
|
1955
2120
|
responseType?: 'json';
|
|
1956
2121
|
withCredentials?: boolean;
|
|
1957
2122
|
keepalive?: boolean;
|
|
2123
|
+
priority?: RequestPriority;
|
|
2124
|
+
cache?: RequestCache;
|
|
1958
2125
|
}): Observable<HttpEvent<T>>;
|
|
1959
2126
|
/**
|
|
1960
2127
|
* Constructs a `PATCH` request that interprets the body as an `ArrayBuffer`
|
|
@@ -1976,6 +2143,8 @@ declare class HttpClient {
|
|
|
1976
2143
|
responseType: 'arraybuffer';
|
|
1977
2144
|
withCredentials?: boolean;
|
|
1978
2145
|
keepalive?: boolean;
|
|
2146
|
+
priority?: RequestPriority;
|
|
2147
|
+
cache?: RequestCache;
|
|
1979
2148
|
}): Observable<HttpResponse<ArrayBuffer>>;
|
|
1980
2149
|
/**
|
|
1981
2150
|
* Constructs a `PATCH` request that interprets the body as a `Blob` and returns the full
|
|
@@ -1997,6 +2166,8 @@ declare class HttpClient {
|
|
|
1997
2166
|
responseType: 'blob';
|
|
1998
2167
|
withCredentials?: boolean;
|
|
1999
2168
|
keepalive?: boolean;
|
|
2169
|
+
priority?: RequestPriority;
|
|
2170
|
+
cache?: RequestCache;
|
|
2000
2171
|
}): Observable<HttpResponse<Blob>>;
|
|
2001
2172
|
/**
|
|
2002
2173
|
* Constructs a `PATCH` request that interprets the body as a text stream and returns the
|
|
@@ -2018,6 +2189,8 @@ declare class HttpClient {
|
|
|
2018
2189
|
responseType: 'text';
|
|
2019
2190
|
withCredentials?: boolean;
|
|
2020
2191
|
keepalive?: boolean;
|
|
2192
|
+
priority?: RequestPriority;
|
|
2193
|
+
cache?: RequestCache;
|
|
2021
2194
|
}): Observable<HttpResponse<string>>;
|
|
2022
2195
|
/**
|
|
2023
2196
|
* Constructs a `PATCH` request that interprets the body as JSON
|
|
@@ -2039,6 +2212,8 @@ declare class HttpClient {
|
|
|
2039
2212
|
responseType?: 'json';
|
|
2040
2213
|
withCredentials?: boolean;
|
|
2041
2214
|
keepalive?: boolean;
|
|
2215
|
+
priority?: RequestPriority;
|
|
2216
|
+
cache?: RequestCache;
|
|
2042
2217
|
}): Observable<HttpResponse<Object>>;
|
|
2043
2218
|
/**
|
|
2044
2219
|
* Constructs a `PATCH` request that interprets the body as JSON
|
|
@@ -2060,6 +2235,8 @@ declare class HttpClient {
|
|
|
2060
2235
|
responseType?: 'json';
|
|
2061
2236
|
withCredentials?: boolean;
|
|
2062
2237
|
keepalive?: boolean;
|
|
2238
|
+
priority?: RequestPriority;
|
|
2239
|
+
cache?: RequestCache;
|
|
2063
2240
|
}): Observable<HttpResponse<T>>;
|
|
2064
2241
|
/**
|
|
2065
2242
|
|
|
@@ -2081,6 +2258,8 @@ declare class HttpClient {
|
|
|
2081
2258
|
responseType?: 'json';
|
|
2082
2259
|
withCredentials?: boolean;
|
|
2083
2260
|
keepalive?: boolean;
|
|
2261
|
+
priority?: RequestPriority;
|
|
2262
|
+
cache?: RequestCache;
|
|
2084
2263
|
}): Observable<Object>;
|
|
2085
2264
|
/**
|
|
2086
2265
|
* Constructs a `PATCH` request that interprets the body as JSON
|
|
@@ -2102,6 +2281,8 @@ declare class HttpClient {
|
|
|
2102
2281
|
responseType?: 'json';
|
|
2103
2282
|
withCredentials?: boolean;
|
|
2104
2283
|
keepalive?: boolean;
|
|
2284
|
+
priority?: RequestPriority;
|
|
2285
|
+
cache?: RequestCache;
|
|
2105
2286
|
}): Observable<T>;
|
|
2106
2287
|
/**
|
|
2107
2288
|
* Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
|
|
@@ -2122,6 +2303,8 @@ declare class HttpClient {
|
|
|
2122
2303
|
responseType: 'arraybuffer';
|
|
2123
2304
|
withCredentials?: boolean;
|
|
2124
2305
|
keepalive?: boolean;
|
|
2306
|
+
priority?: RequestPriority;
|
|
2307
|
+
cache?: RequestCache;
|
|
2125
2308
|
transferCache?: {
|
|
2126
2309
|
includeHeaders?: string[];
|
|
2127
2310
|
} | boolean;
|
|
@@ -2145,6 +2328,8 @@ declare class HttpClient {
|
|
|
2145
2328
|
responseType: 'blob';
|
|
2146
2329
|
withCredentials?: boolean;
|
|
2147
2330
|
keepalive?: boolean;
|
|
2331
|
+
priority?: RequestPriority;
|
|
2332
|
+
cache?: RequestCache;
|
|
2148
2333
|
transferCache?: {
|
|
2149
2334
|
includeHeaders?: string[];
|
|
2150
2335
|
} | boolean;
|
|
@@ -2168,6 +2353,8 @@ declare class HttpClient {
|
|
|
2168
2353
|
responseType: 'text';
|
|
2169
2354
|
withCredentials?: boolean;
|
|
2170
2355
|
keepalive?: boolean;
|
|
2356
|
+
priority?: RequestPriority;
|
|
2357
|
+
cache?: RequestCache;
|
|
2171
2358
|
transferCache?: {
|
|
2172
2359
|
includeHeaders?: string[];
|
|
2173
2360
|
} | boolean;
|
|
@@ -2192,6 +2379,8 @@ declare class HttpClient {
|
|
|
2192
2379
|
responseType: 'arraybuffer';
|
|
2193
2380
|
withCredentials?: boolean;
|
|
2194
2381
|
keepalive?: boolean;
|
|
2382
|
+
priority?: RequestPriority;
|
|
2383
|
+
cache?: RequestCache;
|
|
2195
2384
|
transferCache?: {
|
|
2196
2385
|
includeHeaders?: string[];
|
|
2197
2386
|
} | boolean;
|
|
@@ -2215,6 +2404,8 @@ declare class HttpClient {
|
|
|
2215
2404
|
responseType: 'blob';
|
|
2216
2405
|
withCredentials?: boolean;
|
|
2217
2406
|
keepalive?: boolean;
|
|
2407
|
+
priority?: RequestPriority;
|
|
2408
|
+
cache?: RequestCache;
|
|
2218
2409
|
transferCache?: {
|
|
2219
2410
|
includeHeaders?: string[];
|
|
2220
2411
|
} | boolean;
|
|
@@ -2239,6 +2430,8 @@ declare class HttpClient {
|
|
|
2239
2430
|
responseType: 'text';
|
|
2240
2431
|
withCredentials?: boolean;
|
|
2241
2432
|
keepalive?: boolean;
|
|
2433
|
+
priority?: RequestPriority;
|
|
2434
|
+
cache?: RequestCache;
|
|
2242
2435
|
transferCache?: {
|
|
2243
2436
|
includeHeaders?: string[];
|
|
2244
2437
|
} | boolean;
|
|
@@ -2263,6 +2456,8 @@ declare class HttpClient {
|
|
|
2263
2456
|
responseType?: 'json';
|
|
2264
2457
|
withCredentials?: boolean;
|
|
2265
2458
|
keepalive?: boolean;
|
|
2459
|
+
priority?: RequestPriority;
|
|
2460
|
+
cache?: RequestCache;
|
|
2266
2461
|
transferCache?: {
|
|
2267
2462
|
includeHeaders?: string[];
|
|
2268
2463
|
} | boolean;
|
|
@@ -2287,6 +2482,8 @@ declare class HttpClient {
|
|
|
2287
2482
|
responseType?: 'json';
|
|
2288
2483
|
withCredentials?: boolean;
|
|
2289
2484
|
keepalive?: boolean;
|
|
2485
|
+
priority?: RequestPriority;
|
|
2486
|
+
cache?: RequestCache;
|
|
2290
2487
|
transferCache?: {
|
|
2291
2488
|
includeHeaders?: string[];
|
|
2292
2489
|
} | boolean;
|
|
@@ -2311,6 +2508,8 @@ declare class HttpClient {
|
|
|
2311
2508
|
responseType: 'arraybuffer';
|
|
2312
2509
|
withCredentials?: boolean;
|
|
2313
2510
|
keepalive?: boolean;
|
|
2511
|
+
priority?: RequestPriority;
|
|
2512
|
+
cache?: RequestCache;
|
|
2314
2513
|
transferCache?: {
|
|
2315
2514
|
includeHeaders?: string[];
|
|
2316
2515
|
} | boolean;
|
|
@@ -2335,6 +2534,8 @@ declare class HttpClient {
|
|
|
2335
2534
|
responseType: 'blob';
|
|
2336
2535
|
withCredentials?: boolean;
|
|
2337
2536
|
keepalive?: boolean;
|
|
2537
|
+
priority?: RequestPriority;
|
|
2538
|
+
cache?: RequestCache;
|
|
2338
2539
|
transferCache?: {
|
|
2339
2540
|
includeHeaders?: string[];
|
|
2340
2541
|
} | boolean;
|
|
@@ -2359,6 +2560,8 @@ declare class HttpClient {
|
|
|
2359
2560
|
responseType: 'text';
|
|
2360
2561
|
withCredentials?: boolean;
|
|
2361
2562
|
keepalive?: boolean;
|
|
2563
|
+
priority?: RequestPriority;
|
|
2564
|
+
cache?: RequestCache;
|
|
2362
2565
|
transferCache?: {
|
|
2363
2566
|
includeHeaders?: string[];
|
|
2364
2567
|
} | boolean;
|
|
@@ -2383,6 +2586,8 @@ declare class HttpClient {
|
|
|
2383
2586
|
responseType?: 'json';
|
|
2384
2587
|
withCredentials?: boolean;
|
|
2385
2588
|
keepalive?: boolean;
|
|
2589
|
+
priority?: RequestPriority;
|
|
2590
|
+
cache?: RequestCache;
|
|
2386
2591
|
transferCache?: {
|
|
2387
2592
|
includeHeaders?: string[];
|
|
2388
2593
|
} | boolean;
|
|
@@ -2408,6 +2613,8 @@ declare class HttpClient {
|
|
|
2408
2613
|
responseType?: 'json';
|
|
2409
2614
|
withCredentials?: boolean;
|
|
2410
2615
|
keepalive?: boolean;
|
|
2616
|
+
priority?: RequestPriority;
|
|
2617
|
+
cache?: RequestCache;
|
|
2411
2618
|
transferCache?: {
|
|
2412
2619
|
includeHeaders?: string[];
|
|
2413
2620
|
} | boolean;
|
|
@@ -2431,6 +2638,8 @@ declare class HttpClient {
|
|
|
2431
2638
|
responseType?: 'json';
|
|
2432
2639
|
withCredentials?: boolean;
|
|
2433
2640
|
keepalive?: boolean;
|
|
2641
|
+
priority?: RequestPriority;
|
|
2642
|
+
cache?: RequestCache;
|
|
2434
2643
|
transferCache?: {
|
|
2435
2644
|
includeHeaders?: string[];
|
|
2436
2645
|
} | boolean;
|
|
@@ -2455,6 +2664,8 @@ declare class HttpClient {
|
|
|
2455
2664
|
responseType?: 'json';
|
|
2456
2665
|
withCredentials?: boolean;
|
|
2457
2666
|
keepalive?: boolean;
|
|
2667
|
+
priority?: RequestPriority;
|
|
2668
|
+
cache?: RequestCache;
|
|
2458
2669
|
transferCache?: {
|
|
2459
2670
|
includeHeaders?: string[];
|
|
2460
2671
|
} | boolean;
|
|
@@ -2478,6 +2689,8 @@ declare class HttpClient {
|
|
|
2478
2689
|
responseType: 'arraybuffer';
|
|
2479
2690
|
withCredentials?: boolean;
|
|
2480
2691
|
keepalive?: boolean;
|
|
2692
|
+
priority?: RequestPriority;
|
|
2693
|
+
cache?: RequestCache;
|
|
2481
2694
|
}): Observable<ArrayBuffer>;
|
|
2482
2695
|
/**
|
|
2483
2696
|
* Constructs a `PUT` request that interprets the body as a `Blob` and returns
|
|
@@ -2498,6 +2711,8 @@ declare class HttpClient {
|
|
|
2498
2711
|
responseType: 'blob';
|
|
2499
2712
|
withCredentials?: boolean;
|
|
2500
2713
|
keepalive?: boolean;
|
|
2714
|
+
priority?: RequestPriority;
|
|
2715
|
+
cache?: RequestCache;
|
|
2501
2716
|
}): Observable<Blob>;
|
|
2502
2717
|
/**
|
|
2503
2718
|
* Constructs a `PUT` request that interprets the body as a text string and
|
|
@@ -2518,6 +2733,8 @@ declare class HttpClient {
|
|
|
2518
2733
|
responseType: 'text';
|
|
2519
2734
|
withCredentials?: boolean;
|
|
2520
2735
|
keepalive?: boolean;
|
|
2736
|
+
priority?: RequestPriority;
|
|
2737
|
+
cache?: RequestCache;
|
|
2521
2738
|
}): Observable<string>;
|
|
2522
2739
|
/**
|
|
2523
2740
|
* Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and
|
|
@@ -2539,6 +2756,8 @@ declare class HttpClient {
|
|
|
2539
2756
|
responseType: 'arraybuffer';
|
|
2540
2757
|
withCredentials?: boolean;
|
|
2541
2758
|
keepalive?: boolean;
|
|
2759
|
+
priority?: RequestPriority;
|
|
2760
|
+
cache?: RequestCache;
|
|
2542
2761
|
}): Observable<HttpEvent<ArrayBuffer>>;
|
|
2543
2762
|
/**
|
|
2544
2763
|
* Constructs a `PUT` request that interprets the body as a `Blob` and returns the full event
|
|
@@ -2560,6 +2779,8 @@ declare class HttpClient {
|
|
|
2560
2779
|
responseType: 'blob';
|
|
2561
2780
|
withCredentials?: boolean;
|
|
2562
2781
|
keepalive?: boolean;
|
|
2782
|
+
priority?: RequestPriority;
|
|
2783
|
+
cache?: RequestCache;
|
|
2563
2784
|
}): Observable<HttpEvent<Blob>>;
|
|
2564
2785
|
/**
|
|
2565
2786
|
* Constructs a `PUT` request that interprets the body as a text string and returns the full event
|
|
@@ -2581,6 +2802,8 @@ declare class HttpClient {
|
|
|
2581
2802
|
responseType: 'text';
|
|
2582
2803
|
withCredentials?: boolean;
|
|
2583
2804
|
keepalive?: boolean;
|
|
2805
|
+
priority?: RequestPriority;
|
|
2806
|
+
cache?: RequestCache;
|
|
2584
2807
|
}): Observable<HttpEvent<string>>;
|
|
2585
2808
|
/**
|
|
2586
2809
|
* Constructs a `PUT` request that interprets the body as JSON and returns the full
|
|
@@ -2602,6 +2825,8 @@ declare class HttpClient {
|
|
|
2602
2825
|
responseType?: 'json';
|
|
2603
2826
|
withCredentials?: boolean;
|
|
2604
2827
|
keepalive?: boolean;
|
|
2828
|
+
priority?: RequestPriority;
|
|
2829
|
+
cache?: RequestCache;
|
|
2605
2830
|
}): Observable<HttpEvent<Object>>;
|
|
2606
2831
|
/**
|
|
2607
2832
|
* Constructs a `PUT` request that interprets the body as JSON and returns the
|
|
@@ -2623,6 +2848,8 @@ declare class HttpClient {
|
|
|
2623
2848
|
responseType?: 'json';
|
|
2624
2849
|
withCredentials?: boolean;
|
|
2625
2850
|
keepalive?: boolean;
|
|
2851
|
+
priority?: RequestPriority;
|
|
2852
|
+
cache?: RequestCache;
|
|
2626
2853
|
}): Observable<HttpEvent<T>>;
|
|
2627
2854
|
/**
|
|
2628
2855
|
* Constructs a `PUT` request that interprets the body as an
|
|
@@ -2644,6 +2871,8 @@ declare class HttpClient {
|
|
|
2644
2871
|
responseType: 'arraybuffer';
|
|
2645
2872
|
withCredentials?: boolean;
|
|
2646
2873
|
keepalive?: boolean;
|
|
2874
|
+
priority?: RequestPriority;
|
|
2875
|
+
cache?: RequestCache;
|
|
2647
2876
|
}): Observable<HttpResponse<ArrayBuffer>>;
|
|
2648
2877
|
/**
|
|
2649
2878
|
* Constructs a `PUT` request that interprets the body as a `Blob` and returns the
|
|
@@ -2665,6 +2894,8 @@ declare class HttpClient {
|
|
|
2665
2894
|
responseType: 'blob';
|
|
2666
2895
|
withCredentials?: boolean;
|
|
2667
2896
|
keepalive?: boolean;
|
|
2897
|
+
priority?: RequestPriority;
|
|
2898
|
+
cache?: RequestCache;
|
|
2668
2899
|
}): Observable<HttpResponse<Blob>>;
|
|
2669
2900
|
/**
|
|
2670
2901
|
* Constructs a `PUT` request that interprets the body as a text stream and returns the
|
|
@@ -2686,6 +2917,8 @@ declare class HttpClient {
|
|
|
2686
2917
|
responseType: 'text';
|
|
2687
2918
|
withCredentials?: boolean;
|
|
2688
2919
|
keepalive?: boolean;
|
|
2920
|
+
priority?: RequestPriority;
|
|
2921
|
+
cache?: RequestCache;
|
|
2689
2922
|
}): Observable<HttpResponse<string>>;
|
|
2690
2923
|
/**
|
|
2691
2924
|
* Constructs a `PUT` request that interprets the body as JSON and returns the full
|
|
@@ -2707,6 +2940,8 @@ declare class HttpClient {
|
|
|
2707
2940
|
responseType?: 'json';
|
|
2708
2941
|
withCredentials?: boolean;
|
|
2709
2942
|
keepalive?: boolean;
|
|
2943
|
+
priority?: RequestPriority;
|
|
2944
|
+
cache?: RequestCache;
|
|
2710
2945
|
}): Observable<HttpResponse<Object>>;
|
|
2711
2946
|
/**
|
|
2712
2947
|
* Constructs a `PUT` request that interprets the body as an instance of the requested type and
|
|
@@ -2728,6 +2963,8 @@ declare class HttpClient {
|
|
|
2728
2963
|
responseType?: 'json';
|
|
2729
2964
|
withCredentials?: boolean;
|
|
2730
2965
|
keepalive?: boolean;
|
|
2966
|
+
priority?: RequestPriority;
|
|
2967
|
+
cache?: RequestCache;
|
|
2731
2968
|
}): Observable<HttpResponse<T>>;
|
|
2732
2969
|
/**
|
|
2733
2970
|
* Constructs a `PUT` request that interprets the body as JSON
|
|
@@ -2748,6 +2985,8 @@ declare class HttpClient {
|
|
|
2748
2985
|
responseType?: 'json';
|
|
2749
2986
|
withCredentials?: boolean;
|
|
2750
2987
|
keepalive?: boolean;
|
|
2988
|
+
priority?: RequestPriority;
|
|
2989
|
+
cache?: RequestCache;
|
|
2751
2990
|
}): Observable<Object>;
|
|
2752
2991
|
/**
|
|
2753
2992
|
* Constructs a `PUT` request that interprets the body as an instance of the requested type
|
|
@@ -2768,6 +3007,8 @@ declare class HttpClient {
|
|
|
2768
3007
|
responseType?: 'json';
|
|
2769
3008
|
withCredentials?: boolean;
|
|
2770
3009
|
keepalive?: boolean;
|
|
3010
|
+
priority?: RequestPriority;
|
|
3011
|
+
cache?: RequestCache;
|
|
2771
3012
|
}): Observable<T>;
|
|
2772
3013
|
static ɵfac: i0.ɵɵFactoryDeclaration<HttpClient, never>;
|
|
2773
3014
|
static ɵprov: i0.ɵɵInjectableDeclaration<HttpClient>;
|
|
@@ -3165,6 +3406,10 @@ interface HttpResourceRequest {
|
|
|
3165
3406
|
* the request.
|
|
3166
3407
|
*/
|
|
3167
3408
|
withCredentials?: boolean;
|
|
3409
|
+
/**
|
|
3410
|
+
* When using the fetch implementation and set to `true`, the browser will not abort the associated request if the page that initiated it is unloaded before the request is complete.
|
|
3411
|
+
*/
|
|
3412
|
+
keepalive?: boolean;
|
|
3168
3413
|
/**
|
|
3169
3414
|
* Configures the server-side rendering transfer cache for this request.
|
|
3170
3415
|
*
|