API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 20th, 2018
70
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 62.74 KB | None | 0 0
raw download clone embed print report
  1. -- tools/public_api_guard/common/http.d.ts Golden file
  2. +++ tools/public_api_guard/common/http.d.ts Generated API
  3. @@ -8,72 +8,12 @@
  4.  
  5. /** @stable */
  6. export declare class HttpClient {
  7. constructor(handler: HttpHandler);
  8. - delete<T>(url: string, options?: {
  9. - headers?: HttpHeaders | {
  10. - [header: string]: string | string[];
  11. - };
  12. - observe?: 'body';
  13. - params?: HttpParams | {
  14. - [param: string]: string | string[];
  15. - };
  16. - reportProgress?: boolean;
  17. - responseType?: 'json';
  18. - withCredentials?: boolean;
  19. - }): Observable<T>;
  20. - delete(url: string, options?: {
  21. - headers?: HttpHeaders | {
  22. - [header: string]: string | string[];
  23. - };
  24. - observe?: 'body';
  25. - params?: HttpParams | {
  26. - [param: string]: string | string[];
  27. - };
  28. - reportProgress?: boolean;
  29. - responseType?: 'json';
  30. - withCredentials?: boolean;
  31. - }): Observable<Object>;
  32. delete(url: string, options: {
  33. headers?: HttpHeaders | {
  34. [header: string]: string | string[];
  35. };
  36. - observe?: 'body';
  37. - params?: HttpParams | {
  38. - [param: string]: string | string[];
  39. - };
  40. - reportProgress?: boolean;
  41. - responseType: 'arraybuffer';
  42. - withCredentials?: boolean;
  43. - }): Observable<ArrayBuffer>;
  44. - delete(url: string, options: {
  45. - headers?: HttpHeaders | {
  46. - [header: string]: string | string[];
  47. - };
  48. - observe?: 'body';
  49. - params?: HttpParams | {
  50. - [param: string]: string | string[];
  51. - };
  52. - reportProgress?: boolean;
  53. - responseType: 'blob';
  54. - withCredentials?: boolean;
  55. - }): Observable<Blob>;
  56. - delete(url: string, options: {
  57. - headers?: HttpHeaders | {
  58. - [header: string]: string | string[];
  59. - };
  60. - observe?: 'body';
  61. - params?: HttpParams | {
  62. - [param: string]: string | string[];
  63. - };
  64. - reportProgress?: boolean;
  65. - responseType: 'text';
  66. - withCredentials?: boolean;
  67. - }): Observable<string>;
  68. - delete(url: string, options: {
  69. - headers?: HttpHeaders | {
  70. - [header: string]: string | string[];
  71. - };
  72. observe: 'events';
  73. params?: HttpParams | {
  74. [param: string]: string | string[];
  75. };
  76. @@ -116,20 +56,8 @@
  77. reportProgress?: boolean;
  78. responseType?: 'json';
  79. withCredentials?: boolean;
  80. }): Observable<HttpEvent<Object>>;
  81. - delete<T>(url: string, options: {
  82. - headers?: HttpHeaders | {
  83. - [header: string]: string | string[];
  84. - };
  85. - observe: 'events';
  86. - params?: HttpParams | {
  87. - [param: string]: string | string[];
  88. - };
  89. - reportProgress?: boolean;
  90. - responseType?: 'json';
  91. - withCredentials?: boolean;
  92. - }): Observable<HttpEvent<T>>;
  93. delete(url: string, options: {
  94. headers?: HttpHeaders | {
  95. [header: string]: string | string[];
  96. };
  97. @@ -176,33 +104,45 @@
  98. reportProgress?: boolean;
  99. responseType?: 'json';
  100. withCredentials?: boolean;
  101. }): Observable<HttpResponse<Object>>;
  102. - delete<T>(url: string, options: {
  103. + delete(url: string, options: {
  104. headers?: HttpHeaders | {
  105. [header: string]: string | string[];
  106. };
  107. - observe: 'response';
  108. + observe?: 'body';
  109. params?: HttpParams | {
  110. [param: string]: string | string[];
  111. };
  112. reportProgress?: boolean;
  113. - responseType?: 'json';
  114. + responseType: 'arraybuffer';
  115. withCredentials?: boolean;
  116. - }): Observable<HttpResponse<T>>;
  117. - get(url: string, options: {
  118. + }): Observable<ArrayBuffer>;
  119. + delete(url: string, options: {
  120. headers?: HttpHeaders | {
  121. [header: string]: string | string[];
  122. };
  123. - observe: 'events';
  124. + observe?: 'body';
  125. params?: HttpParams | {
  126. [param: string]: string | string[];
  127. };
  128. reportProgress?: boolean;
  129. + responseType: 'blob';
  130. + withCredentials?: boolean;
  131. + }): Observable<Blob>;
  132. + delete(url: string, options: {
  133. + headers?: HttpHeaders | {
  134. + [header: string]: string | string[];
  135. + };
  136. + observe?: 'body';
  137. + params?: HttpParams | {
  138. + [param: string]: string | string[];
  139. + };
  140. + reportProgress?: boolean;
  141. responseType: 'text';
  142. withCredentials?: boolean;
  143. - }): Observable<HttpEvent<string>>;
  144. - get(url: string, options?: {
  145. + }): Observable<string>;
  146. + delete(url: string, options?: {
  147. headers?: HttpHeaders | {
  148. [header: string]: string | string[];
  149. };
  150. observe?: 'body';
  151. @@ -212,44 +152,44 @@
  152. reportProgress?: boolean;
  153. responseType?: 'json';
  154. withCredentials?: boolean;
  155. }): Observable<Object>;
  156. - get(url: string, options: {
  157. + delete<T>(url: string, options: {
  158. headers?: HttpHeaders | {
  159. [header: string]: string | string[];
  160. };
  161. - observe?: 'body';
  162. + observe: 'events';
  163. params?: HttpParams | {
  164. [param: string]: string | string[];
  165. };
  166. reportProgress?: boolean;
  167. - responseType: 'arraybuffer';
  168. + responseType?: 'json';
  169. withCredentials?: boolean;
  170. - }): Observable<ArrayBuffer>;
  171. - get(url: string, options: {
  172. + }): Observable<HttpEvent<T>>;
  173. + delete<T>(url: string, options: {
  174. headers?: HttpHeaders | {
  175. [header: string]: string | string[];
  176. };
  177. - observe?: 'body';
  178. + observe: 'response';
  179. params?: HttpParams | {
  180. [param: string]: string | string[];
  181. };
  182. reportProgress?: boolean;
  183. - responseType: 'blob';
  184. + responseType?: 'json';
  185. withCredentials?: boolean;
  186. - }): Observable<Blob>;
  187. - get(url: string, options: {
  188. + }): Observable<HttpResponse<T>>;
  189. + delete<T>(url: string, options?: {
  190. headers?: HttpHeaders | {
  191. [header: string]: string | string[];
  192. };
  193. observe?: 'body';
  194. params?: HttpParams | {
  195. [param: string]: string | string[];
  196. };
  197. reportProgress?: boolean;
  198. - responseType: 'text';
  199. + responseType?: 'json';
  200. withCredentials?: boolean;
  201. - }): Observable<string>;
  202. + }): Observable<T>;
  203. get(url: string, options: {
  204. headers?: HttpHeaders | {
  205. [header: string]: string | string[];
  206. };
  207. @@ -272,20 +212,20 @@
  208. reportProgress?: boolean;
  209. responseType: 'blob';
  210. withCredentials?: boolean;
  211. }): Observable<HttpEvent<Blob>>;
  212. - get<T>(url: string, options?: {
  213. + get(url: string, options: {
  214. headers?: HttpHeaders | {
  215. [header: string]: string | string[];
  216. };
  217. - observe?: 'body';
  218. + observe: 'events';
  219. params?: HttpParams | {
  220. [param: string]: string | string[];
  221. };
  222. reportProgress?: boolean;
  223. - responseType?: 'json';
  224. + responseType: 'text';
  225. withCredentials?: boolean;
  226. - }): Observable<T>;
  227. + }): Observable<HttpEvent<string>>;
  228. get(url: string, options: {
  229. headers?: HttpHeaders | {
  230. [header: string]: string | string[];
  231. };
  232. @@ -296,20 +236,8 @@
  233. reportProgress?: boolean;
  234. responseType?: 'json';
  235. withCredentials?: boolean;
  236. }): Observable<HttpEvent<Object>>;
  237. - get<T>(url: string, options: {
  238. - headers?: HttpHeaders | {
  239. - [header: string]: string | string[];
  240. - };
  241. - observe: 'events';
  242. - params?: HttpParams | {
  243. - [param: string]: string | string[];
  244. - };
  245. - reportProgress?: boolean;
  246. - responseType?: 'json';
  247. - withCredentials?: boolean;
  248. - }): Observable<HttpEvent<T>>;
  249. get(url: string, options: {
  250. headers?: HttpHeaders | {
  251. [header: string]: string | string[];
  252. };
  253. @@ -356,57 +284,69 @@
  254. reportProgress?: boolean;
  255. responseType?: 'json';
  256. withCredentials?: boolean;
  257. }): Observable<HttpResponse<Object>>;
  258. - get<T>(url: string, options: {
  259. + get(url: string, options: {
  260. headers?: HttpHeaders | {
  261. [header: string]: string | string[];
  262. };
  263. - observe: 'response';
  264. + observe?: 'body';
  265. params?: HttpParams | {
  266. [param: string]: string | string[];
  267. };
  268. reportProgress?: boolean;
  269. - responseType?: 'json';
  270. + responseType: 'arraybuffer';
  271. withCredentials?: boolean;
  272. - }): Observable<HttpResponse<T>>;
  273. - head<T>(url: string, options?: {
  274. + }): Observable<ArrayBuffer>;
  275. + get(url: string, options: {
  276. headers?: HttpHeaders | {
  277. [header: string]: string | string[];
  278. };
  279. observe?: 'body';
  280. params?: HttpParams | {
  281. [param: string]: string | string[];
  282. };
  283. reportProgress?: boolean;
  284. - responseType?: 'json';
  285. + responseType: 'blob';
  286. withCredentials?: boolean;
  287. - }): Observable<T>;
  288. - head(url: string, options?: {
  289. + }): Observable<Blob>;
  290. + get(url: string, options: {
  291. headers?: HttpHeaders | {
  292. [header: string]: string | string[];
  293. };
  294. observe?: 'body';
  295. params?: HttpParams | {
  296. [param: string]: string | string[];
  297. };
  298. reportProgress?: boolean;
  299. + responseType: 'text';
  300. + withCredentials?: boolean;
  301. + }): Observable<string>;
  302. + get(url: string, options?: {
  303. + headers?: HttpHeaders | {
  304. + [header: string]: string | string[];
  305. + };
  306. + observe?: 'body';
  307. + params?: HttpParams | {
  308. + [param: string]: string | string[];
  309. + };
  310. + reportProgress?: boolean;
  311. responseType?: 'json';
  312. withCredentials?: boolean;
  313. }): Observable<Object>;
  314. - head<T>(url: string, options: {
  315. + get<T>(url: string, options: {
  316. headers?: HttpHeaders | {
  317. [header: string]: string | string[];
  318. };
  319. - observe: 'response';
  320. + observe: 'events';
  321. params?: HttpParams | {
  322. [param: string]: string | string[];
  323. };
  324. reportProgress?: boolean;
  325. responseType?: 'json';
  326. withCredentials?: boolean;
  327. - }): Observable<HttpResponse<T>>;
  328. - head(url: string, options: {
  329. + }): Observable<HttpEvent<T>>;
  330. + get<T>(url: string, options: {
  331. headers?: HttpHeaders | {
  332. [header: string]: string | string[];
  333. };
  334. observe: 'response';
  335. @@ -415,57 +355,57 @@
  336. };
  337. reportProgress?: boolean;
  338. responseType?: 'json';
  339. withCredentials?: boolean;
  340. - }): Observable<HttpResponse<Object>>;
  341. - head(url: string, options: {
  342. + }): Observable<HttpResponse<T>>;
  343. + get<T>(url: string, options?: {
  344. headers?: HttpHeaders | {
  345. [header: string]: string | string[];
  346. };
  347. - observe: 'response';
  348. + observe?: 'body';
  349. params?: HttpParams | {
  350. [param: string]: string | string[];
  351. };
  352. reportProgress?: boolean;
  353. - responseType: 'text';
  354. + responseType?: 'json';
  355. withCredentials?: boolean;
  356. - }): Observable<HttpResponse<string>>;
  357. + }): Observable<T>;
  358. head(url: string, options: {
  359. headers?: HttpHeaders | {
  360. [header: string]: string | string[];
  361. };
  362. - observe: 'response';
  363. + observe: 'events';
  364. params?: HttpParams | {
  365. [param: string]: string | string[];
  366. };
  367. reportProgress?: boolean;
  368. - responseType: 'blob';
  369. + responseType: 'arraybuffer';
  370. withCredentials?: boolean;
  371. - }): Observable<HttpResponse<Blob>>;
  372. + }): Observable<HttpEvent<ArrayBuffer>>;
  373. head(url: string, options: {
  374. headers?: HttpHeaders | {
  375. [header: string]: string | string[];
  376. };
  377. - observe: 'response';
  378. + observe: 'events';
  379. params?: HttpParams | {
  380. [param: string]: string | string[];
  381. };
  382. reportProgress?: boolean;
  383. - responseType: 'arraybuffer';
  384. + responseType: 'blob';
  385. withCredentials?: boolean;
  386. - }): Observable<HttpResponse<ArrayBuffer>>;
  387. - head<T>(url: string, options: {
  388. + }): Observable<HttpEvent<Blob>>;
  389. + head(url: string, options: {
  390. headers?: HttpHeaders | {
  391. [header: string]: string | string[];
  392. };
  393. observe: 'events';
  394. params?: HttpParams | {
  395. [param: string]: string | string[];
  396. };
  397. reportProgress?: boolean;
  398. - responseType?: 'json';
  399. + responseType: 'text';
  400. withCredentials?: boolean;
  401. - }): Observable<HttpEvent<T>>;
  402. + }): Observable<HttpEvent<string>>;
  403. head(url: string, options: {
  404. headers?: HttpHeaders | {
  405. [header: string]: string | string[];
  406. };
  407. @@ -480,52 +420,64 @@
  408. head(url: string, options: {
  409. headers?: HttpHeaders | {
  410. [header: string]: string | string[];
  411. };
  412. - observe: 'events';
  413. + observe: 'response';
  414. params?: HttpParams | {
  415. [param: string]: string | string[];
  416. };
  417. reportProgress?: boolean;
  418. - responseType: 'text';
  419. + responseType: 'arraybuffer';
  420. withCredentials?: boolean;
  421. - }): Observable<HttpEvent<string>>;
  422. + }): Observable<HttpResponse<ArrayBuffer>>;
  423. head(url: string, options: {
  424. headers?: HttpHeaders | {
  425. [header: string]: string | string[];
  426. };
  427. - observe: 'events';
  428. + observe: 'response';
  429. params?: HttpParams | {
  430. [param: string]: string | string[];
  431. };
  432. reportProgress?: boolean;
  433. responseType: 'blob';
  434. withCredentials?: boolean;
  435. - }): Observable<HttpEvent<Blob>>;
  436. + }): Observable<HttpResponse<Blob>>;
  437. head(url: string, options: {
  438. headers?: HttpHeaders | {
  439. [header: string]: string | string[];
  440. };
  441. - observe: 'events';
  442. + observe: 'response';
  443. params?: HttpParams | {
  444. [param: string]: string | string[];
  445. };
  446. reportProgress?: boolean;
  447. - responseType: 'arraybuffer';
  448. + responseType: 'text';
  449. withCredentials?: boolean;
  450. - }): Observable<HttpEvent<ArrayBuffer>>;
  451. + }): Observable<HttpResponse<string>>;
  452. head(url: string, options: {
  453. headers?: HttpHeaders | {
  454. [header: string]: string | string[];
  455. };
  456. + observe: 'response';
  457. + params?: HttpParams | {
  458. + [param: string]: string | string[];
  459. + };
  460. + reportProgress?: boolean;
  461. + responseType?: 'json';
  462. + withCredentials?: boolean;
  463. + }): Observable<HttpResponse<Object>>;
  464. + head(url: string, options: {
  465. + headers?: HttpHeaders | {
  466. + [header: string]: string | string[];
  467. + };
  468. observe?: 'body';
  469. params?: HttpParams | {
  470. [param: string]: string | string[];
  471. };
  472. reportProgress?: boolean;
  473. - responseType: 'text';
  474. + responseType: 'arraybuffer';
  475. withCredentials?: boolean;
  476. - }): Observable<string>;
  477. + }): Observable<ArrayBuffer>;
  478. head(url: string, options: {
  479. headers?: HttpHeaders | {
  480. [header: string]: string | string[];
  481. };
  482. @@ -545,61 +497,61 @@
  483. params?: HttpParams | {
  484. [param: string]: string | string[];
  485. };
  486. reportProgress?: boolean;
  487. - responseType: 'arraybuffer';
  488. + responseType: 'text';
  489. withCredentials?: boolean;
  490. - }): Observable<ArrayBuffer>;
  491. - jsonp<T>(url: string, callbackParam: string): Observable<T>;
  492. - jsonp(url: string, callbackParam: string): Observable<Object>;
  493. - options(url: string, options: {
  494. + }): Observable<string>;
  495. + head(url: string, options?: {
  496. headers?: HttpHeaders | {
  497. [header: string]: string | string[];
  498. };
  499. - observe: 'events';
  500. + observe?: 'body';
  501. params?: HttpParams | {
  502. [param: string]: string | string[];
  503. };
  504. reportProgress?: boolean;
  505. responseType?: 'json';
  506. withCredentials?: boolean;
  507. - }): Observable<HttpEvent<Object>>;
  508. - options(url: string, options: {
  509. + }): Observable<Object>;
  510. + head<T>(url: string, options: {
  511. headers?: HttpHeaders | {
  512. [header: string]: string | string[];
  513. };
  514. - observe?: 'body';
  515. + observe: 'events';
  516. params?: HttpParams | {
  517. [param: string]: string | string[];
  518. };
  519. reportProgress?: boolean;
  520. - responseType: 'arraybuffer';
  521. + responseType?: 'json';
  522. withCredentials?: boolean;
  523. - }): Observable<ArrayBuffer>;
  524. - options(url: string, options: {
  525. + }): Observable<HttpEvent<T>>;
  526. + head<T>(url: string, options: {
  527. headers?: HttpHeaders | {
  528. [header: string]: string | string[];
  529. };
  530. - observe?: 'body';
  531. + observe: 'response';
  532. params?: HttpParams | {
  533. [param: string]: string | string[];
  534. };
  535. reportProgress?: boolean;
  536. - responseType: 'blob';
  537. + responseType?: 'json';
  538. withCredentials?: boolean;
  539. - }): Observable<Blob>;
  540. - options(url: string, options: {
  541. + }): Observable<HttpResponse<T>>;
  542. + head<T>(url: string, options?: {
  543. headers?: HttpHeaders | {
  544. [header: string]: string | string[];
  545. };
  546. observe?: 'body';
  547. params?: HttpParams | {
  548. [param: string]: string | string[];
  549. };
  550. reportProgress?: boolean;
  551. - responseType: 'text';
  552. + responseType?: 'json';
  553. withCredentials?: boolean;
  554. - }): Observable<string>;
  555. + }): Observable<T>;
  556. + jsonp(url: string, callbackParam: string): Observable<Object>;
  557. + jsonp<T>(url: string, callbackParam: string): Observable<T>;
  558. options(url: string, options: {
  559. headers?: HttpHeaders | {
  560. [header: string]: string | string[];
  561. };
  562. @@ -634,32 +586,20 @@
  563. reportProgress?: boolean;
  564. responseType: 'text';
  565. withCredentials?: boolean;
  566. }): Observable<HttpEvent<string>>;
  567. - options<T>(url: string, options?: {
  568. + options(url: string, options: {
  569. headers?: HttpHeaders | {
  570. [header: string]: string | string[];
  571. };
  572. - observe?: 'body';
  573. - params?: HttpParams | {
  574. - [param: string]: string | string[];
  575. - };
  576. - reportProgress?: boolean;
  577. - responseType?: 'json';
  578. - withCredentials?: boolean;
  579. - }): Observable<T>;
  580. - options<T>(url: string, options: {
  581. - headers?: HttpHeaders | {
  582. - [header: string]: string | string[];
  583. - };
  584. observe: 'events';
  585. params?: HttpParams | {
  586. [param: string]: string | string[];
  587. };
  588. reportProgress?: boolean;
  589. responseType?: 'json';
  590. withCredentials?: boolean;
  591. - }): Observable<HttpEvent<T>>;
  592. + }): Observable<HttpEvent<Object>>;
  593. options(url: string, options: {
  594. headers?: HttpHeaders | {
  595. [header: string]: string | string[];
  596. };
  597. @@ -706,92 +646,92 @@
  598. reportProgress?: boolean;
  599. responseType?: 'json';
  600. withCredentials?: boolean;
  601. }): Observable<HttpResponse<Object>>;
  602. - options<T>(url: string, options: {
  603. + options(url: string, options: {
  604. headers?: HttpHeaders | {
  605. [header: string]: string | string[];
  606. };
  607. - observe: 'response';
  608. + observe?: 'body';
  609. params?: HttpParams | {
  610. [param: string]: string | string[];
  611. };
  612. reportProgress?: boolean;
  613. - responseType?: 'json';
  614. + responseType: 'arraybuffer';
  615. withCredentials?: boolean;
  616. - }): Observable<HttpResponse<T>>;
  617. - options(url: string, options?: {
  618. + }): Observable<ArrayBuffer>;
  619. + options(url: string, options: {
  620. headers?: HttpHeaders | {
  621. [header: string]: string | string[];
  622. };
  623. observe?: 'body';
  624. params?: HttpParams | {
  625. [param: string]: string | string[];
  626. };
  627. reportProgress?: boolean;
  628. - responseType?: 'json';
  629. + responseType: 'blob';
  630. withCredentials?: boolean;
  631. - }): Observable<Object>;
  632. - patch(url: string, body: any | null, options: {
  633. + }): Observable<Blob>;
  634. + options(url: string, options: {
  635. headers?: HttpHeaders | {
  636. [header: string]: string | string[];
  637. };
  638. - observe: 'events';
  639. + observe?: 'body';
  640. params?: HttpParams | {
  641. [param: string]: string | string[];
  642. };
  643. reportProgress?: boolean;
  644. - responseType: 'blob';
  645. + responseType: 'text';
  646. withCredentials?: boolean;
  647. - }): Observable<HttpEvent<Blob>>;
  648. - patch(url: string, body: any | null, options: {
  649. + }): Observable<string>;
  650. + options(url: string, options?: {
  651. headers?: HttpHeaders | {
  652. [header: string]: string | string[];
  653. };
  654. - observe: 'events';
  655. + observe?: 'body';
  656. params?: HttpParams | {
  657. [param: string]: string | string[];
  658. };
  659. reportProgress?: boolean;
  660. - responseType: 'text';
  661. + responseType?: 'json';
  662. withCredentials?: boolean;
  663. - }): Observable<HttpEvent<string>>;
  664. - patch(url: string, body: any | null, options: {
  665. + }): Observable<Object>;
  666. + options<T>(url: string, options: {
  667. headers?: HttpHeaders | {
  668. [header: string]: string | string[];
  669. };
  670. - observe?: 'body';
  671. + observe: 'events';
  672. params?: HttpParams | {
  673. [param: string]: string | string[];
  674. };
  675. reportProgress?: boolean;
  676. - responseType: 'arraybuffer';
  677. + responseType?: 'json';
  678. withCredentials?: boolean;
  679. - }): Observable<ArrayBuffer>;
  680. - patch(url: string, body: any | null, options: {
  681. + }): Observable<HttpEvent<T>>;
  682. + options<T>(url: string, options: {
  683. headers?: HttpHeaders | {
  684. [header: string]: string | string[];
  685. };
  686. - observe?: 'body';
  687. + observe: 'response';
  688. params?: HttpParams | {
  689. [param: string]: string | string[];
  690. };
  691. reportProgress?: boolean;
  692. - responseType: 'blob';
  693. + responseType?: 'json';
  694. withCredentials?: boolean;
  695. - }): Observable<Blob>;
  696. - patch(url: string, body: any | null, options: {
  697. + }): Observable<HttpResponse<T>>;
  698. + options<T>(url: string, options?: {
  699. headers?: HttpHeaders | {
  700. [header: string]: string | string[];
  701. };
  702. observe?: 'body';
  703. params?: HttpParams | {
  704. [param: string]: string | string[];
  705. };
  706. reportProgress?: boolean;
  707. - responseType: 'text';
  708. + responseType?: 'json';
  709. withCredentials?: boolean;
  710. - }): Observable<string>;
  711. + }): Observable<T>;
  712. patch(url: string, body: any | null, options: {
  713. headers?: HttpHeaders | {
  714. [header: string]: string | string[];
  715. };
  716. @@ -802,32 +742,32 @@
  717. reportProgress?: boolean;
  718. responseType: 'arraybuffer';
  719. withCredentials?: boolean;
  720. }): Observable<HttpEvent<ArrayBuffer>>;
  721. - patch<T>(url: string, body: any | null, options?: {
  722. + patch(url: string, body: any | null, options: {
  723. headers?: HttpHeaders | {
  724. [header: string]: string | string[];
  725. };
  726. - observe?: 'body';
  727. + observe: 'events';
  728. params?: HttpParams | {
  729. [param: string]: string | string[];
  730. };
  731. reportProgress?: boolean;
  732. - responseType?: 'json';
  733. + responseType: 'blob';
  734. withCredentials?: boolean;
  735. - }): Observable<T>;
  736. - patch(url: string, body: any | null, options?: {
  737. + }): Observable<HttpEvent<Blob>>;
  738. + patch(url: string, body: any | null, options: {
  739. headers?: HttpHeaders | {
  740. [header: string]: string | string[];
  741. };
  742. - observe?: 'body';
  743. + observe: 'events';
  744. params?: HttpParams | {
  745. [param: string]: string | string[];
  746. };
  747. reportProgress?: boolean;
  748. - responseType?: 'json';
  749. + responseType: 'text';
  750. withCredentials?: boolean;
  751. - }): Observable<Object>;
  752. + }): Observable<HttpEvent<string>>;
  753. patch(url: string, body: any | null, options: {
  754. headers?: HttpHeaders | {
  755. [header: string]: string | string[];
  756. };
  757. @@ -838,20 +778,8 @@
  758. reportProgress?: boolean;
  759. responseType?: 'json';
  760. withCredentials?: boolean;
  761. }): Observable<HttpEvent<Object>>;
  762. - patch<T>(url: string, body: any | null, options: {
  763. - headers?: HttpHeaders | {
  764. - [header: string]: string | string[];
  765. - };
  766. - observe: 'events';
  767. - params?: HttpParams | {
  768. - [param: string]: string | string[];
  769. - };
  770. - reportProgress?: boolean;
  771. - responseType?: 'json';
  772. - withCredentials?: boolean;
  773. - }): Observable<HttpEvent<T>>;
  774. patch(url: string, body: any | null, options: {
  775. headers?: HttpHeaders | {
  776. [header: string]: string | string[];
  777. };
  778. @@ -898,33 +826,45 @@
  779. reportProgress?: boolean;
  780. responseType?: 'json';
  781. withCredentials?: boolean;
  782. }): Observable<HttpResponse<Object>>;
  783. - patch<T>(url: string, body: any | null, options: {
  784. + patch(url: string, body: any | null, options: {
  785. headers?: HttpHeaders | {
  786. [header: string]: string | string[];
  787. };
  788. - observe: 'response';
  789. + observe?: 'body';
  790. params?: HttpParams | {
  791. [param: string]: string | string[];
  792. };
  793. reportProgress?: boolean;
  794. - responseType?: 'json';
  795. + responseType: 'arraybuffer';
  796. withCredentials?: boolean;
  797. - }): Observable<HttpResponse<T>>;
  798. - post(url: string, body: any | null, options: {
  799. + }): Observable<ArrayBuffer>;
  800. + patch(url: string, body: any | null, options: {
  801. headers?: HttpHeaders | {
  802. [header: string]: string | string[];
  803. };
  804. - observe: 'events';
  805. + observe?: 'body';
  806. params?: HttpParams | {
  807. [param: string]: string | string[];
  808. };
  809. reportProgress?: boolean;
  810. + responseType: 'blob';
  811. + withCredentials?: boolean;
  812. + }): Observable<Blob>;
  813. + patch(url: string, body: any | null, options: {
  814. + headers?: HttpHeaders | {
  815. + [header: string]: string | string[];
  816. + };
  817. + observe?: 'body';
  818. + params?: HttpParams | {
  819. + [param: string]: string | string[];
  820. + };
  821. + reportProgress?: boolean;
  822. responseType: 'text';
  823. withCredentials?: boolean;
  824. - }): Observable<HttpEvent<string>>;
  825. - post(url: string, body: any | null, options?: {
  826. + }): Observable<string>;
  827. + patch(url: string, body: any | null, options?: {
  828. headers?: HttpHeaders | {
  829. [header: string]: string | string[];
  830. };
  831. observe?: 'body';
  832. @@ -934,44 +874,44 @@
  833. reportProgress?: boolean;
  834. responseType?: 'json';
  835. withCredentials?: boolean;
  836. }): Observable<Object>;
  837. - post(url: string, body: any | null, options: {
  838. + patch<T>(url: string, body: any | null, options: {
  839. headers?: HttpHeaders | {
  840. [header: string]: string | string[];
  841. };
  842. - observe?: 'body';
  843. + observe: 'events';
  844. params?: HttpParams | {
  845. [param: string]: string | string[];
  846. };
  847. reportProgress?: boolean;
  848. - responseType: 'arraybuffer';
  849. + responseType?: 'json';
  850. withCredentials?: boolean;
  851. - }): Observable<ArrayBuffer>;
  852. - post(url: string, body: any | null, options: {
  853. + }): Observable<HttpEvent<T>>;
  854. + patch<T>(url: string, body: any | null, options: {
  855. headers?: HttpHeaders | {
  856. [header: string]: string | string[];
  857. };
  858. - observe?: 'body';
  859. + observe: 'response';
  860. params?: HttpParams | {
  861. [param: string]: string | string[];
  862. };
  863. reportProgress?: boolean;
  864. - responseType: 'blob';
  865. + responseType?: 'json';
  866. withCredentials?: boolean;
  867. - }): Observable<Blob>;
  868. - post(url: string, body: any | null, options: {
  869. + }): Observable<HttpResponse<T>>;
  870. + patch<T>(url: string, body: any | null, options?: {
  871. headers?: HttpHeaders | {
  872. [header: string]: string | string[];
  873. };
  874. observe?: 'body';
  875. params?: HttpParams | {
  876. [param: string]: string | string[];
  877. };
  878. reportProgress?: boolean;
  879. - responseType: 'text';
  880. + responseType?: 'json';
  881. withCredentials?: boolean;
  882. - }): Observable<string>;
  883. + }): Observable<T>;
  884. post(url: string, body: any | null, options: {
  885. headers?: HttpHeaders | {
  886. [header: string]: string | string[];
  887. };
  888. @@ -994,20 +934,20 @@
  889. reportProgress?: boolean;
  890. responseType: 'blob';
  891. withCredentials?: boolean;
  892. }): Observable<HttpEvent<Blob>>;
  893. - post<T>(url: string, body: any | null, options?: {
  894. + post(url: string, body: any | null, options: {
  895. headers?: HttpHeaders | {
  896. [header: string]: string | string[];
  897. };
  898. - observe?: 'body';
  899. + observe: 'events';
  900. params?: HttpParams | {
  901. [param: string]: string | string[];
  902. };
  903. reportProgress?: boolean;
  904. - responseType?: 'json';
  905. + responseType: 'text';
  906. withCredentials?: boolean;
  907. - }): Observable<T>;
  908. + }): Observable<HttpEvent<string>>;
  909. post(url: string, body: any | null, options: {
  910. headers?: HttpHeaders | {
  911. [header: string]: string | string[];
  912. };
  913. @@ -1018,20 +958,8 @@
  914. reportProgress?: boolean;
  915. responseType?: 'json';
  916. withCredentials?: boolean;
  917. }): Observable<HttpEvent<Object>>;
  918. - post<T>(url: string, body: any | null, options: {
  919. - headers?: HttpHeaders | {
  920. - [header: string]: string | string[];
  921. - };
  922. - observe: 'events';
  923. - params?: HttpParams | {
  924. - [param: string]: string | string[];
  925. - };
  926. - reportProgress?: boolean;
  927. - responseType?: 'json';
  928. - withCredentials?: boolean;
  929. - }): Observable<HttpEvent<T>>;
  930. post(url: string, body: any | null, options: {
  931. headers?: HttpHeaders | {
  932. [header: string]: string | string[];
  933. };
  934. @@ -1078,45 +1006,69 @@
  935. reportProgress?: boolean;
  936. responseType?: 'json';
  937. withCredentials?: boolean;
  938. }): Observable<HttpResponse<Object>>;
  939. - post<T>(url: string, body: any | null, options: {
  940. + post(url: string, body: any | null, options: {
  941. headers?: HttpHeaders | {
  942. [header: string]: string | string[];
  943. };
  944. - observe: 'response';
  945. + observe?: 'body';
  946. params?: HttpParams | {
  947. [param: string]: string | string[];
  948. };
  949. reportProgress?: boolean;
  950. - responseType?: 'json';
  951. + responseType: 'arraybuffer';
  952. withCredentials?: boolean;
  953. - }): Observable<HttpResponse<T>>;
  954. - put(url: string, body: any | null, options?: {
  955. + }): Observable<ArrayBuffer>;
  956. + post(url: string, body: any | null, options: {
  957. headers?: HttpHeaders | {
  958. [header: string]: string | string[];
  959. };
  960. observe?: 'body';
  961. params?: HttpParams | {
  962. [param: string]: string | string[];
  963. };
  964. reportProgress?: boolean;
  965. + responseType: 'blob';
  966. + withCredentials?: boolean;
  967. + }): Observable<Blob>;
  968. + post(url: string, body: any | null, options: {
  969. + headers?: HttpHeaders | {
  970. + [header: string]: string | string[];
  971. + };
  972. + observe?: 'body';
  973. + params?: HttpParams | {
  974. + [param: string]: string | string[];
  975. + };
  976. + reportProgress?: boolean;
  977. + responseType: 'text';
  978. + withCredentials?: boolean;
  979. + }): Observable<string>;
  980. + post(url: string, body: any | null, options?: {
  981. + headers?: HttpHeaders | {
  982. + [header: string]: string | string[];
  983. + };
  984. + observe?: 'body';
  985. + params?: HttpParams | {
  986. + [param: string]: string | string[];
  987. + };
  988. + reportProgress?: boolean;
  989. responseType?: 'json';
  990. withCredentials?: boolean;
  991. }): Observable<Object>;
  992. - put<T>(url: string, body: any | null, options: {
  993. + post<T>(url: string, body: any | null, options: {
  994. headers?: HttpHeaders | {
  995. [header: string]: string | string[];
  996. };
  997. - observe: 'response';
  998. + observe: 'events';
  999. params?: HttpParams | {
  1000. [param: string]: string | string[];
  1001. };
  1002. reportProgress?: boolean;
  1003. responseType?: 'json';
  1004. withCredentials?: boolean;
  1005. - }): Observable<HttpResponse<T>>;
  1006. - put(url: string, body: any | null, options: {
  1007. + }): Observable<HttpEvent<T>>;
  1008. + post<T>(url: string, body: any | null, options: {
  1009. headers?: HttpHeaders | {
  1010. [header: string]: string | string[];
  1011. };
  1012. observe: 'response';
  1013. @@ -1125,53 +1077,57 @@
  1014. };
  1015. reportProgress?: boolean;
  1016. responseType?: 'json';
  1017. withCredentials?: boolean;
  1018. - }): Observable<HttpResponse<Object>>;
  1019. - put(url: string, body: any | null, options: {
  1020. + }): Observable<HttpResponse<T>>;
  1021. + post<T>(url: string, body: any | null, options?: {
  1022. headers?: HttpHeaders | {
  1023. [header: string]: string | string[];
  1024. };
  1025. - observe: 'response';
  1026. + observe?: 'body';
  1027. params?: HttpParams | {
  1028. [param: string]: string | string[];
  1029. };
  1030. reportProgress?: boolean;
  1031. - responseType: 'text';
  1032. + responseType?: 'json';
  1033. withCredentials?: boolean;
  1034. - }): Observable<HttpResponse<string>>;
  1035. + }): Observable<T>;
  1036. put(url: string, body: any | null, options: {
  1037. headers?: HttpHeaders | {
  1038. [header: string]: string | string[];
  1039. };
  1040. - observe: 'response';
  1041. + observe: 'events';
  1042. params?: HttpParams | {
  1043. [param: string]: string | string[];
  1044. };
  1045. reportProgress?: boolean;
  1046. - responseType: 'blob';
  1047. + responseType: 'arraybuffer';
  1048. withCredentials?: boolean;
  1049. - }): Observable<HttpResponse<Blob>>;
  1050. + }): Observable<HttpEvent<ArrayBuffer>>;
  1051. put(url: string, body: any | null, options: {
  1052. headers?: HttpHeaders | {
  1053. [header: string]: string | string[];
  1054. };
  1055. - observe: 'response';
  1056. + observe: 'events';
  1057. params?: HttpParams | {
  1058. [param: string]: string | string[];
  1059. };
  1060. reportProgress?: boolean;
  1061. - responseType: 'arraybuffer';
  1062. + responseType: 'blob';
  1063. withCredentials?: boolean;
  1064. - }): Observable<HttpResponse<ArrayBuffer>>;
  1065. - put<T>(url: string, body: any | null, options: {
  1066. + }): Observable<HttpEvent<Blob>>;
  1067. + put(url: string, body: any | null, options: {
  1068. headers?: HttpHeaders | {
  1069. [header: string]: string | string[];
  1070. };
  1071. observe: 'events';
  1072. - responseType?: 'json';
  1073. + params?: HttpParams | {
  1074. + [param: string]: string | string[];
  1075. + };
  1076. + reportProgress?: boolean;
  1077. + responseType: 'text';
  1078. withCredentials?: boolean;
  1079. - }): Observable<HttpEvent<T>>;
  1080. + }): Observable<HttpEvent<string>>;
  1081. put(url: string, body: any | null, options: {
  1082. headers?: HttpHeaders | {
  1083. [header: string]: string | string[];
  1084. };
  1085. @@ -1186,52 +1142,64 @@
  1086. put(url: string, body: any | null, options: {
  1087. headers?: HttpHeaders | {
  1088. [header: string]: string | string[];
  1089. };
  1090. - observe: 'events';
  1091. + observe: 'response';
  1092. params?: HttpParams | {
  1093. [param: string]: string | string[];
  1094. };
  1095. reportProgress?: boolean;
  1096. - responseType: 'text';
  1097. + responseType: 'arraybuffer';
  1098. withCredentials?: boolean;
  1099. - }): Observable<HttpEvent<string>>;
  1100. + }): Observable<HttpResponse<ArrayBuffer>>;
  1101. put(url: string, body: any | null, options: {
  1102. headers?: HttpHeaders | {
  1103. [header: string]: string | string[];
  1104. };
  1105. - observe: 'events';
  1106. + observe: 'response';
  1107. params?: HttpParams | {
  1108. [param: string]: string | string[];
  1109. };
  1110. reportProgress?: boolean;
  1111. responseType: 'blob';
  1112. withCredentials?: boolean;
  1113. - }): Observable<HttpEvent<Blob>>;
  1114. + }): Observable<HttpResponse<Blob>>;
  1115. put(url: string, body: any | null, options: {
  1116. headers?: HttpHeaders | {
  1117. [header: string]: string | string[];
  1118. };
  1119. - observe: 'events';
  1120. + observe: 'response';
  1121. params?: HttpParams | {
  1122. [param: string]: string | string[];
  1123. };
  1124. reportProgress?: boolean;
  1125. - responseType: 'arraybuffer';
  1126. + responseType: 'text';
  1127. withCredentials?: boolean;
  1128. - }): Observable<HttpEvent<ArrayBuffer>>;
  1129. + }): Observable<HttpResponse<string>>;
  1130. put(url: string, body: any | null, options: {
  1131. headers?: HttpHeaders | {
  1132. [header: string]: string | string[];
  1133. };
  1134. + observe: 'response';
  1135. + params?: HttpParams | {
  1136. + [param: string]: string | string[];
  1137. + };
  1138. + reportProgress?: boolean;
  1139. + responseType?: 'json';
  1140. + withCredentials?: boolean;
  1141. + }): Observable<HttpResponse<Object>>;
  1142. + put(url: string, body: any | null, options: {
  1143. + headers?: HttpHeaders | {
  1144. + [header: string]: string | string[];
  1145. + };
  1146. observe?: 'body';
  1147. params?: HttpParams | {
  1148. [param: string]: string | string[];
  1149. };
  1150. reportProgress?: boolean;
  1151. - responseType: 'text';
  1152. + responseType: 'arraybuffer';
  1153. withCredentials?: boolean;
  1154. - }): Observable<string>;
  1155. + }): Observable<ArrayBuffer>;
  1156. put(url: string, body: any | null, options: {
  1157. headers?: HttpHeaders | {
  1158. [header: string]: string | string[];
  1159. };
  1160. @@ -1251,12 +1219,12 @@
  1161. params?: HttpParams | {
  1162. [param: string]: string | string[];
  1163. };
  1164. reportProgress?: boolean;
  1165. - responseType: 'arraybuffer';
  1166. + responseType: 'text';
  1167. withCredentials?: boolean;
  1168. - }): Observable<ArrayBuffer>;
  1169. - put<T>(url: string, body: any | null, options?: {
  1170. + }): Observable<string>;
  1171. + put(url: string, body: any | null, options?: {
  1172. headers?: HttpHeaders | {
  1173. [header: string]: string | string[];
  1174. };
  1175. observe?: 'body';
  1176. @@ -1265,180 +1233,172 @@
  1177. };
  1178. reportProgress?: boolean;
  1179. responseType?: 'json';
  1180. withCredentials?: boolean;
  1181. - }): Observable<T>;
  1182. - request(method: string, url: string, options: {
  1183. - body?: any;
  1184. + }): Observable<Object>;
  1185. + put<T>(url: string, body: any | null, options: {
  1186. headers?: HttpHeaders | {
  1187. [header: string]: string | string[];
  1188. };
  1189. - reportProgress?: boolean;
  1190. observe: 'events';
  1191. - params?: HttpParams | {
  1192. - [param: string]: string | string[];
  1193. - };
  1194. responseType?: 'json';
  1195. withCredentials?: boolean;
  1196. - }): Observable<HttpEvent<any>>;
  1197. - request<R>(method: string, url: string, options?: {
  1198. - body?: any;
  1199. + }): Observable<HttpEvent<T>>;
  1200. + put<T>(url: string, body: any | null, options: {
  1201. headers?: HttpHeaders | {
  1202. [header: string]: string | string[];
  1203. };
  1204. - observe?: 'body';
  1205. + observe: 'response';
  1206. params?: HttpParams | {
  1207. [param: string]: string | string[];
  1208. };
  1209. + reportProgress?: boolean;
  1210. responseType?: 'json';
  1211. - reportProgress?: boolean;
  1212. withCredentials?: boolean;
  1213. - }): Observable<R>;
  1214. - request(method: string, url: string, options: {
  1215. - body?: any;
  1216. + }): Observable<HttpResponse<T>>;
  1217. + put<T>(url: string, body: any | null, options?: {
  1218. headers?: HttpHeaders | {
  1219. [header: string]: string | string[];
  1220. };
  1221. observe?: 'body';
  1222. params?: HttpParams | {
  1223. [param: string]: string | string[];
  1224. };
  1225. reportProgress?: boolean;
  1226. - responseType: 'arraybuffer';
  1227. + responseType?: 'json';
  1228. withCredentials?: boolean;
  1229. - }): Observable<ArrayBuffer>;
  1230. + }): Observable<T>;
  1231. request(method: string, url: string, options: {
  1232. body?: any;
  1233. headers?: HttpHeaders | {
  1234. [header: string]: string | string[];
  1235. };
  1236. - observe?: 'body';
  1237. + observe: 'events';
  1238. params?: HttpParams | {
  1239. [param: string]: string | string[];
  1240. };
  1241. reportProgress?: boolean;
  1242. responseType: 'blob';
  1243. withCredentials?: boolean;
  1244. - }): Observable<Blob>;
  1245. + }): Observable<HttpEvent<Blob>>;
  1246. request(method: string, url: string, options: {
  1247. body?: any;
  1248. headers?: HttpHeaders | {
  1249. [header: string]: string | string[];
  1250. };
  1251. - observe?: 'body';
  1252. + observe: 'events';
  1253. params?: HttpParams | {
  1254. [param: string]: string | string[];
  1255. };
  1256. reportProgress?: boolean;
  1257. responseType: 'text';
  1258. withCredentials?: boolean;
  1259. - }): Observable<string>;
  1260. + }): Observable<HttpEvent<string>>;
  1261. request(method: string, url: string, options: {
  1262. body?: any;
  1263. headers?: HttpHeaders | {
  1264. [header: string]: string | string[];
  1265. };
  1266. + observe: 'response';
  1267. params?: HttpParams | {
  1268. [param: string]: string | string[];
  1269. };
  1270. - observe: 'events';
  1271. reportProgress?: boolean;
  1272. responseType: 'arraybuffer';
  1273. withCredentials?: boolean;
  1274. - }): Observable<HttpEvent<ArrayBuffer>>;
  1275. + }): Observable<HttpResponse<ArrayBuffer>>;
  1276. request(method: string, url: string, options: {
  1277. body?: any;
  1278. headers?: HttpHeaders | {
  1279. [header: string]: string | string[];
  1280. };
  1281. - observe: 'events';
  1282. + observe: 'response';
  1283. params?: HttpParams | {
  1284. [param: string]: string | string[];
  1285. };
  1286. reportProgress?: boolean;
  1287. responseType: 'blob';
  1288. withCredentials?: boolean;
  1289. - }): Observable<HttpEvent<Blob>>;
  1290. + }): Observable<HttpResponse<Blob>>;
  1291. request(method: string, url: string, options: {
  1292. body?: any;
  1293. headers?: HttpHeaders | {
  1294. [header: string]: string | string[];
  1295. };
  1296. - observe: 'events';
  1297. + observe: 'response';
  1298. params?: HttpParams | {
  1299. [param: string]: string | string[];
  1300. };
  1301. reportProgress?: boolean;
  1302. responseType: 'text';
  1303. withCredentials?: boolean;
  1304. - }): Observable<HttpEvent<string>>;
  1305. - request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;
  1306. - request<R>(method: string, url: string, options: {
  1307. + }): Observable<HttpResponse<string>>;
  1308. + request(method: string, url: string, options: {
  1309. body?: any;
  1310. headers?: HttpHeaders | {
  1311. [header: string]: string | string[];
  1312. };
  1313. - reportProgress?: boolean;
  1314. - observe: 'events';
  1315. + observe?: 'body';
  1316. params?: HttpParams | {
  1317. [param: string]: string | string[];
  1318. };
  1319. - responseType?: 'json';
  1320. + reportProgress?: boolean;
  1321. + responseType: 'arraybuffer';
  1322. withCredentials?: boolean;
  1323. - }): Observable<HttpEvent<R>>;
  1324. + }): Observable<ArrayBuffer>;
  1325. request(method: string, url: string, options: {
  1326. body?: any;
  1327. headers?: HttpHeaders | {
  1328. [header: string]: string | string[];
  1329. };
  1330. - observe: 'response';
  1331. + observe?: 'body';
  1332. params?: HttpParams | {
  1333. [param: string]: string | string[];
  1334. };
  1335. reportProgress?: boolean;
  1336. - responseType: 'arraybuffer';
  1337. + responseType: 'blob';
  1338. withCredentials?: boolean;
  1339. - }): Observable<HttpResponse<ArrayBuffer>>;
  1340. + }): Observable<Blob>;
  1341. request(method: string, url: string, options: {
  1342. body?: any;
  1343. headers?: HttpHeaders | {
  1344. [header: string]: string | string[];
  1345. };
  1346. - observe: 'response';
  1347. + observe?: 'body';
  1348. params?: HttpParams | {
  1349. [param: string]: string | string[];
  1350. };
  1351. reportProgress?: boolean;
  1352. - responseType: 'blob';
  1353. + responseType: 'text';
  1354. withCredentials?: boolean;
  1355. - }): Observable<HttpResponse<Blob>>;
  1356. + }): Observable<string>;
  1357. request(method: string, url: string, options: {
  1358. body?: any;
  1359. headers?: HttpHeaders | {
  1360. [header: string]: string | string[];
  1361. };
  1362. - observe: 'response';
  1363. params?: HttpParams | {
  1364. [param: string]: string | string[];
  1365. };
  1366. + observe: 'events';
  1367. reportProgress?: boolean;
  1368. - responseType: 'text';
  1369. + responseType: 'arraybuffer';
  1370. withCredentials?: boolean;
  1371. - }): Observable<HttpResponse<string>>;
  1372. + }): Observable<HttpEvent<ArrayBuffer>>;
  1373. request(method: string, url: string, options: {
  1374. body?: any;
  1375. headers?: HttpHeaders | {
  1376. [header: string]: string | string[];
  1377. };
  1378. reportProgress?: boolean;
  1379. - observe: 'response';
  1380. + observe: 'events';
  1381. params?: HttpParams | {
  1382. [param: string]: string | string[];
  1383. };
  1384. responseType?: 'json';
  1385. withCredentials?: boolean;
  1386. - }): Observable<HttpResponse<Object>>;
  1387. - request<R>(method: string, url: string, options: {
  1388. + }): Observable<HttpEvent<any>>;
  1389. + request(method: string, url: string, options: {
  1390. body?: any;
  1391. headers?: HttpHeaders | {
  1392. [header: string]: string | string[];
  1393. };
  1394. @@ -1448,9 +1408,9 @@
  1395. [param: string]: string | string[];
  1396. };
  1397. responseType?: 'json';
  1398. withCredentials?: boolean;
  1399. - }): Observable<HttpResponse<R>>;
  1400. + }): Observable<HttpResponse<Object>>;
  1401. request(method: string, url: string, options?: {
  1402. body?: any;
  1403. headers?: HttpHeaders | {
  1404. [header: string]: string | string[];
  1405. @@ -1475,8 +1435,48 @@
  1406. reportProgress?: boolean;
  1407. responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
  1408. withCredentials?: boolean;
  1409. }): Observable<any>;
  1410. + request<R>(method: string, url: string, options: {
  1411. + body?: any;
  1412. + headers?: HttpHeaders | {
  1413. + [header: string]: string | string[];
  1414. + };
  1415. + reportProgress?: boolean;
  1416. + observe: 'events';
  1417. + params?: HttpParams | {
  1418. + [param: string]: string | string[];
  1419. + };
  1420. + responseType?: 'json';
  1421. + withCredentials?: boolean;
  1422. + }): Observable<HttpEvent<R>>;
  1423. + request<R>(method: string, url: string, options: {
  1424. + body?: any;
  1425. + headers?: HttpHeaders | {
  1426. + [header: string]: string | string[];
  1427. + };
  1428. + reportProgress?: boolean;
  1429. + observe: 'response';
  1430. + params?: HttpParams | {
  1431. + [param: string]: string | string[];
  1432. + };
  1433. + responseType?: 'json';
  1434. + withCredentials?: boolean;
  1435. + }): Observable<HttpResponse<R>>;
  1436. + request<R>(method: string, url: string, options?: {
  1437. + body?: any;
  1438. + headers?: HttpHeaders | {
  1439. + [header: string]: string | string[];
  1440. + };
  1441. + observe?: 'body';
  1442. + params?: HttpParams | {
  1443. + [param: string]: string | string[];
  1444. + };
  1445. + responseType?: 'json';
  1446. + reportProgress?: boolean;
  1447. + withCredentials?: boolean;
  1448. + }): Observable<R>;
  1449. + request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;
  1450. }
  1451.  
  1452. /** @stable */
  1453. export declare class HttpClientJsonpModule {
  1454. --- tools/public_api_guard/common/http/testing.d.ts Golden file
  1455. +++ tools/public_api_guard/common/http/testing.d.ts Generated API
  1456. @@ -3,16 +3,16 @@
  1457. }
  1458.  
  1459. /** @stable */
  1460. export declare abstract class HttpTestingController {
  1461. + abstract expectNone(match: string | RequestMatch | ((req: HttpRequest<any>) => boolean), description?: string): void;
  1462. + abstract expectNone(matchFn: ((req: HttpRequest<any>) => boolean), description?: string): void;
  1463. + abstract expectNone(params: RequestMatch, description?: string): void;
  1464. abstract expectNone(url: string, description?: string): void;
  1465. - abstract expectNone(params: RequestMatch, description?: string): void;
  1466. - abstract expectNone(matchFn: ((req: HttpRequest<any>) => boolean), description?: string): void;
  1467. - abstract expectNone(match: string | RequestMatch | ((req: HttpRequest<any>) => boolean), description?: string): void;
  1468. + abstract expectOne(match: string | RequestMatch | ((req: HttpRequest<any>) => boolean), description?: string): TestRequest;
  1469. + abstract expectOne(matchFn: ((req: HttpRequest<any>) => boolean), description?: string): TestRequest;
  1470. + abstract expectOne(params: RequestMatch, description?: string): TestRequest;
  1471. abstract expectOne(url: string, description?: string): TestRequest;
  1472. - abstract expectOne(params: RequestMatch, description?: string): TestRequest;
  1473. - abstract expectOne(matchFn: ((req: HttpRequest<any>) => boolean), description?: string): TestRequest;
  1474. - abstract expectOne(match: string | RequestMatch | ((req: HttpRequest<any>) => boolean), description?: string): TestRequest;
  1475. abstract match(match: string | RequestMatch | ((req: HttpRequest<any>) => boolean)): TestRequest[];
  1476. abstract verify(opts?: {
  1477. ignoreCancelled?: boolean;
  1478. }): void;
  1479. --- tools/public_api_guard/core/core.d.ts Golden file
  1480. +++ tools/public_api_guard/core/core.d.ts Generated API
  1481. @@ -289,17 +289,17 @@
  1482. attributes: {
  1483. [key: string]: string | null;
  1484. };
  1485. childNodes: DebugNode[];
  1486. - readonly children: DebugElement[];
  1487. classes: {
  1488. [key: string]: boolean;
  1489. };
  1490. name: string;
  1491. nativeElement: any;
  1492. properties: {
  1493. [key: string]: any;
  1494. };
  1495. + readonly children: DebugElement[];
  1496. styles: {
  1497. [key: string]: string | null;
  1498. };
  1499. constructor(nativeNode: any, parent: any, _debugContext: DebugContext);
  1500. @@ -314,14 +314,14 @@
  1501. }
  1502.  
  1503. /** @experimental */
  1504. export declare class DebugNode {
  1505. + listeners: EventListener[];
  1506. + nativeNode: any;
  1507. + parent: DebugElement | null;
  1508. readonly componentInstance: any;
  1509. readonly context: any;
  1510. readonly injector: Injector;
  1511. - listeners: EventListener[];
  1512. - nativeNode: any;
  1513. - parent: DebugElement | null;
  1514. readonly providerTokens: any[];
  1515. readonly references: {
  1516. [key: string]: any;
  1517. };
  1518. @@ -498,18 +498,18 @@
  1519. }
  1520.  
  1521. /** @stable */
  1522. export declare abstract class Injector {
  1523. + /** @deprecated */ abstract get(token: any, notFoundValue?: any): any;
  1524. abstract get<T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
  1525. - /** @deprecated */ abstract get(token: any, notFoundValue?: any): any;
  1526. static NULL: Injector;
  1527. static THROW_IF_NOT_FOUND: Object;
  1528. - /** @deprecated */ static create(providers: StaticProvider[], parent?: Injector): Injector;
  1529. static create(options: {
  1530. providers: StaticProvider[];
  1531. parent?: Injector;
  1532. name?: string;
  1533. }): Injector;
  1534. + /** @deprecated */ static create(providers: StaticProvider[], parent?: Injector): Injector;
  1535. }
  1536.  
  1537. /** @stable */
  1538. export declare const Input: InputDecorator;
  1539. @@ -782,10 +782,10 @@
  1540. }
  1541.  
  1542. /** @deprecated */
  1543. export declare class ReflectiveKey {
  1544. + id: number;
  1545. readonly displayName: string;
  1546. - id: number;
  1547. token: Object;
  1548. constructor(token: Object, id: number);
  1549. static readonly numberOfKeys: number;
  1550. static get(token: Object): ReflectiveKey;
  1551. @@ -826,12 +826,12 @@
  1552. }
  1553.  
  1554. /** @experimental */
  1555. export declare abstract class Renderer2 {
  1556. + destroyNode: ((node: any) => void) | null;
  1557. readonly abstract data: {
  1558. [key: string]: any;
  1559. };
  1560. - destroyNode: ((node: any) => void) | null;
  1561. abstract addClass(el: any, name: string): void;
  1562. abstract appendChild(parent: any, newChild: any): void;
  1563. abstract createComment(value: string): any;
  1564. abstract createElement(name: string, namespace?: string | null): any;
  1565. --- tools/public_api_guard/core/testing.d.ts Golden file
  1566. +++ tools/public_api_guard/core/testing.d.ts Generated API
  1567. @@ -76,15 +76,15 @@
  1568. useJit?: boolean;
  1569. }): void;
  1570. configureTestingModule(moduleDef: TestModuleMetadata): void;
  1571. createComponent<T>(component: Type<T>): ComponentFixture<T>;
  1572. - deprecatedOverrideProvider(token: any, provider: {
  1573. - useValue: any;
  1574. - }): void;
  1575. /** @deprecated */ deprecatedOverrideProvider(token: any, provider: {
  1576. useFactory: Function;
  1577. deps: any[];
  1578. }): void;
  1579. + deprecatedOverrideProvider(token: any, provider: {
  1580. + useValue: any;
  1581. + }): void;
  1582. execute(tokens: any[], fn: Function, context?: any): any;
  1583. get(token: any, notFoundValue?: any): any;
  1584. /** @experimental */ initTestEnvironment(ngModule: Type<any> | Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): void;
  1585. overrideComponent(component: Type<any>, override: MetadataOverride<Component>): void;
  1586. @@ -107,15 +107,15 @@
  1587. useJit?: boolean;
  1588. }): typeof TestBed;
  1589. static configureTestingModule(moduleDef: TestModuleMetadata): typeof TestBed;
  1590. static createComponent<T>(component: Type<T>): ComponentFixture<T>;
  1591. - static deprecatedOverrideProvider(token: any, provider: {
  1592. - useValue: any;
  1593. - }): void;
  1594. /** @deprecated */ static deprecatedOverrideProvider(token: any, provider: {
  1595. useFactory: Function;
  1596. deps: any[];
  1597. }): void;
  1598. + static deprecatedOverrideProvider(token: any, provider: {
  1599. + useValue: any;
  1600. + }): void;
  1601. static get(token: any, notFoundValue?: any): any;
  1602. /** @experimental */ static initTestEnvironment(ngModule: Type<any> | Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): TestBed;
  1603. static overrideComponent(component: Type<any>, override: MetadataOverride<Component>): typeof TestBed;
  1604. static overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): typeof TestBed;
  1605. --- tools/public_api_guard/forms/forms.d.ts Golden file
  1606. +++ tools/public_api_guard/forms/forms.d.ts Generated API
  1607. @@ -15,12 +15,15 @@
  1608. readonly touched: boolean;
  1609. readonly untouched: boolean;
  1610. readonly updateOn: FormHooks;
  1611. readonly valid: boolean;
  1612. - validator: ValidatorFn | null;
  1613. readonly value: any;
  1614. readonly valueChanges: Observable<any>;
  1615. + validator: ValidatorFn | null;
  1616. constructor(validator: ValidatorFn | null, asyncValidator: AsyncValidatorFn | null);
  1617. + abstract patchValue(value: any, options?: Object): void;
  1618. + abstract reset(value?: any, options?: Object): void;
  1619. + abstract setValue(value: any, options?: Object): void;
  1620. clearAsyncValidators(): void;
  1621. clearValidators(): void;
  1622. disable(opts?: {
  1623. onlySelf?: boolean;
  1624. @@ -47,17 +50,14 @@
  1625. }): void;
  1626. markAsUntouched(opts?: {
  1627. onlySelf?: boolean;
  1628. }): void;
  1629. - abstract patchValue(value: any, options?: Object): void;
  1630. - abstract reset(value?: any, options?: Object): void;
  1631. setAsyncValidators(newValidator: AsyncValidatorFn | AsyncValidatorFn[] | null): void;
  1632. setErrors(errors: ValidationErrors | null, opts?: {
  1633. emitEvent?: boolean;
  1634. }): void;
  1635. setParent(parent: FormGroup | FormArray): void;
  1636. setValidators(newValidator: ValidatorFn | ValidatorFn[] | null): void;
  1637. - abstract setValue(value: any, options?: Object): void;
  1638. updateValueAndValidity(opts?: {
  1639. onlySelf?: boolean;
  1640. emitEvent?: boolean;
  1641. }): void;
  1642. @@ -134,10 +134,10 @@
  1643. export declare const COMPOSITION_BUFFER_MODE: InjectionToken<boolean>;
  1644.  
  1645. /** @stable */
  1646. export declare abstract class ControlContainer extends AbstractControlDirective {
  1647. + name: string;
  1648. readonly formDirective: Form | null;
  1649. - name: string;
  1650. readonly path: string[] | null;
  1651. }
  1652.  
  1653. /** @stable */
  1654. @@ -203,12 +203,12 @@
  1655. }
  1656.  
  1657. /** @stable */
  1658. export declare class FormArrayName extends ControlContainer implements OnInit, OnDestroy {
  1659. + name: string;
  1660. readonly asyncValidator: AsyncValidatorFn | null;
  1661. readonly control: FormArray;
  1662. readonly formDirective: FormGroupDirective | null;
  1663. - name: string;
  1664. readonly path: string[];
  1665. readonly validator: ValidatorFn | null;
  1666. constructor(parent: ControlContainer, validators: any[], asyncValidators: any[]);
  1667. ngOnDestroy(): void;
  1668. @@ -250,33 +250,33 @@
  1669. }
  1670.  
  1671. /** @stable */
  1672. export declare class FormControlDirective extends NgControl implements OnChanges {
  1673. - readonly asyncValidator: AsyncValidatorFn | null;
  1674. - readonly control: FormControl;
  1675. form: FormControl;
  1676. isDisabled: boolean;
  1677. model: any;
  1678. + readonly asyncValidator: AsyncValidatorFn | null;
  1679. + readonly control: FormControl;
  1680. readonly path: string[];
  1681. + readonly validator: ValidatorFn | null;
  1682. update: EventEmitter<{}>;
  1683. - readonly validator: ValidatorFn | null;
  1684. viewModel: any;
  1685. constructor(validators: Array<Validator | ValidatorFn>, asyncValidators: Array<AsyncValidator | AsyncValidatorFn>, valueAccessors: ControlValueAccessor[]);
  1686. ngOnChanges(changes: SimpleChanges): void;
  1687. viewToModelUpdate(newValue: any): void;
  1688. }
  1689.  
  1690. /** @stable */
  1691. export declare class FormControlName extends NgControl implements OnChanges, OnDestroy {
  1692. + isDisabled: boolean;
  1693. + model: any;
  1694. + name: string;
  1695. readonly asyncValidator: AsyncValidatorFn;
  1696. readonly control: FormControl;
  1697. readonly formDirective: any;
  1698. - isDisabled: boolean;
  1699. - model: any;
  1700. - name: string;
  1701. readonly path: string[];
  1702. + readonly validator: ValidatorFn | null;
  1703. update: EventEmitter<{}>;
  1704. - readonly validator: ValidatorFn | null;
  1705. constructor(parent: ControlContainer, validators: Array<Validator | ValidatorFn>, asyncValidators: Array<AsyncValidator | AsyncValidatorFn>, valueAccessors: ControlValueAccessor[]);
  1706. ngOnChanges(changes: SimpleChanges): void;
  1707. ngOnDestroy(): void;
  1708. viewToModelUpdate(newValue: any): void;
  1709. @@ -315,13 +315,13 @@
  1710. }
  1711.  
  1712. /** @stable */
  1713. export declare class FormGroupDirective extends ControlContainer implements Form, OnChanges {
  1714. - readonly control: FormGroup;
  1715. directives: FormControlName[];
  1716. form: FormGroup;
  1717. + ngSubmit: EventEmitter<{}>;
  1718. + readonly control: FormGroup;
  1719. readonly formDirective: Form;
  1720. - ngSubmit: EventEmitter<{}>;
  1721. readonly path: string[];
  1722. readonly submitted: boolean;
  1723. constructor(_validators: any[], _asyncValidators: any[]);
  1724. addControl(dir: FormControlName): FormControl;
  1725. @@ -376,10 +376,10 @@
  1726. export declare const NG_VALUE_ACCESSOR: InjectionToken<ControlValueAccessor>;
  1727.  
  1728. /** @stable */
  1729. export declare abstract class NgControl extends AbstractControlDirective {
  1730. + name: string | null;
  1731. readonly asyncValidator: AsyncValidatorFn | null;
  1732. - name: string | null;
  1733. readonly validator: ValidatorFn | null;
  1734. valueAccessor: ControlValueAccessor | null;
  1735. abstract viewToModelUpdate(newValue: any): void;
  1736. }
  1737. @@ -395,18 +395,18 @@
  1738. }
  1739.  
  1740. /** @stable */
  1741. export declare class NgForm extends ControlContainer implements Form, AfterViewInit {
  1742. + form: FormGroup;
  1743. + ngSubmit: EventEmitter<{}>;
  1744. + options: {
  1745. + updateOn?: FormHooks;
  1746. + };
  1747. readonly control: FormGroup;
  1748. readonly controls: {
  1749. [key: string]: AbstractControl;
  1750. };
  1751. - form: FormGroup;
  1752. readonly formDirective: Form;
  1753. - ngSubmit: EventEmitter<{}>;
  1754. - options: {
  1755. - updateOn?: FormHooks;
  1756. - };
  1757. readonly path: string[];
  1758. readonly submitted: boolean;
  1759. constructor(validators: any[], asyncValidators: any[]);
  1760. addControl(dir: NgModel): void;
  1761. @@ -426,22 +426,22 @@
  1762. }
  1763.  
  1764. /** @stable */
  1765. export declare class NgModel extends NgControl implements OnChanges, OnDestroy {
  1766. - readonly asyncValidator: AsyncValidatorFn | null;
  1767. - readonly control: FormControl;
  1768. - readonly formDirective: any;
  1769. isDisabled: boolean;
  1770. model: any;
  1771. name: string;
  1772. options: {
  1773. name?: string;
  1774. standalone?: boolean;
  1775. updateOn?: FormHooks;
  1776. };
  1777. + readonly asyncValidator: AsyncValidatorFn | null;
  1778. + readonly control: FormControl;
  1779. + readonly formDirective: any;
  1780. readonly path: string[];
  1781. + readonly validator: ValidatorFn | null;
  1782. update: EventEmitter<{}>;
  1783. - readonly validator: ValidatorFn | null;
  1784. viewModel: any;
  1785. constructor(parent: ControlContainer, validators: Array<Validator | ValidatorFn>, asyncValidators: Array<AsyncValidator | AsyncValidatorFn>, valueAccessors: ControlValueAccessor[]);
  1786. ngOnChanges(changes: SimpleChanges): void;
  1787. ngOnDestroy(): void;
  1788. --- tools/public_api_guard/platform-browser/platform-browser.d.ts Golden file
  1789. +++ tools/public_api_guard/platform-browser/platform-browser.d.ts Generated API
  1790. @@ -69,9 +69,9 @@
  1791. buildHammer(element: HTMLElement): HammerInstance;
  1792. }
  1793.  
  1794. /** @experimental */
  1795. -export declare function makeStateKey<T =
  1796. +export declare function makeStateKey<T = void>(key: string): StateKey<T>;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!