@opra/client 0.25.5 → 0.26.0

package/esm/impl/http-request-observable.js

@@ -0,0 +1,242 @@
+import { lastValueFrom, Observable } from 'rxjs';
+import { isReadableStreamLike } from 'rxjs/internal/util/isReadableStreamLike';
+import { isBlob, OpraURL } from '@opra/common';
+import { ClientError } from '../client-error.js';
+import { FORMDATA_CONTENT_TYPE_PATTERN, JSON_CONTENT_TYPE_PATTERN, kClient, kContext, OPRA_JSON_CONTENT_TYPE_PATTERN, TEXT_CONTENT_TYPE_PATTERN } from '../constants.js';
+import { HttpObserveType } from '../enums/index.js';
+import { HttpEventType } from '../interfaces/index.js';
+import { HttpRequest } from './http-request.js';
+const directCopyProperties = ['cache', 'credentials', 'destination', 'headers', 'integrity',
+    'keepalive', 'mode', 'redirect', 'referrer', 'referrerPolicy'];
+const kIntlObservable = Symbol.for('kIntlObservable');
+/**
+ * @class HttpRequestObservable
+ */
+export class HttpRequestObservable extends Observable {
+    constructor(client, init) {
+        super((subscriber) => {
+            this[kIntlObservable].subscribe((event) => {
+                if (event.event === HttpEventType.Response) {
+                    subscriber.next(event.response.body);
+                    subscriber.complete();
+                }
+            }, (error) => subscriber.error(error), () => subscriber.complete());
+        });
+        Object.defineProperty(this, kClient, {
+            enumerable: false,
+            value: client
+        });
+        this.request = new HttpRequest(init);
+        if (init?.headers)
+            this.header(init.headers);
+        this[kIntlObservable] = this._send();
+    }
+    httpOptions(options) {
+        directCopyProperties.forEach(k => {
+            if (options[k] !== undefined)
+                this.request[k] = options[k];
+        });
+        return this;
+    }
+    header(arg0, value) {
+        const headers = this.request.headers;
+        if (typeof arg0 === 'object') {
+            const h = arg0 instanceof Headers
+                ? arg0
+                : new Headers(arg0);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    headers.append(k, v);
+                }
+                else
+                    headers.set(k, v);
+            });
+            return this;
+        }
+        if (value == null)
+            headers.delete(arg0);
+        else
+            headers.append(arg0, String(value));
+        return this;
+    }
+    param(arg0, value) {
+        const params = this.request.url.searchParams;
+        if (typeof arg0 === 'object') {
+            const h = arg0 instanceof URLSearchParams
+                ? arg0
+                : new URLSearchParams(arg0);
+            h.forEach((v, k) => params.set(k, v));
+            return this;
+        }
+        if (value == null)
+            params.delete(arg0);
+        else
+            params.set(arg0, String(value));
+        return this;
+    }
+    observe(observe) {
+        return new Observable((subscriber) => {
+            this[kIntlObservable].subscribe((event) => {
+                if (observe === HttpObserveType.Events) {
+                    subscriber.next(event);
+                    return;
+                }
+                if (observe === HttpObserveType.ResponseHeader && event.event === HttpEventType.ResponseHeader) {
+                    subscriber.next(event.response);
+                    subscriber.complete();
+                    return;
+                }
+                if (observe === HttpObserveType.Body && event.event === HttpEventType.Response) {
+                    subscriber.next(event.response.body);
+                    subscriber.complete();
+                    return;
+                }
+                if (event.event === HttpEventType.Response) {
+                    subscriber.next(event.response);
+                    subscriber.complete();
+                }
+            }, (error) => subscriber.error(error), () => subscriber.complete());
+        });
+    }
+    toPromise() {
+        return this.getData();
+    }
+    getData() {
+        return lastValueFrom(this.observe(HttpObserveType.Body));
+    }
+    getResponse() {
+        return lastValueFrom(this.observe(HttpObserveType.Response));
+    }
+    _send() {
+        const request = this.request;
+        const clientContext = this[kClient][kContext];
+        return new Observable(subscriber => {
+            (async () => {
+                // Prepare request
+                this._prepareRequest();
+                // Call request Interceptors
+                for (const interceptor of clientContext.requestInterceptors) {
+                    await interceptor(request);
+                }
+                // Emit 'sent' event
+                subscriber.next({
+                    request,
+                    event: HttpEventType.Sent,
+                });
+                // Send request
+                const url = new OpraURL(request.url, clientContext.serviceUrl);
+                const fetchResponse = await clientContext.fetch(url.toString(), request);
+                // Emit 'response-header' event
+                const headersResponse = clientContext.createResponse({
+                    url: fetchResponse.url,
+                    headers: fetchResponse.headers,
+                    status: fetchResponse.status,
+                    statusText: fetchResponse.statusText,
+                    hasBody: !!fetchResponse.body
+                });
+                subscriber.next({
+                    request,
+                    event: HttpEventType.ResponseHeader,
+                    response: headersResponse
+                });
+                // Parse body
+                const body = fetchResponse.body
+                    ? await this._parseBody(fetchResponse)
+                    : undefined;
+                // Handle errors
+                if (fetchResponse.status >= 400 && fetchResponse.status <= 599) {
+                    subscriber.error(new ClientError({
+                        message: fetchResponse.status + ' ' + fetchResponse.statusText,
+                        status: fetchResponse.status,
+                        issues: body.errors
+                    }));
+                    subscriber.complete();
+                    return;
+                }
+                // Create response
+                const contentType = fetchResponse.headers.get('Content-Type') || '';
+                const responseInit = {
+                    url: fetchResponse.url,
+                    headers: fetchResponse.headers,
+                    status: fetchResponse.status,
+                    statusText: fetchResponse.statusText,
+                    body,
+                };
+                if (OPRA_JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
+                    responseInit.totalCount = body?.totalCount;
+                    responseInit.affected = body?.affected;
+                }
+                const response = clientContext.createResponse(responseInit);
+                // Call response Interceptors
+                for (const interceptor of clientContext.responseInterceptors) {
+                    await interceptor(response);
+                }
+                // Emit 'response' event
+                subscriber.next({
+                    request,
+                    event: HttpEventType.Response,
+                    response
+                });
+                subscriber.complete();
+            })().catch(error => subscriber.error(error));
+        });
+    }
+    _prepareRequest() {
+        const request = this.request;
+        if (request.body) {
+            let body;
+            let contentType;
+            if (typeof request.body === 'string' || typeof request.body === 'number' || typeof request.body === 'boolean') {
+                contentType = 'text/plain;charset=UTF-8"';
+                body = String(request.body);
+                request.headers.delete('Content-Size');
+                delete request.duplex;
+            }
+            else if (isReadableStreamLike(request.body)) {
+                contentType = 'application/octet-stream';
+                body = request.body;
+                request.duplex = 'half';
+            }
+            else if (Buffer.isBuffer(request.body)) {
+                contentType = 'application/octet-stream';
+                body = request.body;
+                request.headers.set('Content-Size', String(request.body.length));
+                delete request.duplex;
+            }
+            else if (isBlob(request.body)) {
+                contentType = request.body.type || 'application/octet-stream';
+                body = request.body;
+                request.headers.set('Content-Size', String(request.body.length));
+                delete request.duplex;
+            }
+            else {
+                contentType = 'application/json';
+                body = JSON.stringify(request.body);
+                request.headers.delete('Content-Size');
+                delete request.duplex;
+            }
+            if (!request.headers.has('Content-Type') && contentType)
+                request.headers.set('Content-Type', contentType);
+            request.body = body;
+        }
+    }
+    async _parseBody(fetchResponse) {
+        let body;
+        const contentType = fetchResponse.headers.get('Content-Type') || '';
+        if (JSON_CONTENT_TYPE_PATTERN.test(contentType)) {
+            body = await fetchResponse.json();
+            if (typeof body === 'string')
+                body = JSON.parse(body);
+        }
+        else if (TEXT_CONTENT_TYPE_PATTERN.test(contentType))
+            body = await fetchResponse.text();
+        else if (FORMDATA_CONTENT_TYPE_PATTERN.test(contentType))
+            body = await fetchResponse.formData();
+        else {
+            const buf = await fetchResponse.arrayBuffer();
+            if (buf.byteLength)
+                body = buf;
+        }
+        return body;
+    }
+}

