angular-odata 0.80.0 → 0.99.0

package/{esm2015/lib/cache/storage.js → esm2020/lib/cache/storage.mjs}

@@ -1,5 +1,5 @@
-import { ODataCache } from './cache';
 import { ODataResponse } from '../resources';
+import { ODataCache } from './cache';
 export class ODataInStorageCache extends ODataCache {
     constructor({ name, storage = sessionStorage, timeout, }) {
         super({ timeout });
@@ -33,4 +33,4 @@ export class ODataInStorageCache extends ODataCache {
         return data !== undefined ? ODataResponse.fromJSON(req, data) : undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9jYWNoZS9zdG9yYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQW1CLE1BQU0sU0FBUyxDQUFDO0FBQ3RELE9BQU8sRUFBZ0IsYUFBYSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBVTNELE1BQU0sT0FBTyxtQkFBb0IsU0FBUSxVQUFVO0lBR2pELFlBQVksRUFDVixJQUFJLEVBQ0osT0FBTyxHQUFHLGNBQWMsRUFDeEIsT0FBTyxHQUtSO1FBQ0MsS0FBSyxDQUFDLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztRQUNuQixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDZixNQUFNLENBQUMsZ0JBQWdCLENBQUMsY0FBYyxFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFFRCxLQUFLO1FBQ0gsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQ2xCLElBQUksQ0FBQyxJQUFJLEVBQ1QsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQyxDQUNuRCxDQUFDO0lBQ0osQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksR0FBRyxDQUNwQixJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxJQUFJLENBQUMsQ0FDcEQsQ0FBQztJQUNKLENBQUM7SUFFRCxLQUFLO1FBQ0gsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ2QsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ2YsQ0FBQztJQUVELFdBQVcsQ0FBQyxHQUFzQixFQUFFLEdBQXVCO1FBQ3pELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDOUIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFDakMsSUFBSSxDQUFDLEdBQUcsQ0FBZSxHQUFHLENBQUMsY0FBYyxFQUFFLEdBQUcsQ0FBQyxNQUFNLEVBQUUsRUFBRTtZQUN2RCxPQUFPLEVBQUUsR0FBRyxDQUFDLE9BQU8sQ0FBQyxNQUFNO1lBQzNCLEtBQUs7WUFDTCxJQUFJO1NBQ0wsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELFdBQVcsQ0FBQyxHQUFzQjtRQUNoQyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQzlCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQWUsR0FBRyxDQUFDLGNBQWMsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7UUFFbkUsT0FBTyxJQUFJLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLEdBQUcsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO0lBQzVFLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9EYXRhQ2FjaGUsIE9EYXRhQ2FjaGVFbnRyeSB9IGZyb20gJy4vY2FjaGUnO1xuaW1wb3J0IHsgT0RhdGFSZXF1ZXN0LCBPRGF0YVJlc3BvbnNlIH0gZnJvbSAnLi4vcmVzb3VyY2VzJztcblxuaW50ZXJmYWNlIFJlc3BvbnNlSnNvbiB7XG4gIGJvZHk6IGFueSB8IG51bGw7XG4gIGhlYWRlcnM6IHsgW25hbWU6IHN0cmluZ106IHN0cmluZyB8IHN0cmluZ1tdIH07XG4gIHN0YXR1czogbnVtYmVyO1xuICBzdGF0dXNUZXh0OiBzdHJpbmc7XG4gIHVybDogc3RyaW5nIHwgbnVsbDtcbn1cblxuZXhwb3J0IGNsYXNzIE9EYXRhSW5TdG9yYWdlQ2FjaGUgZXh0ZW5kcyBPRGF0YUNhY2hlIHtcbiAgbmFtZTogc3RyaW5nO1xuICBzdG9yYWdlOiBTdG9yYWdlO1xuICBjb25zdHJ1Y3Rvcih7XG4gICAgbmFtZSxcbiAgICBzdG9yYWdlID0gc2Vzc2lvblN0b3JhZ2UsXG4gICAgdGltZW91dCxcbiAgfToge1xuICAgIHRpbWVvdXQ/OiBudW1iZXI7XG4gICAgbmFtZTogc3RyaW5nO1xuICAgIHN0b3JhZ2U/OiBTdG9yYWdlO1xuICB9KSB7XG4gICAgc3VwZXIoeyB0aW1lb3V0IH0pO1xuICAgIHRoaXMubmFtZSA9IG5hbWU7XG4gICAgdGhpcy5zdG9yYWdlID0gc3RvcmFnZTtcbiAgICB0aGlzLnJlc3RvcmUoKTtcbiAgICB3aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcignYmVmb3JldW5sb2FkJywgKCkgPT4gdGhpcy5zdG9yZSgpKTtcbiAgfVxuXG4gIHN0b3JlKCkge1xuICAgIHRoaXMuc3RvcmFnZS5zZXRJdGVtKFxuICAgICAgdGhpcy5uYW1lLFxuICAgICAgSlNPTi5zdHJpbmdpZnkoQXJyYXkuZnJvbSh0aGlzLmVudHJpZXMuZW50cmllcygpKSlcbiAgICApO1xuICB9XG5cbiAgcmVzdG9yZSgpIHtcbiAgICB0aGlzLmVudHJpZXMgPSBuZXcgTWFwPHN0cmluZywgT0RhdGFDYWNoZUVudHJ5PGFueT4+KFxuICAgICAgSlNPTi5wYXJzZSh0aGlzLnN0b3JhZ2UuZ2V0SXRlbSh0aGlzLm5hbWUpIHx8ICdbXScpXG4gICAgKTtcbiAgfVxuXG4gIGZsdXNoKCkge1xuICAgIHN1cGVyLmZsdXNoKCk7XG4gICAgdGhpcy5zdG9yZSgpO1xuICB9XG5cbiAgcHV0UmVzcG9uc2UocmVxOiBPRGF0YVJlcXVlc3Q8YW55PiwgcmVzOiBPRGF0YVJlc3BvbnNlPGFueT4pIHtcbiAgICBjb25zdCBzY29wZSA9IHRoaXMuc2NvcGUocmVxKTtcbiAgICBjb25zdCB0YWdzID0gdGhpcy50YWdzKHJlcSwgcmVzKTtcbiAgICB0aGlzLnB1dDxSZXNwb25zZUpzb24+KHJlcS5wYXRoV2l0aFBhcmFtcywgcmVzLnRvSlNPTigpLCB7XG4gICAgICB0aW1lb3V0OiByZXMub3B0aW9ucy5tYXhBZ2UsXG4gICAgICBzY29wZSxcbiAgICAgIHRhZ3MsXG4gICAgfSk7XG4gIH1cblxuICBnZXRSZXNwb25zZShyZXE6IE9EYXRhUmVxdWVzdDxhbnk+KTogT0RhdGFSZXNwb25zZTxhbnk+IHwgdW5kZWZpbmVkIHtcbiAgICBjb25zdCBzY29wZSA9IHRoaXMuc2NvcGUocmVxKTtcbiAgICBjb25zdCBkYXRhID0gdGhpcy5nZXQ8UmVzcG9uc2VKc29uPihyZXEucGF0aFdpdGhQYXJhbXMsIHsgc2NvcGUgfSk7XG5cbiAgICByZXR1cm4gZGF0YSAhPT0gdW5kZWZpbmVkID8gT0RhdGFSZXNwb25zZS5mcm9tSlNPTihyZXEsIGRhdGEpIDogdW5kZWZpbmVkO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/client.mjs

@@ -0,0 +1,271 @@
+import { HttpParams, } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { ODataRequest, ODataResource, } from './resources/index';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./settings";
+function addBody(options, body) {
+    return {
+        body,
+        etag: options.etag,
+        apiName: options.apiName,
+        fetchPolicy: options.fetchPolicy,
+        headers: options.headers,
+        observe: options.observe,
+        params: options.params,
+        reportProgress: options.reportProgress,
+        responseType: options.responseType,
+        withCredentials: options.withCredentials,
+    };
+}
+export class ODataClient {
+    constructor(http, settings, injector) {
+        this.http = http;
+        this.settings = settings;
+        this.injector = injector;
+        this.settings.configure({
+            requester: (req) => this.http.request(req.method, `${req.url}`, {
+                body: req.body,
+                headers: req.headers,
+                observe: req.observe,
+                params: req.params,
+                reportProgress: req.reportProgress,
+                responseType: req.responseType,
+                withCredentials: req.withCredentials,
+            }),
+        });
+    }
+    //#region Resolve Building Blocks
+    /**
+     * Resolve the api for the given value.
+     * Where value is: string type or an string name or an instance of resource.
+     * @param value The value to resolve.
+     * @returns The api for the value.
+     */
+    apiFor(value) {
+        let api = undefined;
+        if (value instanceof ODataResource)
+            api = this.settings.findApiForTypes(value.types());
+        else if (typeof value === 'string')
+            api =
+                this.settings.findApiByName(value) ||
+                    this.settings.findApiForType(value);
+        return api || this.settings.defaultApi();
+    }
+    /**
+     * Resolve the parser for the given string type.
+     * @param type The string type of the parser.
+     * @returns The parser for the given type.
+     */
+    parserForType(type) {
+        return this.settings.parserForType(type);
+    }
+    /**
+     * Resolve the enum type for the given string type.
+     * @param type The string type of the enum type.
+     * @returns The enum type for the given type.
+     */
+    enumTypeForType(type) {
+        return this.settings.enumTypeForType(type);
+    }
+    /**
+     * Resolve the structured type for the given string type.
+     * @param type The string type of the structured type.
+     * @returns The structured type for the given type.
+     */
+    structuredTypeForType(type) {
+        return this.settings.structuredTypeForType(type);
+    }
+    /**
+     * Resolve the callable for the given string type.
+     * @param type The string type of the callable.
+     * @returns The callable for the given type.
+     */
+    callableForType(type) {
+        return this.settings.callableForType(type);
+    }
+    /**
+     * Resolve the entity set for the given string type.
+     * @param type The string type of the entity set.
+     * @returns The entity set for the given type.
+     */
+    entitySetForType(type) {
+        return this.settings.entitySetForType(type);
+    }
+    /**
+     * Resolve the model for the given string type.
+     * @param type The string type of the model.
+     * @returns The model for the given type.
+     */
+    modelForType(type) {
+        return this.settings.modelForType(type);
+    }
+    /**
+     * Resolve the collection for the given string type.
+     * @param type The string type of the collection.
+     * @returns The collection for the given type.
+     */
+    collectionForType(type) {
+        return this.settings.collectionForType(type);
+    }
+    /**
+     * Resolve the service for the given string type.
+     * @param type The string type of the service.
+     * @returns The service for the given type.
+     */
+    serviceForType(type) {
+        return this.injector.get(this.settings.serviceForType(type));
+    }
+    /**
+     * Resolve the service for the given string entity type.
+     * @param type The string entity type binding to the service.
+     * @returns The service for the given entity type.
+     */
+    serviceForEntityType(type) {
+        return this.injector.get(this.settings.serviceForEntityType(type));
+    }
+    enumTypeByName(name) {
+        return this.settings.enumTypeByName(name);
+    }
+    structuredTypeByName(name) {
+        return this.settings.structuredTypeByName(name);
+    }
+    callableByName(name) {
+        return this.settings.callableByName(name);
+    }
+    entitySetByName(name) {
+        return this.settings.entitySetByName(name);
+    }
+    modelByName(name) {
+        return this.settings.modelByName(name);
+    }
+    collectionByName(name) {
+        return this.settings.collectionByName(name);
+    }
+    serviceByName(name) {
+        return this.injector.get(this.settings.serviceByName(name));
+    }
+    fromJSON(json, apiNameOrType) {
+        return this.apiFor(apiNameOrType).fromJSON(json);
+    }
+    // Requests
+    /**
+     * Build a resource for the metadata.
+     * @param apiName The name of the API.
+     * @returns The metadata resource.
+     */
+    metadata(apiName) {
+        return this.apiFor(apiName).metadata();
+    }
+    /**
+     * Build a resource for the batch.
+     * @param apiName The name of the API.
+     * @returns The batch resource.
+     */
+    batch(apiName) {
+        return this.apiFor(apiName).batch();
+    }
+    /**
+     * Build a resource for the singleton.
+     * @param path The full path to the singleton.
+     * @param apiNameOrType The name of the API or the type of the singleton.
+     * @returns The singleton resource.
+     */
+    singleton(path, apiNameOrType) {
+        return this.apiFor(apiNameOrType).singleton(path);
+    }
+    /**
+     * Build a resource for the entity set.
+     * @param path The full path to the entity set.
+     * @param apiNameOrType The name of the API or the type of the entity set.
+     * @returns The entity set resource.
+     */
+    entitySet(path, apiNameOrType) {
+        return this.apiFor(apiNameOrType).entitySet(path);
+    }
+    /**
+     * Build a resource for unbound action.
+     * @param path The full path to the action.
+     * @param apiNameOrType The name of the API or the type of the entity.
+     * @returns The unbound action resource.
+     */
+    action(path, apiNameOrType) {
+        return this.apiFor(apiNameOrType).action(path);
+    }
+    /**
+     * Build a resource for unbound function.
+     * @param path The full path to the function.
+     * @param apiNameOrType The name of the API or the type of the callable.
+     * @returns The unbound function resource.
+     */
+    function(path, apiNameOrType) {
+        return this.apiFor(apiNameOrType).function(path);
+    }
+    request(method, resource, options) {
+        let api = options.apiName
+            ? this.settings.apiByName(options.apiName)
+            : resource.api;
+        if (!api)
+            throw new Error(`The types: '[${resource
+                .types()
+                .join(', ')}]' does not belongs to any known configuration`);
+        const request = new ODataRequest({
+            method,
+            api,
+            resource,
+            body: options.body,
+            observe: options.observe === 'events' ? 'events' : 'response',
+            etag: options.etag,
+            headers: options.headers,
+            reportProgress: options.reportProgress,
+            params: options.params,
+            responseType: options.responseType,
+            fetchPolicy: options.fetchPolicy,
+            withCredentials: options.withCredentials,
+        });
+        return api
+            .request(request)
+            .pipe(map((res) => options.observe === undefined || options.observe === 'body'
+            ? res.body
+            : res));
+    }
+    delete(resource, options = {}) {
+        return this.request('DELETE', resource, addBody(options, null));
+    }
+    get(resource, options = {}) {
+        return this.request('GET', resource, options);
+    }
+    head(resource, options = {}) {
+        return this.request('HEAD', resource, options);
+    }
+    jsonp(resource, callbackParam) {
+        return this.request('JSONP', resource, {
+            body: null,
+            params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),
+            observe: 'body',
+            responseType: 'json',
+        });
+    }
+    options(resource, options = {}) {
+        return this.request('OPTIONS', resource, options);
+    }
+    patch(resource, body, options = {}) {
+        return this.request('PATCH', resource, addBody(options, body));
+    }
+    post(resource, body, options = {}) {
+        return this.request('POST', resource, addBody(options, body));
+    }
+    put(resource, body, options = {}) {
+        return this.request('PUT', resource, addBody(options, body));
+    }
+}
+ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataClient, deps: [{ token: i1.HttpClient }, { token: i2.ODataSettings }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ODataClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ODataSettings }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../projects/angular-odata/src/lib/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpClient,\n  HttpEvent,\n  HttpHeaders,\n  HttpParams,\n  HttpResponse,\n} from '@angular/common/http';\nimport { Injectable, Injector } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ODataApi } from './api';\nimport { ODataCollection, ODataModel } from './models/index';\nimport {\n  ODataActionResource,\n  ODataBatchResource,\n  ODataEntityResource,\n  ODataEntitySetResource,\n  ODataFunctionResource,\n  ODataMetadataResource,\n  ODataNavigationPropertyResource,\n  ODataRequest,\n  ODataResource,\n  ODataResponse,\n  ODataSegment,\n  ODataSingletonResource,\n} from './resources/index';\nimport { ODataEntityService } from './services/entity';\nimport { ODataSettings } from './settings';\n\nfunction addBody<T>(\n  options: {\n    etag?: string;\n    apiName?: string;\n    fetchPolicy?:\n      | 'cache-first'\n      | 'cache-and-network'\n      | 'network-only'\n      | 'no-cache'\n      | 'cache-only';\n    headers?: HttpHeaders | { [header: string]: string | string[] };\n    observe?: 'body' | 'events' | 'response';\n    params?: HttpParams | { [param: string]: string | string[] };\n    reportProgress?: boolean;\n    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n    withCredentials?: boolean;\n  },\n  body: T | null\n): any {\n  return {\n    body,\n    etag: options.etag,\n    apiName: options.apiName,\n    fetchPolicy: options.fetchPolicy,\n    headers: options.headers,\n    observe: options.observe,\n    params: options.params,\n    reportProgress: options.reportProgress,\n    responseType: options.responseType,\n    withCredentials: options.withCredentials,\n  };\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ODataClient {\n  constructor(\n    private http: HttpClient,\n    private settings: ODataSettings,\n    private injector: Injector\n  ) {\n    this.settings.configure({\n      requester: (req: ODataRequest<any>): Observable<any> =>\n        this.http.request(req.method, `${req.url}`, {\n          body: req.body,\n          headers: req.headers,\n          observe: req.observe,\n          params: req.params,\n          reportProgress: req.reportProgress,\n          responseType: req.responseType,\n          withCredentials: req.withCredentials,\n        }),\n    });\n  }\n\n  //#region Resolve Building Blocks\n  /**\n   * Resolve the api for the given value.\n   * Where value is: string type or an string name or an instance of resource.\n   * @param value The value to resolve.\n   * @returns The api for the value.\n   */\n  apiFor(value?: ODataResource<any> | string): ODataApi {\n    let api: ODataApi | undefined = undefined;\n    if (value instanceof ODataResource)\n      api = this.settings.findApiForTypes(value.types());\n    else if (typeof value === 'string')\n      api =\n        this.settings.findApiByName(value) ||\n        this.settings.findApiForType(value);\n    return api || this.settings.defaultApi();\n  }\n\n  /**\n   * Resolve the parser for the given string type.\n   * @param type The string type of the parser.\n   * @returns The parser for the given type.\n   */\n  parserForType<T>(type: string) {\n    return this.settings.parserForType<T>(type);\n  }\n\n  /**\n   * Resolve the enum type for the given string type.\n   * @param type The string type of the enum type.\n   * @returns The enum type for the given type.\n   */\n  enumTypeForType<T>(type: string) {\n    return this.settings.enumTypeForType<T>(type);\n  }\n\n  /**\n   * Resolve the structured type for the given string type.\n   * @param type The string type of the structured type.\n   * @returns The structured type for the given type.\n   */\n  structuredTypeForType<T>(type: string) {\n    return this.settings.structuredTypeForType<T>(type);\n  }\n\n  /**\n   * Resolve the callable for the given string type.\n   * @param type The string type of the callable.\n   * @returns The callable for the given type.\n   */\n  callableForType<T>(type: string) {\n    return this.settings.callableForType<T>(type);\n  }\n\n  /**\n   * Resolve the entity set for the given string type.\n   * @param type The string type of the entity set.\n   * @returns The entity set for the given type.\n   */\n  entitySetForType(type: string) {\n    return this.settings.entitySetForType(type);\n  }\n\n  /**\n   * Resolve the model for the given string type.\n   * @param type The string type of the model.\n   * @returns The model for the given type.\n   */\n  modelForType(type: string): typeof ODataModel {\n    return this.settings.modelForType(type);\n  }\n\n  /**\n   * Resolve the collection for the given string type.\n   * @param type The string type of the collection.\n   * @returns The collection for the given type.\n   */\n  collectionForType(type: string): typeof ODataCollection {\n    return this.settings.collectionForType(type);\n  }\n\n  /**\n   * Resolve the service for the given string type.\n   * @param type The string type of the service.\n   * @returns The service for the given type.\n   */\n  serviceForType(type: string): ODataEntityService<any> {\n    return this.injector.get(this.settings.serviceForType(type));\n  }\n\n  /**\n   * Resolve the service for the given string entity type.\n   * @param type The string entity type binding to the service.\n   * @returns The service for the given entity type.\n   */\n  serviceForEntityType(type: string): ODataEntityService<any> {\n    return this.injector.get(this.settings.serviceForEntityType(type));\n  }\n\n  enumTypeByName<T>(name: string) {\n    return this.settings.enumTypeByName<T>(name);\n  }\n  structuredTypeByName<T>(name: string) {\n    return this.settings.structuredTypeByName<T>(name);\n  }\n  callableByName<T>(name: string) {\n    return this.settings.callableByName<T>(name);\n  }\n  entitySetByName(name: string) {\n    return this.settings.entitySetByName(name);\n  }\n  modelByName(name: string): typeof ODataModel {\n    return this.settings.modelByName(name);\n  }\n  collectionByName(name: string): typeof ODataCollection {\n    return this.settings.collectionByName(name);\n  }\n  serviceByName(name: string): ODataEntityService<any> {\n    return this.injector.get(this.settings.serviceByName(name));\n  }\n  //#endregion\n\n  //#region API Resource Proxy Methods\n  fromJSON<E>(\n    json: { segments: ODataSegment[]; options: { [name: string]: any } },\n    apiNameOrType?: string\n  ):\n    | ODataEntityResource<E>\n    | ODataEntitySetResource<E>\n    | ODataNavigationPropertyResource<E>\n    | ODataSingletonResource<E>;\n  fromJSON(\n    json: { segments: ODataSegment[]; options: { [name: string]: any } },\n    apiNameOrType?: string\n  ) {\n    return this.apiFor(apiNameOrType).fromJSON<any>(json);\n  }\n\n  // Requests\n  /**\n   * Build a resource for the metadata.\n   * @param apiName The name of the API.\n   * @returns The metadata resource.\n   */\n  metadata(apiName?: string): ODataMetadataResource {\n    return this.apiFor(apiName).metadata();\n  }\n\n  /**\n   * Build a resource for the batch.\n   * @param apiName The name of the API.\n   * @returns The batch resource.\n   */\n  batch(apiName?: string): ODataBatchResource {\n    return this.apiFor(apiName).batch();\n  }\n\n  /**\n   * Build a resource for the singleton.\n   * @param path The full path to the singleton.\n   * @param apiNameOrType The name of the API or the type of the singleton.\n   * @returns The singleton resource.\n   */\n  singleton<T>(path: string, apiNameOrType?: string) {\n    return this.apiFor(apiNameOrType).singleton<T>(path);\n  }\n\n  /**\n   * Build a resource for the entity set.\n   * @param path The full path to the entity set.\n   * @param apiNameOrType The name of the API or the type of the entity set.\n   * @returns The entity set resource.\n   */\n  entitySet<T>(\n    path: string,\n    apiNameOrType?: string\n  ): ODataEntitySetResource<T> {\n    return this.apiFor(apiNameOrType).entitySet<T>(path);\n  }\n\n  /**\n   * Build a resource for unbound action.\n   * @param path The full path to the action.\n   * @param apiNameOrType The name of the API or the type of the entity.\n   * @returns The unbound action resource.\n   */\n  action<P, R>(\n    path: string,\n    apiNameOrType?: string\n  ): ODataActionResource<P, R> {\n    return this.apiFor(apiNameOrType).action<P, R>(path);\n  }\n\n  /**\n   * Build a resource for unbound function.\n   * @param path The full path to the function.\n   * @param apiNameOrType The name of the API or the type of the callable.\n   * @returns The unbound function resource.\n   */\n  function<P, R>(\n    path: string,\n    apiNameOrType?: string\n  ): ODataFunctionResource<P, R> {\n    return this.apiFor(apiNameOrType).function<P, R>(path);\n  }\n  //#endregion\n\n  // Request headers, get, post, put, patch... etc\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      params?: HttpParams | { [param: string]: string | string[] };\n      observe: 'events';\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      reportProgress?: boolean;\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<any>>;\n\n  request<R>(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      reportProgress?: boolean;\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<R>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      reportProgress?: boolean;\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  request<R>(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      reportProgress?: boolean;\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<R>>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      responseType?: 'json';\n      reportProgress?: boolean;\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  request<R>(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      responseType?: 'json';\n      reportProgress?: boolean;\n      withCredentials?: boolean;\n    }\n  ): Observable<R>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options?: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      params?: HttpParams | { [param: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<any>;\n\n  request(\n    method: string,\n    resource: ODataResource<any>,\n    options: {\n      body: any | null;\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<any> {\n    let api = options.apiName\n      ? this.settings.apiByName(options.apiName)\n      : resource.api;\n    if (!api)\n      throw new Error(\n        `The types: '[${resource\n          .types()\n          .join(', ')}]' does not belongs to any known configuration`\n      );\n\n    const request = new ODataRequest({\n      method,\n      api,\n      resource,\n      body: options.body,\n      observe: options.observe === 'events' ? 'events' : 'response',\n      etag: options.etag,\n      headers: options.headers,\n      reportProgress: options.reportProgress,\n      params: options.params,\n      responseType: options.responseType,\n      fetchPolicy: options.fetchPolicy,\n      withCredentials: options.withCredentials,\n    });\n\n    return api\n      .request(request)\n      .pipe(\n        map((res: any) =>\n          options.observe === undefined || options.observe === 'body'\n            ? res.body\n            : res\n        )\n      );\n  }\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  delete<T>(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  delete<T>(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<T>>;\n\n  delete(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  delete<T>(\n    resource: ODataResource<any>,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<T>;\n\n  delete(\n    resource: ODataResource<any>,\n    options: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    } = {}\n  ): Observable<any> {\n    return this.request<any>('DELETE', resource, addBody<any>(options, null));\n  }\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  get<T>(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  get<T>(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<T>>;\n\n  get(\n    resource: ODataResource<any>,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  get<T>(\n    resource: ODataResource<any>,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<T>;\n\n  get(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    } = {}\n  ): Observable<any> {\n    return this.request<any>('GET', resource, options as any);\n  }\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  head<T>(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  head<T>(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<T>>;\n\n  head(\n    resource: ODataResource<any>,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  head<T>(\n    resource: ODataResource<any>,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<T>;\n\n  head(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    } = {}\n  ): Observable<any> {\n    return this.request<any>('HEAD', resource, options as any);\n  }\n\n  jsonp(\n    resource: ODataResource<any>,\n    callbackParam: string\n  ): Observable<Object>;\n\n  jsonp<T>(resource: ODataResource<any>, callbackParam: string): Observable<T>;\n\n  jsonp<T>(resource: ODataResource<any>, callbackParam: string): Observable<T> {\n    return this.request<any>('JSONP', resource, {\n      body: null,\n      params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),\n      observe: 'body',\n      responseType: 'json',\n    });\n  }\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  options<T>(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  options<T>(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<T>>;\n\n  options(\n    resource: ODataResource<any>,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  options<T>(\n    resource: ODataResource<any>,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<T>;\n\n  options(\n    resource: ODataResource<any>,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    } = {}\n  ): Observable<any> {\n    return this.request<any>('OPTIONS', resource, options as any);\n  }\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  patch<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  patch<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<T>>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  patch<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<T>;\n\n  patch(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    } = {}\n  ): Observable<any> {\n    return this.request<any>('PATCH', resource, addBody(options, body));\n  }\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  post<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  post<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<T>>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  post<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<T>;\n\n  post(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    } = {}\n  ): Observable<any> {\n    return this.request<any>('POST', resource, addBody(options, body));\n  }\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<ArrayBuffer>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<Blob>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<string>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<Object>>;\n\n  put<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'events';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<string>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<Object>>;\n\n  put<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe: 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<ODataResponse<T>>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<Object>;\n\n  put<T>(\n    resource: ODataResource<any>,\n    body: any | null,\n    options?: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n    }\n  ): Observable<T>;\n\n  put(\n    resource: ODataResource<any>,\n    body: any | null,\n    options: {\n      etag?: string;\n      apiName?: string;\n      fetchPolicy?:\n        | 'cache-first'\n        | 'cache-and-network'\n        | 'network-only'\n        | 'no-cache'\n        | 'cache-only';\n      headers?: HttpHeaders | { [header: string]: string | string[] };\n      observe?: 'body' | 'events' | 'response';\n      params?: HttpParams | { [param: string]: string | string[] };\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    } = {}\n  ): Observable<any> {\n    return this.request<any>('PUT', resource, addBody(options, body));\n  }\n}\n"]}