@angular/common 20.1.0-next.3 → 20.1.0

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.
Files changed (25) hide show
  1. package/common_module.d.d.ts +7 -3
  2. package/fesm2022/common.mjs +14 -14
  3. package/fesm2022/common.mjs.map +1 -1
  4. package/fesm2022/common_module.mjs +94 -86
  5. package/fesm2022/common_module.mjs.map +1 -1
  6. package/fesm2022/http/testing.mjs +8 -11
  7. package/fesm2022/http/testing.mjs.map +1 -1
  8. package/fesm2022/http.mjs +7 -1
  9. package/fesm2022/http.mjs.map +1 -1
  10. package/fesm2022/location.mjs +16 -16
  11. package/fesm2022/module.mjs +190 -57
  12. package/fesm2022/module.mjs.map +1 -1
  13. package/fesm2022/platform_navigation.mjs +4 -4
  14. package/fesm2022/testing.mjs +13 -13
  15. package/fesm2022/upgrade.mjs +5 -5
  16. package/fesm2022/xhr.mjs +1 -1
  17. package/http/index.d.ts +392 -1
  18. package/http/testing/index.d.ts +1 -1
  19. package/index.d.ts +1 -1
  20. package/module.d.d.ts +48 -1
  21. package/package.json +2 -2
  22. package/platform_location.d.d.ts +1 -1
  23. package/testing/index.d.ts +1 -1
  24. package/upgrade/index.d.ts +1 -1
  25. package/xhr.d.d.ts +1 -1
package/http/index.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  /**
2
- * @license Angular v20.1.0-next.3
2
+ * @license Angular v20.1.0
3
3
  * (c) 2010-2025 Google LLC. https://angular.io/
4
4
  * License: MIT
5
5
  */