package/esm/impl/http-request.js

@@ -0,0 +1,24 @@
+/// <reference lib="dom" />
+import { OpraURL } from '@opra/common';
+/**
+ * @class HttpRequest
+ */
+export class HttpRequest {
+    constructor(init) {
+        this.cache = init?.cache || 'default';
+        this.credentials = init?.credentials || 'same-origin';
+        this.destination = init?.destination || '';
+        this.integrity = init?.integrity || '';
+        this.keepalive = init?.keepalive ?? false;
+        this.method = (init?.method || 'GET').toUpperCase();
+        this.mode = init?.mode || 'cors';
+        this.redirect = init?.redirect || 'follow';
+        this.mode = init?.mode || 'cors';
+        this.referrer = init?.referrer || '';
+        this.referrerPolicy = init?.referrerPolicy || '';
+        this.signal = init?.signal || new AbortController().signal;
+        this.body = init?.body;
+        this.url = init?.url instanceof OpraURL ? init.url : new OpraURL(init?.url);
+        this.headers = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
+    }
+}

package/esm/impl/http-service-base.js

@@ -0,0 +1,12 @@
+var _a;
+import { kClient, kContext } from '../constants.js';
+export class HttpServiceBase {
+    constructor(client) {
+        this[_a] = {
+            resource: {},
+            node: null
+        };
+        this[kClient] = client;
+    }
+}
+_a = kContext;

