@ardium-pl/devkit 8.3.2

package/lib/http-service/http.service.d.ts

@@ -0,0 +1,2574 @@
+import { HttpContext, HttpEvent, HttpHeaders, HttpParams, HttpRequest, HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { DefaultRequestOptions, ObjectHttpParams } from './_types';
+export declare function createHttpService(apiUrl: string, defaultOptions?: DefaultRequestOptions): {
+    new (): {
+        readonly apiUrl: string;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<R>(req: HttpRequest<any>): Observable<HttpEvent<R>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<Blob>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<string>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            reportProgress?: boolean;
+            observe: "events";
+            params?: HttpParams | TParams | undefined;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<any>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<R, TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            reportProgress?: boolean;
+            observe: "events";
+            params?: HttpParams | TParams | undefined;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<R>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            reportProgress?: boolean;
+            observe: "response";
+            params?: HttpParams | TParams | undefined;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<R, TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            reportProgress?: boolean;
+            observe: "response";
+            params?: HttpParams | TParams | undefined;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<R>>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options?: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            responseType?: "json";
+            reportProgress?: boolean;
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        } | undefined): Observable<Object>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<R, TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options?: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            responseType?: "json";
+            reportProgress?: boolean;
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        } | undefined): Observable<R>;
+        /**
+         * Sends an `HttpRequest` and returns a stream of `HttpEvent`s.
+         *
+         * @param req The `HttpRequest` object to send.
+         * @return An `Observable` of the response, with the response body as a stream of `HttpEvent`s.
+         */
+        request<TParams extends ObjectHttpParams = ObjectHttpParams>(method: string, url: string | string[], options?: {
+            body?: any;
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            observe?: "body" | "events" | "response";
+            reportProgress?: boolean;
+            responseType?: "arraybuffer" | "blob" | "json" | "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        } | undefined): Observable<any>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<Blob>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<string>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpEvent<Object>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | {
+                [param: string]: string | number | boolean | (string | number | boolean)[];
+            };
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpEvent<TRes>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            body?: any | null;
+        }): Observable<HttpResponse<TRes>>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            body?: any | null;
+        } | undefined): Observable<Object>;
+        /**
+         * Constructs a `DELETE` request that interprets the body as an `ArrayBuffer`
+         * and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response body as an `ArrayBuffer`.
+         */
+        delete<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            body?: any | null;
+        } | undefined): Observable<TRes>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<Blob>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<string>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<Object>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<TRes>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<TRes>>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        } | undefined): Observable<Object>;
+        /**
+         * Constructs a `GET` request that interprets the body as an `ArrayBuffer` and returns the
+         * response in an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        get<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        } | undefined): Observable<TRes>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<Blob>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<string>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<Object>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<TRes>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Constructs a `HEAD` request that interprets the body as an `ArrayBuffer` and
+         * returns the response as an `ArrayBuffer`.
+         *
+         * @param url     The endpoint URL.
+         * @param options The HTTP options to send with the request.
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        head<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe?: "body";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<TRes>;
+        /**
+         * Constructs a `JSONP` request for the given URL and name of the callback parameter.
+         *
+         * @param url The resource URL.
+         * @param callbackParam The callback function name.
+         *
+         * @return An `Observable` of the response object, with response body as an object.
+         */
+        jsonp(url: string | string[], callbackParam: string): Observable<Object>;
+        /**
+         * Constructs a `JSONP` request for the given URL and name of the callback parameter.
+         *
+         * @param url The resource URL.
+         * @param callbackParam The callback function name.
+         *
+         * @return An `Observable` of the response object, with response body as an object.
+         */
+        jsonp<TRes>(url: string | string[], callbackParam: string): Observable<TRes>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<Blob>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<string>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<Object>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<TRes>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<TRes>>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        } | undefined): Observable<Object>;
+        /**
+         * Constructs an `OPTIONS` request that interprets the body as an
+         * `ArrayBuffer` and returns the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        options<TRes, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        } | undefined): Observable<TRes>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<Blob>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<string>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<Object>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<TRes>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<TRes>>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        } | undefined): Observable<Object>;
+        /**
+         * Constructs a `PATCH` request that interprets the body as an `ArrayBuffer` and returns
+         * the response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to edit.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        patch<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        } | undefined): Observable<TRes>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<Blob>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<string>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<Object>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpEvent<TRes>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        }): Observable<HttpResponse<TRes>>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        } | undefined): Observable<Object>;
+        /**
+         * Constructs a `POST` request that interprets the body as an `ArrayBuffer` and returns
+         * an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The content to replace with.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        post<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+            transferCache?: {
+                includeHeaders?: string[];
+            } | boolean;
+        } | undefined): Observable<TRes>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<ArrayBuffer>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<Blob>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<string>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<ArrayBuffer>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<Blob>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<string>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<Object>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "events";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpEvent<TRes>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "arraybuffer";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<ArrayBuffer>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "blob";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<Blob>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType: "text";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<string>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<Object>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            observe: "response";
+            context?: HttpContext;
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        }): Observable<HttpResponse<TRes>>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        } | undefined): Observable<Object>;
+        /**
+         * Constructs a `PUT` request that interprets the body as an `ArrayBuffer` and returns the
+         * response as an `ArrayBuffer`.
+         *
+         * @param url The endpoint URL.
+         * @param body The resources to add/update.
+         * @param options HTTP options.
+         *
+         * @return An `Observable` of the response, with the response body as an `ArrayBuffer`.
+         */
+        put<TRes, TBody = any, TParams extends ObjectHttpParams = ObjectHttpParams>(url: string | string[], body: TBody | null, options?: {
+            headers?: HttpHeaders | {
+                [header: string]: string | string[];
+            };
+            context?: HttpContext;
+            observe?: "body";
+            params?: HttpParams | TParams | undefined;
+            reportProgress?: boolean;
+            responseType?: "json";
+            withCredentials?: boolean;
+        } | undefined): Observable<TRes>;
+    };
+};