@@ -122,8 +122,11 @@ declare class HttpClient {
122
122
  reportProgress?: boolean;
123
123
  responseType: 'arraybuffer';
124
124
  withCredentials?: boolean;
125
+ credentials?: RequestCredentials;
125
126
  priority?: RequestPriority;
126
127
  cache?: RequestCache;
128
+ mode?: RequestMode;
129
+ redirect?: RequestRedirect;
127
130
  transferCache?: {
128
131
  includeHeaders?: string[];
129
132
  } | boolean;
@@ -147,9 +150,12 @@ declare class HttpClient {
147
150
  reportProgress?: boolean;
148
151
  responseType: 'blob';
149
152
  withCredentials?: boolean;
153
+ credentials?: RequestCredentials;
150
154
  keepalive?: boolean;
151
155
  priority?: RequestPriority;
152
156
  cache?: RequestCache;
157
+ mode?: RequestMode;
158
+ redirect?: RequestRedirect;
153
159
  transferCache?: {
154
160
  includeHeaders?: string[];
155
161
  } | boolean;
@@ -173,9 +179,12 @@ declare class HttpClient {
173
179
  reportProgress?: boolean;
174
180
  responseType: 'text';
175
181
  withCredentials?: boolean;
182
+ credentials?: RequestCredentials;
176
183
  keepalive?: boolean;
177
184
  priority?: RequestPriority;
178
185
  cache?: RequestCache;
186
+ mode?: RequestMode;
187
+ redirect?: RequestRedirect;
179
188
  transferCache?: {
180
189
  includeHeaders?: string[];
181
190
  } | boolean;
@@ -200,9 +209,12 @@ declare class HttpClient {
200
209
  reportProgress?: boolean;
201
210
  responseType: 'arraybuffer';
202
211
  withCredentials?: boolean;
212
+ credentials?: RequestCredentials;
203
213
  keepalive?: boolean;
204
214
  priority?: RequestPriority;
205
215
  cache?: RequestCache;
216
+ mode?: RequestMode;
217
+ redirect?: RequestRedirect;
206
218
  transferCache?: {
207
219
  includeHeaders?: string[];
208
220
  } | boolean;
@@ -227,9 +239,12 @@ declare class HttpClient {
227
239
  reportProgress?: boolean;
228
240
  responseType: 'blob';
229
241
  withCredentials?: boolean;
242
+ credentials?: RequestCredentials;
230
243
  keepalive?: boolean;
231
244
  priority?: RequestPriority;
232
245
  cache?: RequestCache;
246
+ mode?: RequestMode;
247
+ redirect?: RequestRedirect;
233
248
  transferCache?: {
234
249
  includeHeaders?: string[];
235
250
  } | boolean;
@@ -254,9 +269,12 @@ declare class HttpClient {
254
269
  reportProgress?: boolean;
255
270
  responseType: 'text';
256
271
  withCredentials?: boolean;
272
+ credentials?: RequestCredentials;
257
273
  keepalive?: boolean;
258
274
  priority?: RequestPriority;
259
275
  cache?: RequestCache;
276
+ mode?: RequestMode;
277
+ redirect?: RequestRedirect;
260
278
  transferCache?: {
261
279
  includeHeaders?: string[];
262
280
  } | boolean;
@@ -281,9 +299,12 @@ declare class HttpClient {
281
299
  params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
282
300
  responseType?: 'json';
283
301
  withCredentials?: boolean;
302
+ credentials?: RequestCredentials;
284
303
  keepalive?: boolean;
285
304
  priority?: RequestPriority;
286
305
  cache?: RequestCache;
306
+ mode?: RequestMode;
307
+ redirect?: RequestRedirect;
287
308
  transferCache?: {
288
309
  includeHeaders?: string[];
289
310
  } | boolean;
@@ -308,9 +329,12 @@ declare class HttpClient {
308
329
  params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
309
330
  responseType?: 'json';
310
331
  withCredentials?: boolean;
332
+ credentials?: RequestCredentials;
311
333
  keepalive?: boolean;
312
334
  priority?: RequestPriority;
313
335
  cache?: RequestCache;
336
+ mode?: RequestMode;
337
+ redirect?: RequestRedirect;
314
338
  transferCache?: {
315
339
  includeHeaders?: string[];
316
340
  } | boolean;
@@ -334,9 +358,12 @@ declare class HttpClient {
334
358
  reportProgress?: boolean;
335
359
  responseType: 'arraybuffer';
336
360
  withCredentials?: boolean;
361
+ credentials?: RequestCredentials;
337
362
  keepalive?: boolean;
338
363
  priority?: RequestPriority;
339
364
  cache?: RequestCache;
365
+ mode?: RequestMode;
366
+ redirect?: RequestRedirect;
340
367
  transferCache?: {
341
368
  includeHeaders?: string[];
342
369
  } | boolean;
@@ -359,9 +386,12 @@ declare class HttpClient {
359
386
  reportProgress?: boolean;
360
387
  responseType: 'blob';
361
388
  withCredentials?: boolean;
389
+ credentials?: RequestCredentials;
362
390
  keepalive?: boolean;
363
391
  priority?: RequestPriority;
364
392
  cache?: RequestCache;
393
+ mode?: RequestMode;
394
+ redirect?: RequestRedirect;
365
395
  transferCache?: {
366
396
  includeHeaders?: string[];
367
397
  } | boolean;
@@ -385,9 +415,12 @@ declare class HttpClient {
385
415
  reportProgress?: boolean;
386
416
  responseType: 'text';
387
417
  withCredentials?: boolean;
418
+ credentials?: RequestCredentials;
388
419
  keepalive?: boolean;
389
420
  priority?: RequestPriority;
390
421
  cache?: RequestCache;
422
+ mode?: RequestMode;
423
+ redirect?: RequestRedirect;
391
424
  transferCache?: {
392
425
  includeHeaders?: string[];
393
426
  } | boolean;
@@ -412,9 +445,12 @@ declare class HttpClient {
412
445
  params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
413
446
  responseType?: 'json';
414
447
  withCredentials?: boolean;
448
+ credentials?: RequestCredentials;
415
449
  keepalive?: boolean;
416
450
  priority?: RequestPriority;
417
451
  cache?: RequestCache;
452
+ mode?: RequestMode;
453
+ redirect?: RequestRedirect;
418
454
  }): Observable<HttpResponse<Object>>;
419
455
  /**
420
456
  * Constructs a request which interprets the body as a JavaScript object and returns
@@ -435,9 +471,12 @@ declare class HttpClient {
435
471
  params?: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
436
472
  responseType?: 'json';
437
473
  withCredentials?: boolean;
474
+ credentials?: RequestCredentials;
438
475
  keepalive?: boolean;
439
476
  priority?: RequestPriority;
440
477
  cache?: RequestCache;
478
+ mode?: RequestMode;
479
+ redirect?: RequestRedirect;
441
480
  transferCache?: {
442
481
  includeHeaders?: string[];
443
482
  } | boolean;
@@ -461,9 +500,12 @@ declare class HttpClient {
461
500
  responseType?: 'json';
462
501
  reportProgress?: boolean;
463
502
  withCredentials?: boolean;
503
+ credentials?: RequestCredentials;
464
504
  keepalive?: boolean;
465
505
  priority?: RequestPriority;
466
506
  cache?: RequestCache;
507
+ mode?: RequestMode;
508
+ redirect?: RequestRedirect;
467
509
  transferCache?: {
468
510
  includeHeaders?: string[];
469
511
  } | boolean;
@@ -487,9 +529,12 @@ declare class HttpClient {
487
529
  responseType?: 'json';
488
530
  reportProgress?: boolean;
489
531
  withCredentials?: boolean;
532
+ credentials?: RequestCredentials;
490
533
  keepalive?: boolean;
491
534
  priority?: RequestPriority;
492
535
  cache?: RequestCache;
536
+ mode?: RequestMode;
537
+ redirect?: RequestRedirect;
493
538
  transferCache?: {
494
539
  includeHeaders?: string[];
495
540
  } | boolean;
@@ -512,9 +557,12 @@ declare class HttpClient {
512
557
  reportProgress?: boolean;
513
558
  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
514
559
  withCredentials?: boolean;
560
+ credentials?: RequestCredentials;
515
561
  keepalive?: boolean;
516
562
  priority?: RequestPriority;
517
563
  cache?: RequestCache;
564
+ mode?: RequestMode;
565
+ redirect?: RequestRedirect;
518
566
  transferCache?: {
519
567
  includeHeaders?: string[];
520
568
  } | boolean;
@@ -536,9 +584,12 @@ declare class HttpClient {
536
584
  reportProgress?: boolean;
537
585
  responseType: 'arraybuffer';
538
586
  withCredentials?: boolean;
587
+ credentials?: RequestCredentials;
539
588
  keepalive?: boolean;
540
589
  priority?: RequestPriority;
541
590
  cache?: RequestCache;
591
+ mode?: RequestMode;
592
+ redirect?: RequestRedirect;
542
593
  body?: any | null;
543
594
  }): Observable<ArrayBuffer>;
544
595
  /**
@@ -558,9 +609,12 @@ declare class HttpClient {
558
609
  reportProgress?: boolean;
559
610
  responseType: 'blob';
560
611
  withCredentials?: boolean;
612
+ credentials?: RequestCredentials;
561
613
  keepalive?: boolean;
562
614
  priority?: RequestPriority;
563
615
  cache?: RequestCache;
616
+ mode?: RequestMode;
617
+ redirect?: RequestRedirect;
564
618
  body?: any | null;
565
619
  }): Observable<Blob>;
566
620
  /**
@@ -580,9 +634,12 @@ declare class HttpClient {
580
634
  reportProgress?: boolean;
581
635
  responseType: 'text';
582
636
  withCredentials?: boolean;
637
+ credentials?: RequestCredentials;
583
638
  keepalive?: boolean;
584
639
  priority?: RequestPriority;
585
640
  cache?: RequestCache;
641
+ mode?: RequestMode;
642
+ redirect?: RequestRedirect;
586
643
  body?: any | null;
587
644
  }): Observable<string>;
588
645
  /**
@@ -603,9 +660,12 @@ declare class HttpClient {
603
660
  reportProgress?: boolean;
604
661
  responseType: 'arraybuffer';
605
662
  withCredentials?: boolean;
663
+ credentials?: RequestCredentials;
606
664
  keepalive?: boolean;
607
665
  priority?: RequestPriority;
608
666
  cache?: RequestCache;
667
+ mode?: RequestMode;
668
+ redirect?: RequestRedirect;
609
669
  body?: any | null;
610
670
  }): Observable<HttpEvent<ArrayBuffer>>;
611
671
  /**
@@ -626,9 +686,12 @@ declare class HttpClient {
626
686
  reportProgress?: boolean;
627
687
  responseType: 'blob';
628
688
  withCredentials?: boolean;
689
+ credentials?: RequestCredentials;
629
690
  keepalive?: boolean;
630
691
  priority?: RequestPriority;
631
692
  cache?: RequestCache;
693
+ mode?: RequestMode;
694
+ redirect?: RequestRedirect;
632
695
  body?: any | null;
633
696
  }): Observable<HttpEvent<Blob>>;
634
697
  /**
@@ -649,9 +712,12 @@ declare class HttpClient {
649
712
  reportProgress?: boolean;
650
713
  responseType: 'text';
651
714
  withCredentials?: boolean;
715
+ credentials?: RequestCredentials;
652
716
  keepalive?: boolean;
653
717
  priority?: RequestPriority;
654
718
  cache?: RequestCache;
719
+ mode?: RequestMode;
720
+ redirect?: RequestRedirect;
655
721
  body?: any | null;
656
722
  }): Observable<HttpEvent<string>>;
657
723
  /**
@@ -672,9 +738,12 @@ declare class HttpClient {
672
738
  reportProgress?: boolean;
673
739
  responseType?: 'json';
674
740
  withCredentials?: boolean;
741
+ credentials?: RequestCredentials;
675
742
  keepalive?: boolean;
676
743
  priority?: RequestPriority;
677
744
  cache?: RequestCache;
745
+ mode?: RequestMode;
746
+ redirect?: RequestRedirect;
678
747
  body?: any | null;
679
748
  }): Observable<HttpEvent<Object>>;
680
749
  /**
@@ -695,9 +764,12 @@ declare class HttpClient {
695
764
  reportProgress?: boolean;
696
765
  responseType?: 'json';
697
766
  withCredentials?: boolean;
767
+ credentials?: RequestCredentials;
698
768
  keepalive?: boolean;
699
769
  priority?: RequestPriority;
700
770
  cache?: RequestCache;
771
+ mode?: RequestMode;
772
+ redirect?: RequestRedirect;
701
773
  body?: any | null;
702
774
  }): Observable<HttpEvent<T>>;
703
775
  /**
@@ -717,9 +789,12 @@ declare class HttpClient {
717
789
  reportProgress?: boolean;
718
790
  responseType: 'arraybuffer';
719
791
  withCredentials?: boolean;
792
+ credentials?: RequestCredentials;
720
793
  keepalive?: boolean;
721
794
  priority?: RequestPriority;
722
795
  cache?: RequestCache;
796
+ mode?: RequestMode;
797
+ redirect?: RequestRedirect;
723
798
  body?: any | null;
724
799
  }): Observable<HttpResponse<ArrayBuffer>>;
725
800
  /**
@@ -739,9 +814,12 @@ declare class HttpClient {
739
814
  reportProgress?: boolean;
740
815
  responseType: 'blob';
741
816
  withCredentials?: boolean;
817
+ credentials?: RequestCredentials;
742
818
  keepalive?: boolean;
743
819
  priority?: RequestPriority;
744
820
  cache?: RequestCache;
821
+ mode?: RequestMode;
822
+ redirect?: RequestRedirect;
745
823
  body?: any | null;
746
824
  }): Observable<HttpResponse<Blob>>;
747
825
  /**
@@ -761,9 +839,12 @@ declare class HttpClient {
761
839
  reportProgress?: boolean;
762
840
  responseType: 'text';
763
841
  withCredentials?: boolean;
842
+ credentials?: RequestCredentials;
764
843
  keepalive?: boolean;
765
844
  priority?: RequestPriority;
766
845
  cache?: RequestCache;
846
+ mode?: RequestMode;
847
+ redirect?: RequestRedirect;
767
848
  body?: any | null;
768
849
  }): Observable<HttpResponse<string>>;
769
850
  /**
@@ -784,9 +865,12 @@ declare class HttpClient {
784
865
  reportProgress?: boolean;
785
866
  responseType?: 'json';
786
867
  withCredentials?: boolean;
868
+ credentials?: RequestCredentials;
787
869
  keepalive?: boolean;
788
870
  priority?: RequestPriority;
789
871
  cache?: RequestCache;
872
+ mode?: RequestMode;
873
+ redirect?: RequestRedirect;
790
874
  body?: any | null;
791
875
  }): Observable<HttpResponse<Object>>;
792
876
  /**
@@ -806,9 +890,12 @@ declare class HttpClient {
806
890
  reportProgress?: boolean;
807
891
  responseType?: 'json';
808
892
  withCredentials?: boolean;
893
+ credentials?: RequestCredentials;
809
894
  keepalive?: boolean;
810
895
  priority?: RequestPriority;
811
896
  cache?: RequestCache;
897
+ mode?: RequestMode;
898
+ redirect?: RequestRedirect;
812
899
  body?: any | null;
813
900
  }): Observable<HttpResponse<T>>;
814
901
  /**
@@ -828,9 +915,12 @@ declare class HttpClient {
828
915
  reportProgress?: boolean;
829
916
  responseType?: 'json';
830
917
  withCredentials?: boolean;
918
+ credentials?: RequestCredentials;
831
919
  keepalive?: boolean;
832
920
  priority?: RequestPriority;
833
921
  cache?: RequestCache;
922
+ mode?: RequestMode;
923
+ redirect?: RequestRedirect;
834
924
  body?: any | null;
835
925
  }): Observable<Object>;
836
926
  /**
@@ -850,9 +940,12 @@ declare class HttpClient {
850
940
  reportProgress?: boolean;
851
941
  responseType?: 'json';
852
942
  withCredentials?: boolean;
943
+ credentials?: RequestCredentials;
853
944
  keepalive?: boolean;
854
945
  priority?: RequestPriority;
855
946
  cache?: RequestCache;
947
+ mode?: RequestMode;
948
+ redirect?: RequestRedirect;
856
949
  body?: any | null;
857
950
  }): Observable<T>;
858
951
  /**
@@ -872,9 +965,12 @@ declare class HttpClient {
872
965
  reportProgress?: boolean;
873
966
  responseType: 'arraybuffer';
874
967
  withCredentials?: boolean;
968
+ credentials?: RequestCredentials;
875
969
  keepalive?: boolean;
876
970
  priority?: RequestPriority;
877
971
  cache?: RequestCache;
972
+ mode?: RequestMode;
973
+ redirect?: RequestRedirect;
878
974
  transferCache?: {
879
975
  includeHeaders?: string[];
880
976
  } | boolean;
@@ -896,9 +992,12 @@ declare class HttpClient {
896
992
  reportProgress?: boolean;
897
993
  responseType: 'blob';
898
994
  withCredentials?: boolean;
995
+ credentials?: RequestCredentials;
899
996
  keepalive?: boolean;
900
997
  priority?: RequestPriority;
901
998
  cache?: RequestCache;
999
+ mode?: RequestMode;
1000
+ redirect?: RequestRedirect;
902
1001
  transferCache?: {
903
1002
  includeHeaders?: string[];
904
1003
  } | boolean;
@@ -920,9 +1019,12 @@ declare class HttpClient {
920
1019
  reportProgress?: boolean;
921
1020
  responseType: 'text';
922
1021
  withCredentials?: boolean;
1022
+ credentials?: RequestCredentials;
923
1023
  keepalive?: boolean;
924
1024
  priority?: RequestPriority;
925
1025
  cache?: RequestCache;
1026
+ mode?: RequestMode;
1027
+ redirect?: RequestRedirect;
926
1028
  transferCache?: {
927
1029
  includeHeaders?: string[];
928
1030
  } | boolean;
@@ -945,9 +1047,12 @@ declare class HttpClient {
945
1047
  reportProgress?: boolean;
946
1048
  responseType: 'arraybuffer';
947
1049
  withCredentials?: boolean;
1050
+ credentials?: RequestCredentials;
948
1051
  keepalive?: boolean;
949
1052
  priority?: RequestPriority;
950
1053
  cache?: RequestCache;
1054
+ mode?: RequestMode;
1055
+ redirect?: RequestRedirect;
951
1056
  transferCache?: {
952
1057
  includeHeaders?: string[];
953
1058
  } | boolean;
@@ -969,9 +1074,12 @@ declare class HttpClient {
969
1074
  reportProgress?: boolean;
970
1075
  responseType: 'blob';
971
1076
  withCredentials?: boolean;
1077
+ credentials?: RequestCredentials;
972
1078
  keepalive?: boolean;
973
1079
  priority?: RequestPriority;
974
1080
  cache?: RequestCache;
1081
+ mode?: RequestMode;
1082
+ redirect?: RequestRedirect;
975
1083
  transferCache?: {
976
1084
  includeHeaders?: string[];
977
1085
  } | boolean;
@@ -993,9 +1101,12 @@ declare class HttpClient {
993
1101
  reportProgress?: boolean;
994
1102
  responseType: 'text';
995
1103
  withCredentials?: boolean;
1104
+ credentials?: RequestCredentials;
996
1105
  keepalive?: boolean;
997
1106
  priority?: RequestPriority;
998
1107
  cache?: RequestCache;
1108
+ mode?: RequestMode;
1109
+ redirect?: RequestRedirect;
999
1110
  transferCache?: {
1000
1111
  includeHeaders?: string[];
1001
1112
  } | boolean;
@@ -1017,9 +1128,12 @@ declare class HttpClient {
1017
1128
  reportProgress?: boolean;
1018
1129
  responseType?: 'json';
1019
1130
  withCredentials?: boolean;
1131
+ credentials?: RequestCredentials;
1020
1132
  keepalive?: boolean;
1021
1133
  priority?: RequestPriority;
1022
1134
  cache?: RequestCache;
1135
+ mode?: RequestMode;
1136
+ redirect?: RequestRedirect;
1023
1137
  transferCache?: {
1024
1138
  includeHeaders?: string[];
1025
1139
  } | boolean;
@@ -1041,9 +1155,12 @@ declare class HttpClient {
1041
1155
  reportProgress?: boolean;
1042
1156
  responseType?: 'json';
1043
1157
  withCredentials?: boolean;
1158
+ credentials?: RequestCredentials;
1044
1159
  keepalive?: boolean;
1045
1160
  priority?: RequestPriority;
1046
1161
  cache?: RequestCache;
1162
+ mode?: RequestMode;
1163
+ redirect?: RequestRedirect;
1047
1164
  transferCache?: {
1048
1165
  includeHeaders?: string[];
1049
1166
  } | boolean;
@@ -1066,9 +1183,12 @@ declare class HttpClient {
1066
1183
  reportProgress?: boolean;
1067
1184
  responseType: 'arraybuffer';
1068
1185
  withCredentials?: boolean;
1186
+ credentials?: RequestCredentials;
1069
1187
  keepalive?: boolean;
1070
1188
  priority?: RequestPriority;
1071
1189
  cache?: RequestCache;
1190
+ mode?: RequestMode;
1191
+ redirect?: RequestRedirect;
1072
1192
  transferCache?: {
1073
1193
  includeHeaders?: string[];
1074
1194
  } | boolean;
@@ -1091,9 +1211,12 @@ declare class HttpClient {
1091
1211
  reportProgress?: boolean;
1092
1212
  responseType: 'blob';
1093
1213
  withCredentials?: boolean;
1214
+ credentials?: RequestCredentials;
1094
1215
  keepalive?: boolean;
1095
1216
  priority?: RequestPriority;
1096
1217
  cache?: RequestCache;
1218
+ mode?: RequestMode;
1219
+ redirect?: RequestRedirect;
1097
1220
  transferCache?: {
1098
1221
  includeHeaders?: string[];
1099
1222
  } | boolean;
@@ -1116,9 +1239,12 @@ declare class HttpClient {
1116
1239
  reportProgress?: boolean;
1117
1240
  responseType: 'text';
1118
1241
  withCredentials?: boolean;
1242
+ credentials?: RequestCredentials;
1119
1243
  keepalive?: boolean;
1120
1244
  priority?: RequestPriority;
1121
1245
  cache?: RequestCache;
1246
+ mode?: RequestMode;
1247
+ redirect?: RequestRedirect;
1122
1248
  transferCache?: {
1123
1249
  includeHeaders?: string[];
1124
1250
  } | boolean;
@@ -1141,9 +1267,12 @@ declare class HttpClient {
1141
1267
  reportProgress?: boolean;
1142
1268
  responseType?: 'json';
1143
1269
  withCredentials?: boolean;
1270
+ credentials?: RequestCredentials;
1144
1271
  keepalive?: boolean;
1145
1272
  priority?: RequestPriority;
1146
1273
  cache?: RequestCache;
1274
+ mode?: RequestMode;
1275
+ redirect?: RequestRedirect;
1147
1276
  transferCache?: {
1148
1277
  includeHeaders?: string[];
1149
1278
  } | boolean;
@@ -1166,9 +1295,12 @@ declare class HttpClient {
1166
1295
  reportProgress?: boolean;
1167
1296
  responseType?: 'json';
1168
1297
  withCredentials?: boolean;
1298
+ credentials?: RequestCredentials;
1169
1299
  keepalive?: boolean;
1170
1300
  priority?: RequestPriority;
1171
1301
  cache?: RequestCache;
1302
+ mode?: RequestMode;
1303
+ redirect?: RequestRedirect;
1172
1304
  transferCache?: {
1173
1305
  includeHeaders?: string[];
1174
1306
  } | boolean;
@@ -1191,9 +1323,12 @@ declare class HttpClient {
1191
1323
  reportProgress?: boolean;
1192
1324
  responseType?: 'json';
1193
1325
  withCredentials?: boolean;
1326
+ credentials?: RequestCredentials;
1194
1327
  keepalive?: boolean;
1195
1328
  priority?: RequestPriority;
1196
1329
  cache?: RequestCache;
1330
+ mode?: RequestMode;
1331
+ redirect?: RequestRedirect;
1197
1332
  transferCache?: {
1198
1333
  includeHeaders?: string[];
1199
1334
  } | boolean;
@@ -1215,9 +1350,12 @@ declare class HttpClient {
1215
1350
  reportProgress?: boolean;
1216
1351
  responseType?: 'json';
1217
1352
  withCredentials?: boolean;
1353
+ credentials?: RequestCredentials;
1218
1354
  keepalive?: boolean;
1219
1355
  priority?: RequestPriority;
1220
1356
  cache?: RequestCache;
1357
+ mode?: RequestMode;
1358
+ redirect?: RequestRedirect;
1221
1359
  transferCache?: {
1222
1360
  includeHeaders?: string[];
1223
1361
  } | boolean;
@@ -1239,9 +1377,12 @@ declare class HttpClient {
1239
1377
  reportProgress?: boolean;
1240
1378
  responseType: 'arraybuffer';
1241
1379
  withCredentials?: boolean;
1380
+ credentials?: RequestCredentials;
1242
1381
  keepalive?: boolean;
1243
1382
  priority?: RequestPriority;
1244
1383
  cache?: RequestCache;
1384
+ mode?: RequestMode;
1385
+ redirect?: RequestRedirect;
1245
1386
  transferCache?: {
1246
1387
  includeHeaders?: string[];
1247
1388
  } | boolean;
@@ -1263,9 +1404,12 @@ declare class HttpClient {
1263
1404
  reportProgress?: boolean;
1264
1405
  responseType: 'blob';
1265
1406
  withCredentials?: boolean;
1407
+ credentials?: RequestCredentials;
1266
1408
  keepalive?: boolean;
1267
1409
  priority?: RequestPriority;
1268
1410
  cache?: RequestCache;
1411
+ mode?: RequestMode;
1412
+ redirect?: RequestRedirect;
1269
1413
  transferCache?: {
1270
1414
  includeHeaders?: string[];
1271
1415
  } | boolean;
@@ -1287,9 +1431,12 @@ declare class HttpClient {
1287
1431
  reportProgress?: boolean;
1288
1432
  responseType: 'text';
1289
1433
  withCredentials?: boolean;
1434
+ credentials?: RequestCredentials;
1290
1435
  keepalive?: boolean;
1291
1436
  priority?: RequestPriority;
1292
1437
  cache?: RequestCache;
1438
+ mode?: RequestMode;
1439
+ redirect?: RequestRedirect;
1293
1440
  transferCache?: {
1294
1441
  includeHeaders?: string[];
1295
1442
  } | boolean;
@@ -1312,9 +1459,12 @@ declare class HttpClient {
1312
1459
  reportProgress?: boolean;
1313
1460
  responseType: 'arraybuffer';
1314
1461
  withCredentials?: boolean;
1462
+ credentials?: RequestCredentials;
1315
1463
  keepalive?: boolean;
1316
1464
  priority?: RequestPriority;
1317
1465
  cache?: RequestCache;
1466
+ mode?: RequestMode;
1467
+ redirect?: RequestRedirect;
1318
1468
  transferCache?: {
1319
1469
  includeHeaders?: string[];
1320
1470
  } | boolean;
@@ -1337,9 +1487,12 @@ declare class HttpClient {
1337
1487
  reportProgress?: boolean;
1338
1488
  responseType: 'blob';
1339
1489
  withCredentials?: boolean;
1490
+ credentials?: RequestCredentials;
1340
1491
  keepalive?: boolean;
1341
1492
  priority?: RequestPriority;
1342
1493
  cache?: RequestCache;
1494
+ mode?: RequestMode;
1495
+ redirect?: RequestRedirect;
1343
1496
  transferCache?: {
1344
1497
  includeHeaders?: string[];
1345
1498
  } | boolean;
@@ -1362,9 +1515,12 @@ declare class HttpClient {
1362
1515
  reportProgress?: boolean;
1363
1516
  responseType: 'text';
1364
1517
  withCredentials?: boolean;
1518
+ credentials?: RequestCredentials;
1365
1519
  keepalive?: boolean;
1366
1520
  priority?: RequestPriority;
1367
1521
  cache?: RequestCache;
1522
+ mode?: RequestMode;
1523
+ redirect?: RequestRedirect;
1368
1524
  transferCache?: {
1369
1525
  includeHeaders?: string[];
1370
1526
  } | boolean;
@@ -1387,9 +1543,12 @@ declare class HttpClient {
1387
1543
  reportProgress?: boolean;
1388
1544
  responseType?: 'json';
1389
1545
  withCredentials?: boolean;
1546
+ credentials?: RequestCredentials;
1390
1547
  keepalive?: boolean;
1391
1548
  priority?: RequestPriority;
1392
1549
  cache?: RequestCache;
1550
+ mode?: RequestMode;
1551
+ redirect?: RequestRedirect;
1393
1552
  transferCache?: {
1394
1553
  includeHeaders?: string[];
1395
1554
  } | boolean;
@@ -1412,9 +1571,12 @@ declare class HttpClient {
1412
1571
  reportProgress?: boolean;
1413
1572
  responseType?: 'json';
1414
1573
  withCredentials?: boolean;
1574
+ credentials?: RequestCredentials;
1415
1575
  keepalive?: boolean;
1416
1576
  priority?: RequestPriority;
1417
1577
  cache?: RequestCache;
1578
+ mode?: RequestMode;
1579
+ redirect?: RequestRedirect;
1418
1580
  transferCache?: {
1419
1581
  includeHeaders?: string[];
1420
1582
  } | boolean;
@@ -1437,9 +1599,12 @@ declare class HttpClient {
1437
1599
  reportProgress?: boolean;
1438
1600
  responseType: 'arraybuffer';
1439
1601
  withCredentials?: boolean;
1602
+ credentials?: RequestCredentials;
1440
1603
  keepalive?: boolean;
1441
1604
  priority?: RequestPriority;
1442
1605
  cache?: RequestCache;
1606
+ mode?: RequestMode;
1607
+ redirect?: RequestRedirect;
1443
1608
  transferCache?: {
1444
1609
  includeHeaders?: string[];
1445
1610
  } | boolean;
@@ -1462,9 +1627,12 @@ declare class HttpClient {
1462
1627
  reportProgress?: boolean;
1463
1628
  responseType: 'blob';
1464
1629
  withCredentials?: boolean;
1630
+ credentials?: RequestCredentials;
1465
1631
  keepalive?: boolean;
1466
1632
  priority?: RequestPriority;
1467
1633
  cache?: RequestCache;
1634
+ mode?: RequestMode;
1635
+ redirect?: RequestRedirect;
1468
1636
  transferCache?: {
1469
1637
  includeHeaders?: string[];
1470
1638
  } | boolean;
@@ -1487,9 +1655,12 @@ declare class HttpClient {
1487
1655
  reportProgress?: boolean;
1488
1656
  responseType: 'text';
1489
1657
  withCredentials?: boolean;
1658
+ credentials?: RequestCredentials;
1490
1659
  keepalive?: boolean;
1491
1660
  priority?: RequestPriority;
1492
1661
  cache?: RequestCache;
1662
+ mode?: RequestMode;
1663
+ redirect?: RequestRedirect;
1493
1664
  transferCache?: {
1494
1665
  includeHeaders?: string[];
1495
1666
  } | boolean;
@@ -1512,9 +1683,12 @@ declare class HttpClient {
1512
1683
  reportProgress?: boolean;
1513
1684
  responseType?: 'json';
1514
1685
  withCredentials?: boolean;
1686
+ credentials?: RequestCredentials;
1515
1687
  keepalive?: boolean;
1516
1688
  priority?: RequestPriority;
1517
1689
  cache?: RequestCache;
1690
+ mode?: RequestMode;
1691
+ redirect?: RequestRedirect;
1518
1692
  transferCache?: {
1519
1693
  includeHeaders?: string[];
1520
1694
  } | boolean;
@@ -1537,9 +1711,12 @@ declare class HttpClient {
1537
1711
  reportProgress?: boolean;
1538
1712
  responseType?: 'json';
1539
1713
  withCredentials?: boolean;
1714
+ credentials?: RequestCredentials;
1540
1715
  keepalive?: boolean;
1541
1716
  priority?: RequestPriority;
1542
1717
  cache?: RequestCache;
1718
+ mode?: RequestMode;
1719
+ redirect?: RequestRedirect;
1543
1720
  transferCache?: {
1544
1721
  includeHeaders?: string[];
1545
1722
  } | boolean;
@@ -1562,9 +1739,12 @@ declare class HttpClient {
1562
1739
  reportProgress?: boolean;
1563
1740
  responseType?: 'json';
1564
1741
  withCredentials?: boolean;
1742
+ credentials?: RequestCredentials;
1565
1743
  keepalive?: boolean;
1566
1744
  priority?: RequestPriority;
1567
1745
  cache?: RequestCache;
1746
+ mode?: RequestMode;
1747
+ redirect?: RequestRedirect;
1568
1748
  transferCache?: {
1569
1749
  includeHeaders?: string[];
1570
1750
  } | boolean;
@@ -1587,9 +1767,12 @@ declare class HttpClient {
1587
1767
  reportProgress?: boolean;
1588
1768
  responseType?: 'json';
1589
1769
  withCredentials?: boolean;
1770
+ credentials?: RequestCredentials;
1590
1771
  keepalive?: boolean;
1591
1772
  priority?: RequestPriority;
1592
1773
  cache?: RequestCache;
1774
+ mode?: RequestMode;
1775
+ redirect?: RequestRedirect;
1593
1776
  transferCache?: {
1594
1777
  includeHeaders?: string[];
1595
1778
  } | boolean;
@@ -1633,9 +1816,12 @@ declare class HttpClient {
1633
1816
  reportProgress?: boolean;
1634
1817
  responseType: 'arraybuffer';
1635
1818
  withCredentials?: boolean;
1819
+ credentials?: RequestCredentials;
1636
1820
  keepalive?: boolean;
1637
1821
  priority?: RequestPriority;
1638
1822
  cache?: RequestCache;
1823
+ mode?: RequestMode;
1824
+ redirect?: RequestRedirect;
1639
1825
  }): Observable<ArrayBuffer>;
1640
1826
  /**
1641
1827
  * Constructs an `OPTIONS` request that interprets the body as a `Blob` and returns
@@ -1654,9 +1840,12 @@ declare class HttpClient {
1654
1840
  reportProgress?: boolean;
1655
1841
  responseType: 'blob';
1656
1842
  withCredentials?: boolean;
1843
+ credentials?: RequestCredentials;
1657
1844
  keepalive?: boolean;
1658
1845
  priority?: RequestPriority;
1659
1846
  cache?: RequestCache;
1847
+ mode?: RequestMode;
1848
+ redirect?: RequestRedirect;
1660
1849
  }): Observable<Blob>;
1661
1850
  /**
1662
1851
  * Constructs an `OPTIONS` request that interprets the body as a text string and
@@ -1675,9 +1864,12 @@ declare class HttpClient {
1675
1864
  reportProgress?: boolean;
1676
1865
  responseType: 'text';
1677
1866
  withCredentials?: boolean;
1867
+ credentials?: RequestCredentials;
1678
1868
  keepalive?: boolean;
1679
1869
  priority?: RequestPriority;
1680
1870
  cache?: RequestCache;
1871
+ mode?: RequestMode;
1872
+ redirect?: RequestRedirect;
1681
1873
  }): Observable<string>;
1682
1874
  /**
1683
1875
  * Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`
@@ -1697,9 +1889,12 @@ declare class HttpClient {
1697
1889
  reportProgress?: boolean;
1698
1890
  responseType: 'arraybuffer';
1699
1891
  withCredentials?: boolean;
1892
+ credentials?: RequestCredentials;
1700
1893
  keepalive?: boolean;
1701
1894
  priority?: RequestPriority;
1702
1895
  cache?: RequestCache;
1896
+ mode?: RequestMode;
1897
+ redirect?: RequestRedirect;
1703
1898
  }): Observable<HttpEvent<ArrayBuffer>>;
1704
1899
  /**
1705
1900
  * Constructs an `OPTIONS` request that interprets the body as a `Blob` and
@@ -1719,9 +1914,12 @@ declare class HttpClient {
1719
1914
  reportProgress?: boolean;
1720
1915
  responseType: 'blob';
1721
1916
  withCredentials?: boolean;
1917
+ credentials?: RequestCredentials;
1722
1918
  keepalive?: boolean;
1723
1919
  priority?: RequestPriority;
1724
1920
  cache?: RequestCache;
1921
+ mode?: RequestMode;
1922
+ redirect?: RequestRedirect;
1725
1923
  }): Observable<HttpEvent<Blob>>;
1726
1924
  /**
1727
1925
  * Constructs an `OPTIONS` request that interprets the body as a text string
@@ -1741,9 +1939,12 @@ declare class HttpClient {
1741
1939
  reportProgress?: boolean;
1742
1940
  responseType: 'text';
1743
1941
  withCredentials?: boolean;
1942
+ credentials?: RequestCredentials;
1744
1943
  keepalive?: boolean;
1745
1944
  priority?: RequestPriority;
1746
1945
  cache?: RequestCache;
1946
+ mode?: RequestMode;
1947
+ redirect?: RequestRedirect;
1747
1948
  }): Observable<HttpEvent<string>>;
1748
1949
  /**
1749
1950
  * Constructs an `OPTIONS` request that interprets the body as JSON
@@ -1763,9 +1964,12 @@ declare class HttpClient {
1763
1964
  reportProgress?: boolean;
1764
1965
  responseType?: 'json';
1765
1966
  withCredentials?: boolean;
1967
+ credentials?: RequestCredentials;
1766
1968
  keepalive?: boolean;
1767
1969
  priority?: RequestPriority;
1768
1970
  cache?: RequestCache;
1971
+ mode?: RequestMode;
1972
+ redirect?: RequestRedirect;
1769
1973
  }): Observable<HttpEvent<Object>>;
1770
1974
  /**
1771
1975
  * Constructs an `OPTIONS` request that interprets the body as JSON and
@@ -1785,9 +1989,12 @@ declare class HttpClient {
1785
1989
  reportProgress?: boolean;
1786
1990
  responseType?: 'json';
1787
1991
  withCredentials?: boolean;
1992
+ credentials?: RequestCredentials;
1788
1993
  keepalive?: boolean;
1789
1994
  priority?: RequestPriority;
1790
1995
  cache?: RequestCache;
1996
+ mode?: RequestMode;
1997
+ redirect?: RequestRedirect;
1791
1998
  }): Observable<HttpEvent<T>>;
1792
1999
  /**
1793
2000
  * Constructs an `OPTIONS` request that interprets the body as an `ArrayBuffer`
@@ -1807,9 +2014,12 @@ declare class HttpClient {
1807
2014
  reportProgress?: boolean;
1808
2015
  responseType: 'arraybuffer';
1809
2016
  withCredentials?: boolean;
2017
+ credentials?: RequestCredentials;
1810
2018
  keepalive?: boolean;
1811
2019
  priority?: RequestPriority;
1812
2020
  cache?: RequestCache;
2021
+ mode?: RequestMode;
2022
+ redirect?: RequestRedirect;
1813
2023
  }): Observable<HttpResponse<ArrayBuffer>>;
1814
2024
  /**
1815
2025
  * Constructs an `OPTIONS` request that interprets the body as a `Blob`
@@ -1829,9 +2039,12 @@ declare class HttpClient {
1829
2039
  reportProgress?: boolean;
1830
2040
  responseType: 'blob';
1831
2041
  withCredentials?: boolean;
2042
+ credentials?: RequestCredentials;
1832
2043
  keepalive?: boolean;
1833
2044
  priority?: RequestPriority;
1834
2045
  cache?: RequestCache;
2046
+ mode?: RequestMode;
2047
+ redirect?: RequestRedirect;
1835
2048
  }): Observable<HttpResponse<Blob>>;
1836
2049
  /**
1837
2050
  * Constructs an `OPTIONS` request that interprets the body as text stream
@@ -1851,9 +2064,12 @@ declare class HttpClient {
1851
2064
  reportProgress?: boolean;
1852
2065
  responseType: 'text';
1853
2066
  withCredentials?: boolean;
2067
+ credentials?: RequestCredentials;
1854
2068
  keepalive?: boolean;
1855
2069
  priority?: RequestPriority;
1856
2070
  cache?: RequestCache;
2071
+ mode?: RequestMode;
2072
+ redirect?: RequestRedirect;
1857
2073
  }): Observable<HttpResponse<string>>;
1858
2074
  /**
1859
2075
  * Constructs an `OPTIONS` request that interprets the body as JSON
@@ -1873,9 +2089,12 @@ declare class HttpClient {
1873
2089
  reportProgress?: boolean;
1874
2090
  responseType?: 'json';
1875
2091
  withCredentials?: boolean;
2092
+ credentials?: RequestCredentials;
1876
2093
  keepalive?: boolean;
1877
2094
  priority?: RequestPriority;
1878
2095
  cache?: RequestCache;
2096
+ mode?: RequestMode;
2097
+ redirect?: RequestRedirect;
1879
2098
  }): Observable<HttpResponse<Object>>;
1880
2099
  /**
1881
2100
  * Constructs an `OPTIONS` request that interprets the body as JSON and
@@ -1895,9 +2114,12 @@ declare class HttpClient {
1895
2114
  reportProgress?: boolean;
1896
2115
  responseType?: 'json';
1897
2116
  withCredentials?: boolean;
2117
+ credentials?: RequestCredentials;
1898
2118
  keepalive?: boolean;
1899
2119
  priority?: RequestPriority;
1900
2120
  cache?: RequestCache;
2121
+ mode?: RequestMode;
2122
+ redirect?: RequestRedirect;
1901
2123
  }): Observable<HttpResponse<T>>;
1902
2124
  /**
1903
2125
 
@@ -1917,9 +2139,12 @@ declare class HttpClient {
1917
2139
  reportProgress?: boolean;
1918
2140
  responseType?: 'json';
1919
2141
  withCredentials?: boolean;
2142
+ credentials?: RequestCredentials;
1920
2143
  keepalive?: boolean;
1921
2144
  priority?: RequestPriority;
1922
2145
  cache?: RequestCache;
2146
+ mode?: RequestMode;
2147
+ redirect?: RequestRedirect;
1923
2148
  }): Observable<Object>;
1924
2149
  /**
1925
2150
  * Constructs an `OPTIONS` request that interprets the body as JSON and returns the
@@ -1938,9 +2163,12 @@ declare class HttpClient {
1938
2163
  reportProgress?: boolean;
1939
2164
  responseType?: 'json';
1940
2165
  withCredentials?: boolean;
2166
+ credentials?: RequestCredentials;
1941
2167
  keepalive?: boolean;
1942
2168
  priority?: RequestPriority;
1943
2169
  cache?: RequestCache;
2170
+ mode?: RequestMode;
2171
+ redirect?: RequestRedirect;
1944
2172
  }): Observable<T>;
1945
2173
  /**
1946
2174
  * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
@@ -1960,9 +2188,12 @@ declare class HttpClient {
1960
2188
  reportProgress?: boolean;
1961
2189
  responseType: 'arraybuffer';
1962
2190
  withCredentials?: boolean;
2191
+ credentials?: RequestCredentials;
1963
2192
  keepalive?: boolean;
1964
2193
  priority?: RequestPriority;
1965
2194
  cache?: RequestCache;
2195
+ mode?: RequestMode;
2196
+ redirect?: RequestRedirect;
1966
2197
  }): Observable<ArrayBuffer>;
1967
2198
  /**
1968
2199
  * Constructs a `PATCH` request that interprets the body as a `Blob` and returns the response
@@ -1982,9 +2213,12 @@ declare class HttpClient {
1982
2213
  reportProgress?: boolean;
1983
2214
  responseType: 'blob';
1984
2215
  withCredentials?: boolean;
2216
+ credentials?: RequestCredentials;
1985
2217
  keepalive?: boolean;
1986
2218
  priority?: RequestPriority;
1987
2219
  cache?: RequestCache;
2220
+ mode?: RequestMode;
2221
+ redirect?: RequestRedirect;
1988
2222
  }): Observable<Blob>;
1989
2223
  /**
1990
2224
  * Constructs a `PATCH` request that interprets the body as a text string and
@@ -2004,9 +2238,12 @@ declare class HttpClient {
2004
2238
  reportProgress?: boolean;
2005
2239
  responseType: 'text';
2006
2240
  withCredentials?: boolean;
2241
+ credentials?: RequestCredentials;
2007
2242
  keepalive?: boolean;
2008
2243
  priority?: RequestPriority;
2009
2244
  cache?: RequestCache;
2245
+ mode?: RequestMode;
2246
+ redirect?: RequestRedirect;
2010
2247
  }): Observable<string>;
2011
2248
  /**
2012
2249
  * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and
@@ -2027,9 +2264,12 @@ declare class HttpClient {
2027
2264
  reportProgress?: boolean;
2028
2265
  responseType: 'arraybuffer';
2029
2266
  withCredentials?: boolean;
2267
+ credentials?: RequestCredentials;
2030
2268
  keepalive?: boolean;
2031
2269
  priority?: RequestPriority;
2032
2270
  cache?: RequestCache;
2271
+ mode?: RequestMode;
2272
+ redirect?: RequestRedirect;
2033
2273
  }): Observable<HttpEvent<ArrayBuffer>>;
2034
2274
  /**
2035
2275
  * Constructs a `PATCH` request that interprets the body as a `Blob`
@@ -2050,9 +2290,12 @@ declare class HttpClient {
2050
2290
  reportProgress?: boolean;
2051
2291
  responseType: 'blob';
2052
2292
  withCredentials?: boolean;
2293
+ credentials?: RequestCredentials;
2053
2294
  keepalive?: boolean;
2054
2295
  priority?: RequestPriority;
2055
2296
  cache?: RequestCache;
2297
+ mode?: RequestMode;
2298
+ redirect?: RequestRedirect;
2056
2299
  }): Observable<HttpEvent<Blob>>;
2057
2300
  /**
2058
2301
  * Constructs a `PATCH` request that interprets the body as a text string and
@@ -2073,9 +2316,12 @@ declare class HttpClient {
2073
2316
  reportProgress?: boolean;
2074
2317
  responseType: 'text';
2075
2318
  withCredentials?: boolean;
2319
+ credentials?: RequestCredentials;
2076
2320
  keepalive?: boolean;
2077
2321
  priority?: RequestPriority;
2078
2322
  cache?: RequestCache;
2323
+ mode?: RequestMode;
2324
+ redirect?: RequestRedirect;
2079
2325
  }): Observable<HttpEvent<string>>;
2080
2326
  /**
2081
2327
  * Constructs a `PATCH` request that interprets the body as JSON
@@ -2096,9 +2342,12 @@ declare class HttpClient {
2096
2342
  reportProgress?: boolean;
2097
2343
  responseType?: 'json';
2098
2344
  withCredentials?: boolean;
2345
+ credentials?: RequestCredentials;
2099
2346
  keepalive?: boolean;
2100
2347
  priority?: RequestPriority;
2101
2348
  cache?: RequestCache;
2349
+ mode?: RequestMode;
2350
+ redirect?: RequestRedirect;
2102
2351
  }): Observable<HttpEvent<Object>>;
2103
2352
  /**
2104
2353
  * Constructs a `PATCH` request that interprets the body as JSON
@@ -2119,9 +2368,12 @@ declare class HttpClient {
2119
2368
  reportProgress?: boolean;
2120
2369
  responseType?: 'json';
2121
2370
  withCredentials?: boolean;
2371
+ credentials?: RequestCredentials;
2122
2372
  keepalive?: boolean;
2123
2373
  priority?: RequestPriority;
2124
2374
  cache?: RequestCache;
2375
+ mode?: RequestMode;
2376
+ redirect?: RequestRedirect;
2125
2377
  }): Observable<HttpEvent<T>>;
2126
2378
  /**
2127
2379
  * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer`
@@ -2142,9 +2394,12 @@ declare class HttpClient {
2142
2394
  reportProgress?: boolean;
2143
2395
  responseType: 'arraybuffer';
2144
2396
  withCredentials?: boolean;
2397
+ credentials?: RequestCredentials;
2145
2398
  keepalive?: boolean;
2146
2399
  priority?: RequestPriority;
2147
2400
  cache?: RequestCache;
2401
+ mode?: RequestMode;
2402
+ redirect?: RequestRedirect;
2148
2403
  }): Observable<HttpResponse<ArrayBuffer>>;
2149
2404
  /**
2150
2405
  * Constructs a `PATCH` request that interprets the body as a `Blob` and returns the full
@@ -2165,9 +2420,12 @@ declare class HttpClient {
2165
2420
  reportProgress?: boolean;
2166
2421
  responseType: 'blob';
2167
2422
  withCredentials?: boolean;
2423
+ credentials?: RequestCredentials;
2168
2424
  keepalive?: boolean;
2169
2425
  priority?: RequestPriority;
2170
2426
  cache?: RequestCache;
2427
+ mode?: RequestMode;
2428
+ redirect?: RequestRedirect;
2171
2429
  }): Observable<HttpResponse<Blob>>;
2172
2430
  /**
2173
2431
  * Constructs a `PATCH` request that interprets the body as a text stream and returns the
@@ -2188,9 +2446,12 @@ declare class HttpClient {
2188
2446
  reportProgress?: boolean;
2189
2447
  responseType: 'text';
2190
2448
  withCredentials?: boolean;
2449
+ credentials?: RequestCredentials;
2191
2450
  keepalive?: boolean;
2192
2451
  priority?: RequestPriority;
2193
2452
  cache?: RequestCache;
2453
+ mode?: RequestMode;
2454
+ redirect?: RequestRedirect;
2194
2455
  }): Observable<HttpResponse<string>>;
2195
2456
  /**
2196
2457
  * Constructs a `PATCH` request that interprets the body as JSON
@@ -2211,9 +2472,12 @@ declare class HttpClient {
2211
2472
  reportProgress?: boolean;
2212
2473
  responseType?: 'json';
2213
2474
  withCredentials?: boolean;
2475
+ credentials?: RequestCredentials;
2214
2476
  keepalive?: boolean;
2215
2477
  priority?: RequestPriority;
2216
2478
  cache?: RequestCache;
2479
+ mode?: RequestMode;
2480
+ redirect?: RequestRedirect;
2217
2481
  }): Observable<HttpResponse<Object>>;
2218
2482
  /**
2219
2483
  * Constructs a `PATCH` request that interprets the body as JSON
@@ -2234,9 +2498,12 @@ declare class HttpClient {
2234
2498
  reportProgress?: boolean;
2235
2499
  responseType?: 'json';
2236
2500
  withCredentials?: boolean;
2501
+ credentials?: RequestCredentials;
2237
2502
  keepalive?: boolean;
2238
2503
  priority?: RequestPriority;
2239
2504
  cache?: RequestCache;
2505
+ mode?: RequestMode;
2506
+ redirect?: RequestRedirect;
2240
2507
  }): Observable<HttpResponse<T>>;
2241
2508
  /**
2242
2509
 
@@ -2257,9 +2524,12 @@ declare class HttpClient {
2257
2524
  reportProgress?: boolean;
2258
2525
  responseType?: 'json';
2259
2526
  withCredentials?: boolean;
2527
+ credentials?: RequestCredentials;
2260
2528
  keepalive?: boolean;
2261
2529
  priority?: RequestPriority;
2262
2530
  cache?: RequestCache;
2531
+ mode?: RequestMode;
2532
+ redirect?: RequestRedirect;
2263
2533
  }): Observable<Object>;
2264
2534
  /**
2265
2535
  * Constructs a `PATCH` request that interprets the body as JSON
@@ -2280,9 +2550,12 @@ declare class HttpClient {
2280
2550
  reportProgress?: boolean;
2281
2551
  responseType?: 'json';
2282
2552
  withCredentials?: boolean;
2553
+ credentials?: RequestCredentials;
2283
2554
  keepalive?: boolean;
2284
2555
  priority?: RequestPriority;
2285
2556
  cache?: RequestCache;
2557
+ mode?: RequestMode;
2558
+ redirect?: RequestRedirect;
2286
2559
  }): Observable<T>;
2287
2560
  /**
2288
2561
  * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
@@ -2302,9 +2575,12 @@ declare class HttpClient {
2302
2575
  reportProgress?: boolean;
2303
2576
  responseType: 'arraybuffer';
2304
2577
  withCredentials?: boolean;
2578
+ credentials?: RequestCredentials;
2305
2579
  keepalive?: boolean;
2306
2580
  priority?: RequestPriority;
2307
2581
  cache?: RequestCache;
2582
+ mode?: RequestMode;
2583
+ redirect?: RequestRedirect;
2308
2584
  transferCache?: {
2309
2585
  includeHeaders?: string[];
2310
2586
  } | boolean;
@@ -2327,9 +2603,12 @@ declare class HttpClient {
2327
2603
  reportProgress?: boolean;
2328
2604
  responseType: 'blob';
2329
2605
  withCredentials?: boolean;
2606
+ credentials?: RequestCredentials;
2330
2607
  keepalive?: boolean;
2331
2608
  priority?: RequestPriority;
2332
2609
  cache?: RequestCache;
2610
+ mode?: RequestMode;
2611
+ redirect?: RequestRedirect;
2333
2612
  transferCache?: {
2334
2613
  includeHeaders?: string[];
2335
2614
  } | boolean;
@@ -2352,9 +2631,12 @@ declare class HttpClient {
2352
2631
  reportProgress?: boolean;
2353
2632
  responseType: 'text';
2354
2633
  withCredentials?: boolean;
2634
+ credentials?: RequestCredentials;
2355
2635
  keepalive?: boolean;
2356
2636
  priority?: RequestPriority;
2357
2637
  cache?: RequestCache;
2638
+ mode?: RequestMode;
2639
+ redirect?: RequestRedirect;
2358
2640
  transferCache?: {
2359
2641
  includeHeaders?: string[];
2360
2642
  } | boolean;
@@ -2378,9 +2660,12 @@ declare class HttpClient {
2378
2660
  reportProgress?: boolean;
2379
2661
  responseType: 'arraybuffer';
2380
2662
  withCredentials?: boolean;
2663
+ credentials?: RequestCredentials;
2381
2664
  keepalive?: boolean;
2382
2665
  priority?: RequestPriority;
2383
2666
  cache?: RequestCache;
2667
+ mode?: RequestMode;
2668
+ redirect?: RequestRedirect;
2384
2669
  transferCache?: {
2385
2670
  includeHeaders?: string[];
2386
2671
  } | boolean;
@@ -2403,9 +2688,12 @@ declare class HttpClient {
2403
2688
  reportProgress?: boolean;
2404
2689
  responseType: 'blob';
2405
2690
  withCredentials?: boolean;
2691
+ credentials?: RequestCredentials;
2406
2692
  keepalive?: boolean;
2407
2693
  priority?: RequestPriority;
2408
2694
  cache?: RequestCache;
2695
+ mode?: RequestMode;
2696
+ redirect?: RequestRedirect;
2409
2697
  transferCache?: {
2410
2698
  includeHeaders?: string[];
2411
2699
  } | boolean;
@@ -2429,9 +2717,12 @@ declare class HttpClient {
2429
2717
  reportProgress?: boolean;
2430
2718
  responseType: 'text';
2431
2719
  withCredentials?: boolean;
2720
+ credentials?: RequestCredentials;
2432
2721
  keepalive?: boolean;
2433
2722
  priority?: RequestPriority;
2434
2723
  cache?: RequestCache;
2724
+ mode?: RequestMode;
2725
+ redirect?: RequestRedirect;
2435
2726
  transferCache?: {
2436
2727
  includeHeaders?: string[];
2437
2728
  } | boolean;
@@ -2455,9 +2746,12 @@ declare class HttpClient {
2455
2746
  reportProgress?: boolean;
2456
2747
  responseType?: 'json';
2457
2748
  withCredentials?: boolean;
2749
+ credentials?: RequestCredentials;
2458
2750
  keepalive?: boolean;
2459
2751
  priority?: RequestPriority;
2460
2752
  cache?: RequestCache;
2753
+ mode?: RequestMode;
2754
+ redirect?: RequestRedirect;
2461
2755
  transferCache?: {
2462
2756
  includeHeaders?: string[];
2463
2757
  } | boolean;
@@ -2481,9 +2775,12 @@ declare class HttpClient {
2481
2775
  reportProgress?: boolean;
2482
2776
  responseType?: 'json';
2483
2777
  withCredentials?: boolean;
2778
+ credentials?: RequestCredentials;
2484
2779
  keepalive?: boolean;
2485
2780
  priority?: RequestPriority;
2486
2781
  cache?: RequestCache;
2782
+ mode?: RequestMode;
2783
+ redirect?: RequestRedirect;
2487
2784
  transferCache?: {
2488
2785
  includeHeaders?: string[];
2489
2786
  } | boolean;
@@ -2507,9 +2804,12 @@ declare class HttpClient {
2507
2804
  reportProgress?: boolean;
2508
2805
  responseType: 'arraybuffer';
2509
2806
  withCredentials?: boolean;
2807
+ credentials?: RequestCredentials;
2510
2808
  keepalive?: boolean;
2511
2809
  priority?: RequestPriority;
2512
2810
  cache?: RequestCache;
2811
+ mode?: RequestMode;
2812
+ redirect?: RequestRedirect;
2513
2813
  transferCache?: {
2514
2814
  includeHeaders?: string[];
2515
2815
  } | boolean;
@@ -2533,9 +2833,12 @@ declare class HttpClient {
2533
2833
  reportProgress?: boolean;
2534
2834
  responseType: 'blob';
2535
2835
  withCredentials?: boolean;
2836
+ credentials?: RequestCredentials;
2536
2837
  keepalive?: boolean;
2537
2838
  priority?: RequestPriority;
2538
2839
  cache?: RequestCache;
2840
+ mode?: RequestMode;
2841
+ redirect?: RequestRedirect;
2539
2842
  transferCache?: {
2540
2843
  includeHeaders?: string[];
2541
2844
  } | boolean;
@@ -2559,9 +2862,12 @@ declare class HttpClient {
2559
2862
  reportProgress?: boolean;
2560
2863
  responseType: 'text';
2561
2864
  withCredentials?: boolean;
2865
+ credentials?: RequestCredentials;
2562
2866
  keepalive?: boolean;
2563
2867
  priority?: RequestPriority;
2564
2868
  cache?: RequestCache;
2869
+ mode?: RequestMode;
2870
+ redirect?: RequestRedirect;
2565
2871
  transferCache?: {
2566
2872
  includeHeaders?: string[];
2567
2873
  } | boolean;
@@ -2585,9 +2891,12 @@ declare class HttpClient {
2585
2891
  reportProgress?: boolean;
2586
2892
  responseType?: 'json';
2587
2893
  withCredentials?: boolean;
2894
+ credentials?: RequestCredentials;
2588
2895
  keepalive?: boolean;
2589
2896
  priority?: RequestPriority;
2590
2897
  cache?: RequestCache;
2898
+ mode?: RequestMode;
2899
+ redirect?: RequestRedirect;
2591
2900
  transferCache?: {
2592
2901
  includeHeaders?: string[];
2593
2902
  } | boolean;
@@ -2612,9 +2921,12 @@ declare class HttpClient {
2612
2921
  reportProgress?: boolean;
2613
2922
  responseType?: 'json';
2614
2923
  withCredentials?: boolean;
2924
+ credentials?: RequestCredentials;
2615
2925
  keepalive?: boolean;
2616
2926
  priority?: RequestPriority;
2617
2927
  cache?: RequestCache;
2928
+ mode?: RequestMode;
2929
+ redirect?: RequestRedirect;
2618
2930
  transferCache?: {
2619
2931
  includeHeaders?: string[];
2620
2932
  } | boolean;
@@ -2637,9 +2949,12 @@ declare class HttpClient {
2637
2949
  reportProgress?: boolean;
2638
2950
  responseType?: 'json';
2639
2951
  withCredentials?: boolean;
2952
+ credentials?: RequestCredentials;
2640
2953
  keepalive?: boolean;
2641
2954
  priority?: RequestPriority;
2642
2955
  cache?: RequestCache;
2956
+ mode?: RequestMode;
2957
+ redirect?: RequestRedirect;
2643
2958
  transferCache?: {
2644
2959
  includeHeaders?: string[];
2645
2960
  } | boolean;
@@ -2663,9 +2978,12 @@ declare class HttpClient {
2663
2978
  reportProgress?: boolean;
2664
2979
  responseType?: 'json';
2665
2980
  withCredentials?: boolean;
2981
+ credentials?: RequestCredentials;
2666
2982
  keepalive?: boolean;
2667
2983
  priority?: RequestPriority;
2668
2984
  cache?: RequestCache;
2985
+ mode?: RequestMode;
2986
+ redirect?: RequestRedirect;
2669
2987
  transferCache?: {
2670
2988
  includeHeaders?: string[];
2671
2989
  } | boolean;
@@ -2688,9 +3006,12 @@ declare class HttpClient {
2688
3006
  reportProgress?: boolean;
2689
3007
  responseType: 'arraybuffer';
2690
3008
  withCredentials?: boolean;
3009
+ credentials?: RequestCredentials;
2691
3010
  keepalive?: boolean;
2692
3011
  priority?: RequestPriority;
2693
3012
  cache?: RequestCache;
3013
+ mode?: RequestMode;
3014
+ redirect?: RequestRedirect;
2694
3015
  }): Observable<ArrayBuffer>;
2695
3016
  /**
2696
3017
  * Constructs a `PUT` request that interprets the body as a `Blob` and returns
@@ -2710,9 +3031,12 @@ declare class HttpClient {
2710
3031
  reportProgress?: boolean;
2711
3032
  responseType: 'blob';
2712
3033
  withCredentials?: boolean;
3034
+ credentials?: RequestCredentials;
2713
3035
  keepalive?: boolean;
2714
3036
  priority?: RequestPriority;
2715
3037
  cache?: RequestCache;
3038
+ mode?: RequestMode;
3039
+ redirect?: RequestRedirect;
2716
3040
  }): Observable<Blob>;
2717
3041
  /**
2718
3042
  * Constructs a `PUT` request that interprets the body as a text string and
@@ -2732,9 +3056,12 @@ declare class HttpClient {
2732
3056
  reportProgress?: boolean;
2733
3057
  responseType: 'text';
2734
3058
  withCredentials?: boolean;
3059
+ credentials?: RequestCredentials;
2735
3060
  keepalive?: boolean;
2736
3061
  priority?: RequestPriority;
2737
3062
  cache?: RequestCache;
3063
+ mode?: RequestMode;
3064
+ redirect?: RequestRedirect;
2738
3065
  }): Observable<string>;
2739
3066
  /**
2740
3067
  * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and
@@ -2755,9 +3082,12 @@ declare class HttpClient {
2755
3082
  reportProgress?: boolean;
2756
3083
  responseType: 'arraybuffer';
2757
3084
  withCredentials?: boolean;
3085
+ credentials?: RequestCredentials;
2758
3086
  keepalive?: boolean;
2759
3087
  priority?: RequestPriority;
2760
3088
  cache?: RequestCache;
3089
+ mode?: RequestMode;
3090
+ redirect?: RequestRedirect;
2761
3091
  }): Observable<HttpEvent<ArrayBuffer>>;
2762
3092
  /**
2763
3093
  * Constructs a `PUT` request that interprets the body as a `Blob` and returns the full event
@@ -2778,9 +3108,12 @@ declare class HttpClient {
2778
3108
  reportProgress?: boolean;
2779
3109
  responseType: 'blob';
2780
3110
  withCredentials?: boolean;
3111
+ credentials?: RequestCredentials;
2781
3112
  keepalive?: boolean;
2782
3113
  priority?: RequestPriority;
2783
3114
  cache?: RequestCache;
3115
+ mode?: RequestMode;
3116
+ redirect?: RequestRedirect;
2784
3117
  }): Observable<HttpEvent<Blob>>;
2785
3118
  /**
2786
3119
  * Constructs a `PUT` request that interprets the body as a text string and returns the full event
@@ -2801,9 +3134,12 @@ declare class HttpClient {
2801
3134
  reportProgress?: boolean;
2802
3135
  responseType: 'text';
2803
3136
  withCredentials?: boolean;
3137
+ credentials?: RequestCredentials;
2804
3138
  keepalive?: boolean;
2805
3139
  priority?: RequestPriority;
2806
3140
  cache?: RequestCache;
3141
+ mode?: RequestMode;
3142
+ redirect?: RequestRedirect;
2807
3143
  }): Observable<HttpEvent<string>>;
2808
3144
  /**
2809
3145
  * Constructs a `PUT` request that interprets the body as JSON and returns the full
@@ -2824,9 +3160,12 @@ declare class HttpClient {
2824
3160
  reportProgress?: boolean;
2825
3161
  responseType?: 'json';
2826
3162
  withCredentials?: boolean;
3163
+ credentials?: RequestCredentials;
2827
3164
  keepalive?: boolean;
2828
3165
  priority?: RequestPriority;
2829
3166
  cache?: RequestCache;
3167
+ mode?: RequestMode;
3168
+ redirect?: RequestRedirect;
2830
3169
  }): Observable<HttpEvent<Object>>;
2831
3170
  /**
2832
3171
  * Constructs a `PUT` request that interprets the body as JSON and returns the
@@ -2847,9 +3186,12 @@ declare class HttpClient {
2847
3186
  reportProgress?: boolean;
2848
3187
  responseType?: 'json';
2849
3188
  withCredentials?: boolean;
3189
+ credentials?: RequestCredentials;
2850
3190
  keepalive?: boolean;
2851
3191
  priority?: RequestPriority;
2852
3192
  cache?: RequestCache;
3193
+ mode?: RequestMode;
3194
+ redirect?: RequestRedirect;
2853
3195
  }): Observable<HttpEvent<T>>;
2854
3196
  /**
2855
3197
  * Constructs a `PUT` request that interprets the body as an
@@ -2870,9 +3212,12 @@ declare class HttpClient {
2870
3212
  reportProgress?: boolean;
2871
3213
  responseType: 'arraybuffer';
2872
3214
  withCredentials?: boolean;
3215
+ credentials?: RequestCredentials;
2873
3216
  keepalive?: boolean;
2874
3217
  priority?: RequestPriority;
2875
3218
  cache?: RequestCache;
3219
+ mode?: RequestMode;
3220
+ redirect?: RequestRedirect;
2876
3221
  }): Observable<HttpResponse<ArrayBuffer>>;
2877
3222
  /**
2878
3223
  * Constructs a `PUT` request that interprets the body as a `Blob` and returns the
@@ -2893,9 +3238,12 @@ declare class HttpClient {
2893
3238
  reportProgress?: boolean;
2894
3239
  responseType: 'blob';
2895
3240
  withCredentials?: boolean;
3241
+ credentials?: RequestCredentials;
2896
3242
  keepalive?: boolean;
2897
3243
  priority?: RequestPriority;
2898
3244
  cache?: RequestCache;
3245
+ mode?: RequestMode;
3246
+ redirect?: RequestRedirect;
2899
3247
  }): Observable<HttpResponse<Blob>>;
2900
3248
  /**
2901
3249
  * Constructs a `PUT` request that interprets the body as a text stream and returns the
@@ -2916,9 +3264,12 @@ declare class HttpClient {
2916
3264
  reportProgress?: boolean;
2917
3265
  responseType: 'text';
2918
3266
  withCredentials?: boolean;
3267
+ credentials?: RequestCredentials;
2919
3268
  keepalive?: boolean;
2920
3269
  priority?: RequestPriority;
2921
3270
  cache?: RequestCache;
3271
+ mode?: RequestMode;
3272
+ redirect?: RequestRedirect;
2922
3273
  }): Observable<HttpResponse<string>>;
2923
3274
  /**
2924
3275
  * Constructs a `PUT` request that interprets the body as JSON and returns the full
@@ -2939,9 +3290,12 @@ declare class HttpClient {
2939
3290
  reportProgress?: boolean;
2940
3291
  responseType?: 'json';
2941
3292
  withCredentials?: boolean;
3293
+ credentials?: RequestCredentials;
2942
3294
  keepalive?: boolean;
2943
3295
  priority?: RequestPriority;
2944
3296
  cache?: RequestCache;
3297
+ mode?: RequestMode;
3298
+ redirect?: RequestRedirect;
2945
3299
  }): Observable<HttpResponse<Object>>;
2946
3300
  /**
2947
3301
  * Constructs a `PUT` request that interprets the body as an instance of the requested type and
@@ -2962,9 +3316,12 @@ declare class HttpClient {
2962
3316
  reportProgress?: boolean;
2963
3317
  responseType?: 'json';
2964
3318
  withCredentials?: boolean;
3319
+ credentials?: RequestCredentials;
2965
3320
  keepalive?: boolean;
2966
3321
  priority?: RequestPriority;
2967
3322
  cache?: RequestCache;
3323
+ mode?: RequestMode;
3324
+ redirect?: RequestRedirect;
2968
3325
  }): Observable<HttpResponse<T>>;
2969
3326
  /**
2970
3327
  * Constructs a `PUT` request that interprets the body as JSON
@@ -2984,9 +3341,12 @@ declare class HttpClient {
2984
3341
  reportProgress?: boolean;
2985
3342
  responseType?: 'json';
2986
3343
  withCredentials?: boolean;
3344
+ credentials?: RequestCredentials;
2987
3345
  keepalive?: boolean;
2988
3346
  priority?: RequestPriority;
2989
3347
  cache?: RequestCache;
3348
+ mode?: RequestMode;
3349
+ redirect?: RequestRedirect;
2990
3350
  }): Observable<Object>;
2991
3351
  /**
2992
3352
  * Constructs a `PUT` request that interprets the body as an instance of the requested type
@@ -3006,9 +3366,12 @@ declare class HttpClient {
3006
3366
  reportProgress?: boolean;
3007
3367
  responseType?: 'json';
3008
3368
  withCredentials?: boolean;
3369
+ credentials?: RequestCredentials;
3009
3370
  keepalive?: boolean;
3010
3371
  priority?: RequestPriority;
3011
3372
  cache?: RequestCache;
3373
+ mode?: RequestMode;
3374
+ redirect?: RequestRedirect;
3012
3375
  }): Observable<T>;
3013
3376
  static ɵfac: i0.ɵɵFactoryDeclaration<HttpClient, never>;
3014
3377
  static ɵprov: i0.ɵɵInjectableDeclaration<HttpClient>;
@@ -3410,6 +3773,30 @@ interface HttpResourceRequest {
3410
3773
  * 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
3774
  */
3412
3775
  keepalive?: boolean;
3776
+ /**
3777
+ * Controls how the request will interact with the browser's HTTP cache.
3778
+ * This affects whether a response is retrieved from the cache, how it is stored, or if it bypasses the cache altogether.
3779
+ */
3780
+ cache?: RequestCache | (string & {});
3781
+ /**
3782
+ * The credentials mode of the request, which determines how cookies and other authentication information are handled.
3783
+ * This can affect whether credentials are sent with cross-origin requests or not.
3784
+ */
3785
+ credentials?: RequestCredentials | (string & {});
3786
+ /**
3787
+ * Indicates the relative priority of the request. This may be used by the browser to decide the order in which requests are dispatched and resources fetched.
3788
+ */
3789
+ priority?: RequestPriority | (string & {});
3790
+ /**
3791
+ * The mode of the request, which determines how the request will interact with the browser's security model.
3792
+ * This can affect things like CORS (Cross-Origin Resource Sharing) and same-origin policies.
3793
+ */
3794
+ mode?: RequestMode | (string & {});
3795
+ /**
3796
+ * The redirect mode of the request, which determines how redirects are handled.
3797
+ * This can affect whether the request follows redirects automatically, or if it fails when a redirect occurs.
3798
+ */
3799
+ redirect?: RequestRedirect | (string & {});
3413
3800
  /**
3414
3801
  * Configures the server-side rendering transfer cache for this request.
3415
3802
  *
@@ -3418,6 +3805,10 @@ interface HttpResourceRequest {
3418
3805
  transferCache?: {
3419
3806
  includeHeaders?: string[];
3420
3807
  } | boolean;
3808
+ /**
3809
+ * The timeout for the backend HTTP request in ms.
3810
+ */
3811
+ timeout?: number;
3421
3812
  }
3422
3813
  /**
3423
3814
  * Options for creating an `httpResource`.