package/esm/impl/singleton-node.js

@@ -0,0 +1,58 @@
+import { toArrayDef } from 'putil-varhelpers';
+import { HttpRequestObservable } from './http-request-observable.js';
+/**
+ * @class HttpSingletonNode
+ */
+export class HttpSingletonNode {
+    constructor(client, path) {
+        this._client = client;
+        this._path = path;
+    }
+    create(data, options) {
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'POST',
+            url: this._path,
+            body: data
+        });
+        if (options?.include)
+            observable.param('include', toArrayDef(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', toArrayDef(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', toArrayDef(options.omit, []).join(','));
+        return observable;
+    }
+    delete() {
+        return new HttpRequestObservable(this._client, {
+            method: 'DELETE',
+            url: this._path
+        });
+    }
+    get(options) {
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'GET',
+            url: this._path
+        });
+        if (options?.include)
+            observable.param('include', toArrayDef(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', toArrayDef(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', toArrayDef(options.omit, []).join(','));
+        return observable;
+    }
+    update(data, options) {
+        const observable = new HttpRequestObservable(this._client, {
+            method: 'PATCH',
+            url: this._path,
+            body: data
+        });
+        if (options?.include)
+            observable.param('include', toArrayDef(options.include, []).join(','));
+        if (options?.pick)
+            observable.param('pick', toArrayDef(options.pick, []).join(','));
+        if (options?.omit)
+            observable.param('omit', toArrayDef(options.omit, []).join(','));
+        return observable;
+    }
+}

package/esm/index.js

@@ -1,9 +1,12 @@
 export * from './client.js';
 export * from './client-error.js';
-export * from './collection-node.js';
-export * from './http-request.js';
-export * from './http-request-observable.js';
-export * from './http-response.js';
-export * from './http-service-base.js';
-export * from './singleton-node.js';
 export * from './types.js';
+export * from './enums/index.js';
+export * from './interfaces/index.js';
+export * from './impl/collection-node.js';
+export * from './impl/singleton-node.js';
+export * from './impl/http-request.js';
+export * from './impl/http-response.js';
+export * from './impl/http-service-base.js';
+export * from './impl/http-request-observable.js';
+export { kClient, kContext } from './constants.js';

package/esm/interfaces/client-context.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/http-event.interface.js

@@ -0,0 +1,32 @@
+/**
+ * Type enumeration for the different kinds of `HttpEvent`.
+ */
+export var HttpEventType;
+(function (HttpEventType) {
+    /**
+     * The request was sent out over the wire.
+     */
+    HttpEventType["Sent"] = "sent";
+    /**
+     * An upload progress event was received.
+     *
+     * Note: The `FetchBackend` doesn't support progress report on uploads.
+     */
+    HttpEventType["UploadProgress"] = "upload-progress";
+    /**
+     * The response status code and headers were received.
+     */
+    HttpEventType["ResponseHeader"] = "response-header";
+    /**
+     * A download progress event was received.
+     */
+    HttpEventType["DownloadProgress"] = "download-progress";
+    /**
+     * The full response including the body was received.
+     */
+    HttpEventType["Response"] = "response";
+    /**
+     * A custom event from an interceptor or a backend.
+     */
+    HttpEventType["Custom"] = "custom";
+})(HttpEventType || (HttpEventType = {}));

package/esm/interfaces/http-request-defaults.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/index.js

@@ -0,0 +1,2 @@
+export * from './http-event.interface.js';
+export * from './http-request-defaults.interface.js';

package/esm/types.js

@@ -1,41 +1 @@
-/* **********************
- * Enums
- *********************** */
-export var HttpObserveType;
-(function (HttpObserveType) {
-    HttpObserveType["Response"] = "response";
-    HttpObserveType["Body"] = "body";
-    HttpObserveType["Events"] = "events";
-})(HttpObserveType || (HttpObserveType = {}));
-/**
- * Type enumeration for the different kinds of `HttpEvent`.
- */
-export var HttpEventType;
-(function (HttpEventType) {
-    /**
-     * The request was sent out over the wire.
-     */
-    HttpEventType["Sent"] = "sent";
-    /**
-     * An upload progress event was received.
-     *
-     * Note: The `FetchBackend` doesn't support progress report on uploads.
-     */
-    HttpEventType["UploadProgress"] = "upload-progress";
-    /**
-     * The response status code and headers were received.
-     */
-    HttpEventType["ResponseHeader"] = "response-header";
-    /**
-     * A download progress event was received.
-     */
-    HttpEventType["DownloadProgress"] = "download-progress";
-    /**
-     * The full response including the body was received.
-     */
-    HttpEventType["Response"] = "response";
-    /**
-     * A custom event from an interceptor or a backend.
-     */
-    HttpEventType["Custom"] = "custom";
-})(HttpEventType || (HttpEventType = {}));
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/client",
-  "version": "0.25.5",
+  "version": "0.26.0",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "@browsery/i18next": "^0.6.0",
     "@browsery/stream": "^0.5.0",
     "@browsery/util": "^0.4.0",
-    "@opra/common": "^0.25.5",
+    "@opra/common": "^0.26.0",
     "accepts": "^1.3.8",
     "buffer": "^6.0.3",
     "cookie": "^0.5.0",

package/types/client.d.ts

@@ -1,45 +1,33 @@
-import { Observable, Subscriber } from 'rxjs';
-import { StrictOmit, Type } from 'ts-gems';
-import { ApiDocument, OpraSchema } from '@opra/common';
-import { HttpCollectionNode } from './collection-node.js';
-import { HttpRequest } from './http-request.js';
-import { HttpResponse } from './http-response.js';
-import { HttpSingletonNode } from './singleton-node.js';
-import { HttpClientContext, HttpEvent, HttpObserveType, HttpRequestDefaults, RequestInterceptor, ResponseInterceptor } from './types.js';
-export interface OpraHttpClientOptions {
-    /**
-     * Opra Service Metadata Document
-     */
-    api?: ApiDocument;
-    /**
-     *
-     */
-    defaults?: HttpRequestDefaults;
-    requestInterceptors?: RequestInterceptor[];
-    responseInterceptors?: ResponseInterceptor[];
-}
-declare const kAssets: unique symbol;
-export declare class OpraHttpClient {
-    protected static kAssets: symbol;
-    protected [kAssets]: {
-        serviceUrl: string;
+import { StrictOmit } from 'ts-gems';
+import { ApiDocument } from '@opra/common';
+import { kContext } from './constants.js';
+import { HttpCollectionNode } from './impl/collection-node.js';
+import { HttpRequestObservable } from './impl/http-request-observable.js';
+import { HttpSingletonNode } from './impl/singleton-node.js';
+import { OpraHttpClientContext } from './interfaces/client-context.interface.js';
+import { HttpRequestDefaults } from './interfaces/index.js';
+import { RequestInterceptor, ResponseInterceptor } from './types.js';
+export declare namespace OpraHttpClient {
+    interface Options {
         api?: ApiDocument;
-        metadataPromise?: Promise<any>;
-        requestInterceptors: RequestInterceptor[];
-        responseInterceptors: ResponseInterceptor[];
-    };
-    defaults: StrictOmit<HttpRequestDefaults, 'headers' | 'params'> & {
+        requestInterceptors?: RequestInterceptor[];
+        responseInterceptors?: ResponseInterceptor[];
+        defaults?: HttpRequestDefaults;
+    }
+    type Defaults = StrictOmit<HttpRequestDefaults, 'headers' | 'params'> & {
         headers: Headers;
         params: URLSearchParams;
     };
-    constructor(serviceUrl: string, options?: OpraHttpClientOptions);
+}
+export declare class OpraHttpClient<TResponseExt = {}> {
+    protected _metadataPromise?: Promise<any>;
+    [kContext]: OpraHttpClientContext;
+    constructor(serviceUrl: string, options?: OpraHttpClient.Options);
     get serviceUrl(): string;
+    get api(): ApiDocument | undefined;
+    get defaults(): OpraHttpClient.Defaults;
     getMetadata(): Promise<ApiDocument>;
-    collection<TType = any>(resourceName: string | Type<TType>): HttpCollectionNode<TType>;
-    singleton<TType = any>(sourceName: string | Type<TType>): HttpSingletonNode<TType>;
-    protected _sendRequest<TBody>(observe: HttpObserveType, request: HttpRequest, sourceKind?: OpraSchema.Resource.Kind, endpoint?: string, ctx?: HttpClientContext): Observable<HttpResponse<TBody> | TBody | HttpEvent>;
-    protected _fetch(url: string, init?: RequestInit): Promise<Response>;
-    protected _createResponse(init?: HttpResponse.Initiator): HttpResponse;
-    protected _handleResponse(observe: HttpObserveType, subscriber: Subscriber<any>, request: HttpRequest, fetchResponse: Response, sourceKind?: OpraSchema.Resource.Kind, endpoint?: string, ctx?: HttpClientContext): Promise<void>;
+    collection<TType = any>(path: string): HttpCollectionNode<TType, TResponseExt>;
+    singleton<TType = any>(path: string): HttpSingletonNode<TType, TResponseExt>;
+    action<T = any>(path: string, params?: Record<string, any>): HttpRequestObservable<T, TResponseExt>;
 }
-export {};

package/types/constants.d.ts

@@ -2,5 +2,5 @@ export declare const OPRA_JSON_CONTENT_TYPE_PATTERN: RegExp;
 export declare const JSON_CONTENT_TYPE_PATTERN: RegExp;
 export declare const TEXT_CONTENT_TYPE_PATTERN: RegExp;
 export declare const FORMDATA_CONTENT_TYPE_PATTERN: RegExp;
-export declare const kRequest: unique symbol;
+export declare const kClient: unique symbol;
 export declare const kContext: unique symbol;

package/types/enums/http-observable-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum HttpObserveType {
+    ResponseHeader = "response-header",
+    Response = "response",
+    Body = "body",
+    Events = "events"
+}

package/types/enums/index.d.ts

@@ -0,0 +1 @@
+export * from './http-observable-type.enum.js';

package/types/impl/collection-node.d.ts

@@ -0,0 +1,66 @@
+import type { PartialInput } from '@opra/common';
+import { OpraFilter } from '@opra/common';
+import type { OpraHttpClient } from '../client.js';
+import { HttpRequestObservable } from './http-request-observable.js';
+/**
+ * @class HttpCollectionNode
+ */
+export declare class HttpCollectionNode<TType, TResponseExt = {}> {
+    protected _client: OpraHttpClient;
+    protected _path: string;
+    constructor(client: OpraHttpClient<any>, path: string);
+    create(data: PartialInput<TType>, options?: HttpCollectionNode.CreateOptions): HttpRequestObservable<TType, TResponseExt>;
+    delete(id: any): HttpRequestObservable<never, TResponseExt>;
+    deleteMany(options?: HttpCollectionNode.DeleteManyOptions): HttpRequestObservable<HttpCollectionNode.DeleteManyBody, TResponseExt>;
+    get(id: any, options?: HttpCollectionNode.GetOptions): HttpRequestObservable<TType, TResponseExt>;
+    findMany(options?: HttpCollectionNode.FindManyOptions): HttpRequestObservable<HttpCollectionNode.FindManyBody<TType>, TResponseExt>;
+    update(id: any, data: PartialInput<TType>, options?: HttpCollectionNode.UpdateOptions): HttpRequestObservable<TType, TResponseExt>;
+    updateMany(data: PartialInput<TType>, options?: HttpCollectionNode.UpdateManyOptions): HttpRequestObservable<HttpCollectionNode.UpdateManyBody, TResponseExt>;
+}
+/**
+ * @namespace
+ */
+export declare namespace HttpCollectionNode {
+    interface CreateOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    }
+    interface DeleteManyOptions {
+        filter?: string | OpraFilter.Expression;
+    }
+    interface GetOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    }
+    interface FindManyOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        filter?: string | OpraFilter.Expression;
+        limit?: number;
+        skip?: number;
+        distinct?: boolean;
+        count?: boolean;
+        sort?: string[];
+    }
+    interface UpdateOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    }
+    interface UpdateManyOptions {
+        filter?: string | OpraFilter.Expression;
+    }
+    interface DeleteManyBody {
+        affected: number;
+    }
+    interface UpdateManyBody {
+        affected: number;
+    }
+    interface FindManyBody<TType> {
+        totalCount?: number;
+        data: TType[];
+    }
+}

package/types/impl/http-request-observable.d.ts

@@ -0,0 +1,45 @@
+import { Observable } from 'rxjs';
+import type { OpraHttpClient } from '../client.js';
+import { kClient } from '../constants.js';
+import { HttpObserveType } from '../enums/index.js';
+import { HttpEvent } from '../interfaces/index.js';
+import { RequestInterceptor, ResponseInterceptor, URLSearchParamsInit } from '../types.js';
+import { HttpRequest } from './http-request.js';
+import { HttpResponse } from './http-response.js';
+/**
+ * @namespace HttpRequestObservable
+ */
+export declare namespace HttpRequestObservable {
+    interface Initiator extends HttpRequest.Initiator {
+        requestInterceptors?: RequestInterceptor[];
+        responseInterceptors?: ResponseInterceptor[];
+    }
+    interface HttpOptions extends Partial<Pick<HttpRequest, 'cache' | 'credentials' | 'destination' | 'integrity' | 'keepalive' | 'mode' | 'redirect' | 'referrer' | 'referrerPolicy'>> {
+    }
+}
+declare const kIntlObservable: unique symbol;
+/**
+ * @class HttpRequestObservable
+ */
+export declare class HttpRequestObservable<TBody = any, TResponseExt = {}> extends Observable<TBody> {
+    [kClient]: OpraHttpClient;
+    [kIntlObservable]: Observable<HttpEvent>;
+    request: HttpRequest;
+    constructor(client: OpraHttpClient<any>, init?: HttpRequestObservable.Initiator);
+    httpOptions(options: HttpRequestObservable.HttpOptions): this;
+    header(headers: HeadersInit): this;
+    header(name: string, value?: string | number | boolean | null): this;
+    param(params: URLSearchParamsInit): this;
+    param(name: string, value: any): this;
+    observe(observe: HttpObserveType.Body): Observable<TBody>;
+    observe(observe: HttpObserveType.ResponseHeader): Observable<HttpResponse<void> & TResponseExt>;
+    observe(observe: HttpObserveType.Response): Observable<HttpResponse<TBody> & TResponseExt>;
+    observe(observe: HttpObserveType.Events): Observable<HttpEvent>;
+    toPromise(): Promise<TBody>;
+    getData(): Promise<TBody>;
+    getResponse(): Promise<HttpResponse<TBody> & TResponseExt>;
+    protected _send(): Observable<HttpEvent>;
+    protected _prepareRequest(): void;
+    protected _parseBody(fetchResponse: Response): Promise<TBody>;
+}
+export {};