@opra/client 0.21.0 → 0.22.0

package/browser.js

@@ -6,6 +6,11 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
+// ../../build/client/esm/client.js
+import { lastValueFrom as lastValueFrom2, Observable as Observable2 } from "rxjs";
+import { isReadableStreamLike } from "rxjs/internal/util/isReadableStreamLike";
+import { DocumentFactory, HttpHeaderCodes, HttpParams, isBlob, joinPath } from "@opra/common";
+
 // ../../build/client/esm/client-error.js
 var ClientError = class extends Error {
   static {
@@ -24,22 +29,17 @@ var ClientError = class extends Error {
   }
 };
 
-// ../../build/client/esm/http/http-client.js
-import { lastValueFrom as lastValueFrom2, Observable as Observable2 } from "rxjs";
-import { isReadableStreamLike } from "rxjs/internal/util/isReadableStreamLike";
-import { DocumentFactory, HttpHeaderCodes, HttpParams, isBlob, joinPath } from "@opra/common";
-
 // ../../build/client/esm/constants.js
 var JSON_CONTENT_TYPE_PATTERN = /^application\/([\w-]+\+)?\bjson\b/i;
 var TEXT_CONTENT_TYPE_PATTERN = /^text\/.*$/i;
 var FORMDATA_CONTENT_TYPE_PATTERN = /^multipart\/\bform-data\b/i;
 var kHttpClientContext = Symbol("kContext");
 
-// ../../build/client/esm/http/http-request-observable.js
+// ../../build/client/esm/http-request-observable.js
 import { lastValueFrom, Observable } from "rxjs";
 import { uid } from "@opra/common";
 
-// ../../build/client/esm/http/http-request.js
+// ../../build/client/esm/http-request.js
 import { OpraURL } from "@opra/common";
 var directCopyProperties = [
   "cache",
@@ -131,7 +131,24 @@ var HttpRequest = class _HttpRequest {
   }
 };
 
-// ../../build/client/esm/http/http-request-observable.js
+// ../../build/client/esm/types.js
+var HttpObserveType;
+(function(HttpObserveType2) {
+  HttpObserveType2["Response"] = "response";
+  HttpObserveType2["Body"] = "body";
+  HttpObserveType2["Events"] = "events";
+})(HttpObserveType || (HttpObserveType = {}));
+var HttpEventType;
+(function(HttpEventType2) {
+  HttpEventType2["Sent"] = "sent";
+  HttpEventType2["UploadProgress"] = "upload-progress";
+  HttpEventType2["ResponseHeader"] = "response-header";
+  HttpEventType2["DownloadProgress"] = "download-progress";
+  HttpEventType2["Response"] = "response";
+  HttpEventType2["Custom"] = "custom";
+})(HttpEventType || (HttpEventType = {}));
+
+// ../../build/client/esm/http-request-observable.js
 var kRequest = Symbol("kRequest");
 var HttpRequestObservable = class extends Observable {
   static {
@@ -139,7 +156,7 @@ var HttpRequestObservable = class extends Observable {
   }
   constructor(context, options) {
     super((subscriber) => {
-      context.send(options?.observe || "body", this[kRequest]).subscribe(subscriber);
+      context.send(options?.observe || HttpObserveType.Body, this[kRequest]).subscribe(subscriber);
     });
     this[kHttpClientContext] = context;
     this[kRequest] = new HttpRequest(options?.http);
@@ -158,7 +175,7 @@ var HttpRequestObservable = class extends Observable {
     return this;
   }
   async fetch(observe) {
-    return lastValueFrom(this[kHttpClientContext].send(observe || "body", this[kRequest]));
+    return lastValueFrom(this[kHttpClientContext].send(observe || HttpObserveType.Body, this[kRequest]));
   }
   with(cb) {
     cb(this);
@@ -168,7 +185,7 @@ var HttpRequestObservable = class extends Observable {
 HttpRequestObservable.kContext = kHttpClientContext;
 HttpRequestObservable.kRequest = kRequest;
 
-// ../../build/client/esm/http/http-collection-node.js
+// ../../build/client/esm/collection-node.js
 var HttpCollectionNode = class {
   static {
     __name(this, "HttpCollectionNode");
@@ -277,7 +294,7 @@ var HttpCollectionNode = class {
   }
 };
 
-// ../../build/client/esm/http/http-response.js
+// ../../build/client/esm/http-response.js
 var HttpResponse = class _HttpResponse {
   static {
     __name(this, "HttpResponse");
@@ -291,14 +308,14 @@ var HttpResponse = class _HttpResponse {
     this.ok = this.status >= 200 && this.status < 300;
     this.body = init?.body;
     this.hasBody = init?.body != null || !!init?.hasBody;
-    this.totalMatches = init?.totalMatches;
+    this.totalCount = init?.totalCount;
   }
   clone(update) {
     return new _HttpResponse({ ...this, ...update });
   }
 };
 
-// ../../build/client/esm/http/http-singleton-node.js
+// ../../build/client/esm/singleton-node.js
 var HttpSingletonNode = class {
   static {
     __name(this, "HttpSingletonNode");
@@ -360,7 +377,7 @@ var HttpSingletonNode = class {
   }
 };
 
-// ../../build/client/esm/http/http-client.js
+// ../../build/client/esm/client.js
 var kAssets = Symbol("kAssets");
 var OpraHttpClient = class {
   static {
@@ -392,7 +409,7 @@ var OpraHttpClient = class {
     if (promise) {
       return promise;
     }
-    this[kAssets].metadataPromise = promise = lastValueFrom2(this._sendRequest("body", new HttpRequest({
+    this[kAssets].metadataPromise = promise = lastValueFrom2(this._sendRequest(HttpObserveType.Body, new HttpRequest({
       method: "GET",
       url: "$metadata",
       headers: new Headers({ "accept": "application/json" })
@@ -492,8 +509,12 @@ var OpraHttpClient = class {
             await interceptor(ctx, request);
           }
         }
-        if (observe === "events")
-          subscriber.next({ event: "sent", request });
+        if (observe === HttpObserveType.Events)
+          subscriber.next({
+            observe,
+            request,
+            event: HttpEventType.Sent
+          });
         const response = await this._fetch(url, request);
         await this._handleResponse(observe, subscriber, request, response);
       })().catch((error) => subscriber.error(error));
@@ -507,7 +528,7 @@ var OpraHttpClient = class {
   }
   async _handleResponse(observe, subscriber, request, fetchResponse, ctx) {
     const headers = fetchResponse.headers;
-    if (observe === "events") {
+    if (observe === HttpObserveType.Events) {
       const response2 = this._createResponse({
         url: fetchResponse.url,
         headers,
@@ -515,7 +536,12 @@ var OpraHttpClient = class {
         statusText: fetchResponse.statusText,
         hasBody: !!fetchResponse.body
       });
-      subscriber.next({ event: "headers-received", request, response: response2 });
+      subscriber.next({
+        observe,
+        request,
+        event: HttpEventType.ResponseHeader,
+        response: response2
+      });
     }
     let body;
     if (fetchResponse.body) {
@@ -533,7 +559,7 @@ var OpraHttpClient = class {
           body = buf;
       }
     }
-    if (observe === "body" && fetchResponse.status >= 400 && fetchResponse.status < 600) {
+    if (observe === HttpObserveType.Body && fetchResponse.status >= 400 && fetchResponse.status < 600) {
       subscriber.error(new ClientError({
         message: fetchResponse.status + " " + fetchResponse.statusText,
         status: fetchResponse.status,
@@ -549,8 +575,8 @@ var OpraHttpClient = class {
       statusText: fetchResponse.statusText,
       body
     };
-    if (fetchResponse.headers.has(HttpHeaderCodes.X_Opra_Total_Matches))
-      responseInit.totalMatches = parseInt(fetchResponse.headers.get(HttpHeaderCodes.X_Opra_Total_Matches), 10);
+    if (fetchResponse.headers.has(HttpHeaderCodes.X_Total_Count))
+      responseInit.totalCount = parseInt(fetchResponse.headers.get(HttpHeaderCodes.X_Total_Count), 10);
     const response = this._createResponse(responseInit);
     if (ctx) {
       const responseInterceptors = [
@@ -561,11 +587,16 @@ var OpraHttpClient = class {
         await interceptor(ctx, observe, request);
       }
     }
-    if (observe === "body") {
+    if (observe === HttpObserveType.Body) {
       subscriber.next(body);
     } else {
-      if (observe === "events")
-        subscriber.next({ event: "response", request, response });
+      if (observe === HttpObserveType.Events)
+        subscriber.next({
+          observe,
+          request,
+          event: HttpEventType.Response,
+          response
+        });
       else
         subscriber.next(response);
     }
@@ -574,7 +605,7 @@ var OpraHttpClient = class {
 };
 OpraHttpClient.kAssets = kAssets;
 
-// ../../build/client/esm/http/http-service-base.js
+// ../../build/client/esm/http-service-base.js
 var HttpServiceBase = class {
   static {
     __name(this, "HttpServiceBase");
@@ -586,6 +617,8 @@ var HttpServiceBase = class {
 export {
   ClientError,
   HttpCollectionNode,
+  HttpEventType,
+  HttpObserveType,
   HttpRequest,
   HttpRequestObservable,
   HttpResponse,

package/cjs/{http/http-client.js → client.js}

@@ -4,12 +4,13 @@ exports.OpraHttpClient = void 0;
 const rxjs_1 = require("rxjs");
 const isReadableStreamLike_1 = require("rxjs/internal/util/isReadableStreamLike");
 const common_1 = require("@opra/common");
-const client_error_js_1 = require("../client-error.js");
-const constants_js_1 = require("../constants.js");
-const http_collection_node_js_1 = require("./http-collection-node.js");
+const client_error_js_1 = require("./client-error.js");
+const collection_node_js_1 = require("./collection-node.js");
+const constants_js_1 = require("./constants.js");
 const http_request_js_1 = require("./http-request.js");
 const http_response_js_1 = require("./http-response.js");
-const http_singleton_node_js_1 = require("./http-singleton-node.js");
+const singleton_node_js_1 = require("./singleton-node.js");
+const types_js_1 = require("./types.js");
 const kAssets = Symbol('kAssets');
 class OpraHttpClient {
     constructor(serviceUrl, options) {
@@ -40,7 +41,7 @@ class OpraHttpClient {
         if (promise) {
             return promise;
         }
-        this[kAssets].metadataPromise = promise = (0, rxjs_1.lastValueFrom)(this._sendRequest('body', new http_request_js_1.HttpRequest({
+        this[kAssets].metadataPromise = promise = (0, rxjs_1.lastValueFrom)(this._sendRequest(types_js_1.HttpObserveType.Body, new http_request_js_1.HttpRequest({
             method: 'GET',
             url: '$metadata',
             headers: new Headers({ 'accept': 'application/json' })
@@ -78,7 +79,7 @@ class OpraHttpClient {
             // ],
             responseInterceptors: []
         };
-        return new http_collection_node_js_1.HttpCollectionNode(ctx);
+        return new collection_node_js_1.HttpCollectionNode(ctx);
     }
     singleton(resourceName) {
         // If name argument is a class, we extract name from the class
@@ -97,7 +98,7 @@ class OpraHttpClient {
             // ],
             responseInterceptors: []
         };
-        return new http_singleton_node_js_1.HttpSingletonNode(ctx);
+        return new singleton_node_js_1.HttpSingletonNode(ctx);
     }
     _sendRequest(observe, request, ctx) {
         return new rxjs_1.Observable(subscriber => {
@@ -149,8 +150,12 @@ class OpraHttpClient {
                         await interceptor(ctx, request);
                     }
                 }
-                if (observe === 'events')
-                    subscriber.next({ event: 'sent', request });
+                if (observe === types_js_1.HttpObserveType.Events)
+                    subscriber.next({
+                        observe,
+                        request,
+                        event: types_js_1.HttpEventType.Sent,
+                    });
                 const response = await this._fetch(url, request);
                 await this._handleResponse(observe, subscriber, request, response);
             })().catch(error => subscriber.error(error));
@@ -164,7 +169,7 @@ class OpraHttpClient {
     }
     async _handleResponse(observe, subscriber, request, fetchResponse, ctx) {
         const headers = fetchResponse.headers;
-        if (observe === 'events') {
+        if (observe === types_js_1.HttpObserveType.Events) {
             const response = this._createResponse({
                 url: fetchResponse.url,
                 headers,
@@ -172,7 +177,12 @@ class OpraHttpClient {
                 statusText: fetchResponse.statusText,
                 hasBody: !!fetchResponse.body
             });
-            subscriber.next({ event: 'headers-received', request, response });
+            subscriber.next({
+                observe,
+                request,
+                event: types_js_1.HttpEventType.ResponseHeader,
+                response
+            });
         }
         let body;
         if (fetchResponse.body) {
@@ -191,7 +201,7 @@ class OpraHttpClient {
                     body = buf;
             }
         }
-        if (observe === 'body' && fetchResponse.status >= 400 && fetchResponse.status < 600) {
+        if (observe === types_js_1.HttpObserveType.Body && fetchResponse.status >= 400 && fetchResponse.status < 600) {
             subscriber.error(new client_error_js_1.ClientError({
                 message: fetchResponse.status + ' ' + fetchResponse.statusText,
                 status: fetchResponse.status,
@@ -207,8 +217,8 @@ class OpraHttpClient {
             statusText: fetchResponse.statusText,
             body
         };
-        if (fetchResponse.headers.has(common_1.HttpHeaderCodes.X_Opra_Total_Matches))
-            responseInit.totalMatches = parseInt(fetchResponse.headers.get(common_1.HttpHeaderCodes.X_Opra_Total_Matches), 10);
+        if (fetchResponse.headers.has(common_1.HttpHeaderCodes.X_Total_Count))
+            responseInit.totalCount = parseInt(fetchResponse.headers.get(common_1.HttpHeaderCodes.X_Total_Count), 10);
         const response = this._createResponse(responseInit);
         if (ctx) {
             const responseInterceptors = [
@@ -219,12 +229,17 @@ class OpraHttpClient {
                 await interceptor(ctx, observe, request);
             }
         }
-        if (observe === 'body') {
+        if (observe === types_js_1.HttpObserveType.Body) {
             subscriber.next(body);
         }
         else {
-            if (observe === 'events')
-                subscriber.next({ event: 'response', request, response });
+            if (observe === types_js_1.HttpObserveType.Events)
+                subscriber.next({
+                    observe,
+                    request,
+                    event: types_js_1.HttpEventType.Response,
+                    response
+                });
             else
                 subscriber.next(response);
         }

package/cjs/{http/http-collection-node.js → collection-node.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpCollectionNode = void 0;
-const constants_js_1 = require("../constants.js");
+const constants_js_1 = require("./constants.js");
 const http_request_observable_js_1 = require("./http-request-observable.js");
 class HttpCollectionNode {
     constructor(context) {

package/cjs/{http/http-request-observable.js → http-request-observable.js}

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpRequestObservable = void 0;
 const rxjs_1 = require("rxjs");
 const common_1 = require("@opra/common");
-const constants_js_1 = require("../constants.js");
+const constants_js_1 = require("./constants.js");
 const http_request_js_1 = require("./http-request.js");
+const types_js_1 = require("./types.js");
 const kRequest = Symbol('kRequest');
 class HttpRequestObservable extends rxjs_1.Observable {
     constructor(context, options) {
         super((subscriber) => {
-            context.send(options?.observe || 'body', this[kRequest]).subscribe((subscriber));
+            context.send(options?.observe || types_js_1.HttpObserveType.Body, this[kRequest]).subscribe((subscriber));
         });
         this[constants_js_1.kHttpClientContext] = context;
         this[kRequest] = new http_request_js_1.HttpRequest(options?.http);
@@ -28,7 +29,7 @@ class HttpRequestObservable extends rxjs_1.Observable {
         return this;
     }
     async fetch(observe) {
-        return (0, rxjs_1.lastValueFrom)(this[constants_js_1.kHttpClientContext].send(observe || 'body', this[kRequest]));
+        return (0, rxjs_1.lastValueFrom)(this[constants_js_1.kHttpClientContext].send(observe || types_js_1.HttpObserveType.Body, this[kRequest]));
     }
     with(cb) {
         cb(this);

package/cjs/{http/http-response.js → http-response.js}

@@ -15,7 +15,7 @@ class HttpResponse {
         this.ok = this.status >= 200 && this.status < 300;
         this.body = init?.body;
         this.hasBody = init?.body != null || !!init?.hasBody;
-        this.totalMatches = init?.totalMatches;
+        this.totalCount = init?.totalCount;
     }
     clone(update) {
         return new HttpResponse({ ...this, ...update });

package/cjs/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./client.js"), exports);
 tslib_1.__exportStar(require("./client-error.js"), exports);
-tslib_1.__exportStar(require("./http/http-client.js"), exports);
-tslib_1.__exportStar(require("./http/http-collection-node.js"), exports);
-tslib_1.__exportStar(require("./http/http-request.js"), exports);
-tslib_1.__exportStar(require("./http/http-request-observable.js"), exports);
-tslib_1.__exportStar(require("./http/http-response.js"), exports);
-tslib_1.__exportStar(require("./http/http-service-base.js"), exports);
-tslib_1.__exportStar(require("./http/http-singleton-node.js"), exports);
-tslib_1.__exportStar(require("./http/http-types.js"), exports);
+tslib_1.__exportStar(require("./collection-node.js"), exports);
+tslib_1.__exportStar(require("./http-request.js"), exports);
+tslib_1.__exportStar(require("./http-request-observable.js"), exports);
+tslib_1.__exportStar(require("./http-response.js"), exports);
+tslib_1.__exportStar(require("./http-service-base.js"), exports);
+tslib_1.__exportStar(require("./singleton-node.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/{http/http-singleton-node.js → singleton-node.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpSingletonNode = void 0;
-const constants_js_1 = require("../constants.js");
+const constants_js_1 = require("./constants.js");
 const http_request_observable_js_1 = require("./http-request-observable.js");
 class HttpSingletonNode {
     constructor(context) {

package/cjs/types.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpEventType = exports.HttpObserveType = void 0;
+/* **********************
+ * Enums
+ *********************** */
+var HttpObserveType;
+(function (HttpObserveType) {
+    HttpObserveType["Response"] = "response";
+    HttpObserveType["Body"] = "body";
+    HttpObserveType["Events"] = "events";
+})(HttpObserveType || (exports.HttpObserveType = HttpObserveType = {}));
+/**
+ * Type enumeration for the different kinds of `HttpEvent`.
+ */
+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 || (exports.HttpEventType = HttpEventType = {}));

package/esm/{http/http-client.js → client.js}

@@ -1,12 +1,13 @@
 import { lastValueFrom, Observable } from 'rxjs';
 import { isReadableStreamLike } from 'rxjs/internal/util/isReadableStreamLike';
-import { DocumentFactory, HttpHeaderCodes, HttpParams, isBlob, joinPath, } from '@opra/common';
-import { ClientError } from '../client-error.js';
-import { FORMDATA_CONTENT_TYPE_PATTERN, JSON_CONTENT_TYPE_PATTERN, TEXT_CONTENT_TYPE_PATTERN } from '../constants.js';
-import { HttpCollectionNode } from './http-collection-node.js';
+import { DocumentFactory, HttpHeaderCodes, HttpParams, isBlob, joinPath } from '@opra/common';
+import { ClientError } from './client-error.js';
+import { HttpCollectionNode } from './collection-node.js';
+import { FORMDATA_CONTENT_TYPE_PATTERN, JSON_CONTENT_TYPE_PATTERN, TEXT_CONTENT_TYPE_PATTERN } from './constants.js';
 import { HttpRequest } from './http-request.js';
 import { HttpResponse } from './http-response.js';
-import { HttpSingletonNode } from './http-singleton-node.js';
+import { HttpSingletonNode } from './singleton-node.js';
+import { HttpEventType, HttpObserveType, } from './types.js';
 const kAssets = Symbol('kAssets');
 export class OpraHttpClient {
     constructor(serviceUrl, options) {
@@ -37,7 +38,7 @@ export class OpraHttpClient {
         if (promise) {
             return promise;
         }
-        this[kAssets].metadataPromise = promise = lastValueFrom(this._sendRequest('body', new HttpRequest({
+        this[kAssets].metadataPromise = promise = lastValueFrom(this._sendRequest(HttpObserveType.Body, new HttpRequest({
             method: 'GET',
             url: '$metadata',
             headers: new Headers({ 'accept': 'application/json' })
@@ -146,8 +147,12 @@ export class OpraHttpClient {
                         await interceptor(ctx, request);
                     }
                 }
-                if (observe === 'events')
-                    subscriber.next({ event: 'sent', request });
+                if (observe === HttpObserveType.Events)
+                    subscriber.next({
+                        observe,
+                        request,
+                        event: HttpEventType.Sent,
+                    });
                 const response = await this._fetch(url, request);
                 await this._handleResponse(observe, subscriber, request, response);
             })().catch(error => subscriber.error(error));
@@ -161,7 +166,7 @@ export class OpraHttpClient {
     }
     async _handleResponse(observe, subscriber, request, fetchResponse, ctx) {
         const headers = fetchResponse.headers;
-        if (observe === 'events') {
+        if (observe === HttpObserveType.Events) {
             const response = this._createResponse({
                 url: fetchResponse.url,
                 headers,
@@ -169,7 +174,12 @@ export class OpraHttpClient {
                 statusText: fetchResponse.statusText,
                 hasBody: !!fetchResponse.body
             });
-            subscriber.next({ event: 'headers-received', request, response });
+            subscriber.next({
+                observe,
+                request,
+                event: HttpEventType.ResponseHeader,
+                response
+            });
         }
         let body;
         if (fetchResponse.body) {
@@ -188,7 +198,7 @@ export class OpraHttpClient {
                     body = buf;
             }
         }
-        if (observe === 'body' && fetchResponse.status >= 400 && fetchResponse.status < 600) {
+        if (observe === HttpObserveType.Body && fetchResponse.status >= 400 && fetchResponse.status < 600) {
             subscriber.error(new ClientError({
                 message: fetchResponse.status + ' ' + fetchResponse.statusText,
                 status: fetchResponse.status,
@@ -204,8 +214,8 @@ export class OpraHttpClient {
             statusText: fetchResponse.statusText,
             body
         };
-        if (fetchResponse.headers.has(HttpHeaderCodes.X_Opra_Total_Matches))
-            responseInit.totalMatches = parseInt(fetchResponse.headers.get(HttpHeaderCodes.X_Opra_Total_Matches), 10);
+        if (fetchResponse.headers.has(HttpHeaderCodes.X_Total_Count))
+            responseInit.totalCount = parseInt(fetchResponse.headers.get(HttpHeaderCodes.X_Total_Count), 10);
         const response = this._createResponse(responseInit);
         if (ctx) {
             const responseInterceptors = [
@@ -216,12 +226,17 @@ export class OpraHttpClient {
                 await interceptor(ctx, observe, request);
             }
         }
-        if (observe === 'body') {
+        if (observe === HttpObserveType.Body) {
             subscriber.next(body);
         }
         else {
-            if (observe === 'events')
-                subscriber.next({ event: 'response', request, response });
+            if (observe === HttpObserveType.Events)
+                subscriber.next({
+                    observe,
+                    request,
+                    event: HttpEventType.Response,
+                    response
+                });
             else
                 subscriber.next(response);
         }

package/esm/{http/http-collection-node.js → collection-node.js}

@@ -1,4 +1,4 @@
-import { kHttpClientContext } from '../constants.js';
+import { kHttpClientContext } from './constants.js';
 import { HttpRequestObservable } from './http-request-observable.js';
 export class HttpCollectionNode {
     constructor(context) {

package/esm/{http/http-request-observable.js → http-request-observable.js}

@@ -1,12 +1,13 @@
 import { lastValueFrom, Observable } from 'rxjs';
 import { uid } from '@opra/common';
-import { kHttpClientContext } from '../constants.js';
+import { kHttpClientContext } from './constants.js';
 import { HttpRequest } from './http-request.js';
+import { HttpObserveType } from './types.js';
 const kRequest = Symbol('kRequest');
 export class HttpRequestObservable extends Observable {
     constructor(context, options) {
         super((subscriber) => {
-            context.send(options?.observe || 'body', this[kRequest]).subscribe((subscriber));
+            context.send(options?.observe || HttpObserveType.Body, this[kRequest]).subscribe((subscriber));
         });
         this[kHttpClientContext] = context;
         this[kRequest] = new HttpRequest(options?.http);
@@ -25,7 +26,7 @@ export class HttpRequestObservable extends Observable {
         return this;
     }
     async fetch(observe) {
-        return lastValueFrom(this[kHttpClientContext].send(observe || 'body', this[kRequest]));
+        return lastValueFrom(this[kHttpClientContext].send(observe || HttpObserveType.Body, this[kRequest]));
     }
     with(cb) {
         cb(this);

package/esm/{http/http-response.js → http-response.js}

@@ -12,7 +12,7 @@ export class HttpResponse {
         this.ok = this.status >= 200 && this.status < 300;
         this.body = init?.body;
         this.hasBody = init?.body != null || !!init?.hasBody;
-        this.totalMatches = init?.totalMatches;
+        this.totalCount = init?.totalCount;
     }
     clone(update) {
         return new HttpResponse({ ...this, ...update });

package/esm/index.js

@@ -1,9 +1,9 @@
+export * from './client.js';
 export * from './client-error.js';
-export * from './http/http-client.js';
-export * from './http/http-collection-node.js';
-export * from './http/http-request.js';
-export * from './http/http-request-observable.js';
-export * from './http/http-response.js';
-export * from './http/http-service-base.js';
-export * from './http/http-singleton-node.js';
-export * from './http/http-types.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';

package/esm/{http/http-singleton-node.js → singleton-node.js}

@@ -1,4 +1,4 @@
-import { kHttpClientContext } from '../constants.js';
+import { kHttpClientContext } from './constants.js';
 import { HttpRequestObservable } from './http-request-observable.js';
 export class HttpSingletonNode {
     constructor(context) {

package/esm/types.js

@@ -0,0 +1,41 @@
+/* **********************
+ * 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 = {}));

package/package.json

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

package/types/{http/http-client.d.ts → client.d.ts}

@@ -1,11 +1,11 @@
 import { Observable, Subscriber } from 'rxjs';
 import { StrictOmit, Type } from 'ts-gems';
 import { ApiDocument, HttpParams } from '@opra/common';
-import { HttpCollectionNode } from './http-collection-node.js';
+import { HttpCollectionNode } from './collection-node.js';
 import { HttpRequest } from './http-request.js';
 import { HttpResponse } from './http-response.js';
-import { HttpSingletonNode } from './http-singleton-node.js';
-import { HttpClientContext, HttpEvent, HttpRequestDefaults, ObserveType, RequestInterceptor, ResponseInterceptor } from './http-types.js';
+import { HttpSingletonNode } from './singleton-node.js';
+import { HttpClientContext, HttpEvent, HttpObserveType, HttpRequestDefaults, RequestInterceptor, ResponseInterceptor } from './types.js';
 export interface OpraHttpClientOptions {
     /**
      * Opra Service Metadata Document
@@ -37,9 +37,9 @@ export declare class OpraHttpClient {
     getMetadata(): Promise<ApiDocument>;
     collection<TType = any>(resourceName: string | Type<TType>): HttpCollectionNode<TType>;
     singleton<TType = any>(resourceName: string | Type<TType>): HttpSingletonNode<TType>;
-    protected _sendRequest<TBody>(observe: ObserveType, request: HttpRequest, ctx?: HttpClientContext): Observable<HttpResponse<TBody> | TBody | HttpEvent>;
+    protected _sendRequest<TBody>(observe: HttpObserveType, request: HttpRequest, ctx?: HttpClientContext): Observable<HttpResponse<TBody> | TBody | HttpEvent>;
     protected _fetch(url: string, init?: RequestInit): Promise<Response>;
     protected _createResponse(init?: HttpResponse.Initiator): HttpResponse;
-    protected _handleResponse(observe: ObserveType, subscriber: Subscriber<any>, request: HttpRequest, fetchResponse: Response, ctx?: HttpClientContext): Promise<void>;
+    protected _handleResponse(observe: HttpObserveType, subscriber: Subscriber<any>, request: HttpRequest, fetchResponse: Response, ctx?: HttpClientContext): Promise<void>;
 }
 export {};

package/types/{http/http-collection-node.d.ts → collection-node.d.ts}

@@ -1,10 +1,10 @@
 import { StrictOmit } from 'ts-gems';
 import type { PartialInput } from '@opra/common';
 import { OpraFilter } from '@opra/common';
-import { kHttpClientContext } from '../constants.js';
+import { kHttpClientContext } from './constants.js';
 import { HttpRequestObservable } from './http-request-observable.js';
 import { HttpResponse } from './http-response.js';
-import { HttpClientContext, HttpEvent } from './http-types.js';
+import { HttpClientContext, HttpEvent, HttpObserveType } from './types.js';
 export declare namespace HttpCollectionNode {
     interface CreateOptions extends HttpRequestObservable.Options {
         pick?: string[];
@@ -51,67 +51,67 @@ export declare class HttpCollectionNode<TType, TResponseExt = {}> {
     protected [kHttpClientContext]: HttpClientContext;
     constructor(context: HttpClientContext);
     create(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.CreateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.CreateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.CreateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     delete(id: any, options?: StrictOmit<HttpCollectionNode.DeleteOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<never, never, TResponseExt>;
     delete(id: any, options?: StrictOmit<HttpCollectionNode.DeleteOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<never>, never, TResponseExt>;
     delete(id: any, options?: StrictOmit<HttpCollectionNode.DeleteOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, never, TResponseExt>;
     deleteMany(options?: StrictOmit<HttpCollectionNode.DeleteManyOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<HttpCollectionNode.DeleteManyBody, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     deleteMany(options?: StrictOmit<HttpCollectionNode.DeleteManyOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<HttpCollectionNode.DeleteManyBody>, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     deleteMany(options?: StrictOmit<HttpCollectionNode.DeleteManyOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     get(id: any, options?: StrictOmit<HttpCollectionNode.GetOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     get(id: any, options?: StrictOmit<HttpCollectionNode.GetOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     get(id: any, options?: StrictOmit<HttpCollectionNode.GetOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'>): HttpRequestObservable<TType[], TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType[], TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType[]>, TType, TResponseExt>;
     findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     update(id: any, data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     update(id: any, data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     update(id: any, data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     updateMany(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateManyOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<HttpCollectionNode.UpdateManyBody, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     updateMany(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateManyOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<HttpCollectionNode.UpdateManyBody>, HttpCollectionNode.DeleteManyBody, TResponseExt>;
     updateMany(data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateManyOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, HttpCollectionNode.UpdateManyBody, TResponseExt>;
 }

package/types/{http/http-request-observable.d.ts → http-request-observable.d.ts}

@@ -1,13 +1,13 @@
 import { Observable } from 'rxjs';
 import { ClientHttpHeaders } from '@opra/common';
-import { kHttpClientContext } from '../constants.js';
+import { kHttpClientContext } from './constants.js';
 import { HttpRequest } from './http-request.js';
 import { HttpResponse } from './http-response.js';
-import { HttpClientContext, HttpRequestDefaults, ObserveType } from './http-types.js';
+import { HttpClientContext, HttpObserveType, HttpRequestDefaults } from './types.js';
 declare const kRequest: unique symbol;
 export declare namespace HttpRequestObservable {
     interface Options {
-        observe?: ObserveType;
+        observe?: HttpObserveType;
         http?: HttpRequestDefaults;
     }
 }
@@ -21,8 +21,8 @@ export declare class HttpRequestObservable<T, TBody, TResponseExt = {}> extends
     header<K extends keyof ClientHttpHeaders>(name: K, value: ClientHttpHeaders[K]): this;
     param(name: string, value: any): this;
     fetch(): Promise<TBody>;
-    fetch(observe: 'body'): Promise<TBody>;
-    fetch(observe: 'response'): Promise<HttpResponse<TBody> & TResponseExt>;
+    fetch(observe: HttpObserveType.Body): Promise<TBody>;
+    fetch(observe: HttpObserveType.Response): Promise<HttpResponse<TBody> & TResponseExt>;
     with(cb: (_this: this) => void): this;
 }
 export {};

package/types/{http/http-response.d.ts → http-response.d.ts}

@@ -6,7 +6,7 @@ export declare namespace HttpResponse {
         url?: string;
         body?: any;
         hasBody?: boolean;
-        totalMatches?: number;
+        totalCount?: number;
     }
 }
 export declare class HttpResponse<TBody = any> {
@@ -34,7 +34,7 @@ export declare class HttpResponse<TBody = any> {
      * Body contents
      */
     readonly body: TBody | null;
-    readonly totalMatches?: number;
+    readonly totalCount?: number;
     /**
      * Returns true if response has body to be received
      */

package/types/{http/http-service-base.d.ts → http-service-base.d.ts}

@@ -1,4 +1,4 @@
-import { OpraHttpClient } from './http-client.js';
+import { OpraHttpClient } from './client.js';
 export declare class HttpServiceBase {
     $client: OpraHttpClient;
     constructor($client: OpraHttpClient);

package/types/index.d.ts

@@ -1,9 +1,9 @@
+export * from './client.js';
 export * from './client-error.js';
-export * from './http/http-client.js';
-export * from './http/http-collection-node.js';
-export * from './http/http-request.js';
-export * from './http/http-request-observable.js';
-export * from './http/http-response.js';
-export * from './http/http-service-base.js';
-export * from './http/http-singleton-node.js';
-export * from './http/http-types.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';

package/types/{http/http-singleton-node.d.ts → singleton-node.d.ts}

@@ -1,9 +1,9 @@
 import { StrictOmit } from 'ts-gems';
 import { PartialInput } from '@opra/common';
-import { kHttpClientContext } from '../constants.js';
+import { kHttpClientContext } from './constants.js';
 import { HttpRequestObservable } from './http-request-observable.js';
 import { HttpResponse } from './http-response.js';
-import { HttpClientContext, HttpEvent } from './http-types.js';
+import { HttpClientContext, HttpEvent, HttpObserveType } from './types.js';
 export declare namespace HttpSingletonNode {
     interface CreateOptions extends HttpRequestObservable.Options {
         pick?: string[];
@@ -27,39 +27,39 @@ export declare class HttpSingletonNode<TType, TResponseExt = {}> {
     protected [kHttpClientContext]: HttpClientContext;
     constructor(context: HttpClientContext);
     create(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.CreateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.CreateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     create(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.CreateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     delete(options?: StrictOmit<HttpSingletonNode.DeleteOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<never, never, TResponseExt>;
     delete(options?: StrictOmit<HttpSingletonNode.DeleteOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<never>, never, TResponseExt>;
     delete(options?: StrictOmit<HttpSingletonNode.DeleteOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, never, TResponseExt>;
     get(options?: StrictOmit<HttpSingletonNode.GetOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     get(options?: StrictOmit<HttpSingletonNode.GetOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     get(options?: StrictOmit<HttpSingletonNode.GetOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     update(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.UpdateOptions, 'observe'> & {
-        observe?: 'body';
+        observe?: HttpObserveType.Body;
     }): HttpRequestObservable<TType, TType, TResponseExt>;
     update(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.UpdateOptions, 'observe'> & {
-        observe: 'response';
+        observe: HttpObserveType.Response;
     }): HttpRequestObservable<HttpResponse<TType>, TType, TResponseExt>;
     update(data: PartialInput<TType>, options?: StrictOmit<HttpSingletonNode.UpdateOptions, 'observe'> & {
-        observe: 'events';
+        observe: HttpObserveType.Events;
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
 }

package/types/types.d.ts

@@ -0,0 +1,111 @@
+import type { Observable } from 'rxjs';
+import type { HttpParams } from '@opra/common';
+import type { OpraHttpClient } from './client';
+import type { HttpRequest } from './http-request.js';
+import type { HttpResponse } from './http-response.js';
+export type HttpRequestHandler = (observe: HttpObserveType, request: HttpRequest) => Observable<any>;
+export type RequestInterceptor = (ctx: HttpClientContext, request: HttpRequest) => void | Promise<void>;
+export type ResponseInterceptor = ((ctx: HttpClientContext, observe: HttpObserveType, response: any) => void | Promise<void>);
+export type HttpEvent = HttpSentEvent | HttpDownloadProgressEvent | HttpUploadProgressEvent | HttpResponseHeaderEvent | HttpResponseEvent | HttpUserEvent;
+export declare enum HttpObserveType {
+    Response = "response",
+    Body = "body",
+    Events = "events"
+}
+/**
+ * Type enumeration for the different kinds of `HttpEvent`.
+ */
+export declare enum HttpEventType {
+    /**
+     * The request was sent out over the wire.
+     */
+    Sent = "sent",
+    /**
+     * An upload progress event was received.
+     *
+     * Note: The `FetchBackend` doesn't support progress report on uploads.
+     */
+    UploadProgress = "upload-progress",
+    /**
+     * The response status code and headers were received.
+     */
+    ResponseHeader = "response-header",
+    /**
+     * A download progress event was received.
+     */
+    DownloadProgress = "download-progress",
+    /**
+     * The full response including the body was received.
+     */
+    Response = "response",
+    /**
+     * A custom event from an interceptor or a backend.
+     */
+    Custom = "custom"
+}
+export interface HttpClientContext {
+    readonly client: OpraHttpClient;
+    readonly resourceName: string;
+    send: HttpRequestHandler;
+    requestInterceptors?: RequestInterceptor[];
+    responseInterceptors?: ResponseInterceptor[];
+}
+export interface HttpRequestDefaults extends Partial<Pick<HttpRequest, 'cache' | 'credentials' | 'destination' | 'integrity' | 'keepalive' | 'mode' | 'redirect' | 'referrer' | 'referrerPolicy'>> {
+    headers?: HeadersInit;
+    params?: HttpParams.Initiator;
+}
+interface HttpEventBase {
+    observe: HttpObserveType;
+    request: HttpRequest;
+    event: HttpEventType;
+}
+export interface HttpSentEvent extends HttpEventBase {
+    event: HttpEventType.Sent;
+}
+export interface HttpDownloadProgressEvent extends HttpEventBase {
+    event: HttpEventType.DownloadProgress;
+    /**
+     * Number of bytes uploaded
+     */
+    loaded: number;
+    /**
+     * Total number of bytes to upload.
+     * Depending on the request, this may not be computable and thus may not be present.
+     */
+    total?: number;
+}
+export interface HttpUploadProgressEvent extends HttpEventBase {
+    event: HttpEventType.UploadProgress;
+    /**
+     * Response object
+     */
+    response: HttpResponse;
+    /**
+     * Number of bytes uploaded
+     */
+    loaded: number;
+    /**
+     * Total number of bytes to upload.
+     * Depending on the request, this may not be computable and thus may not be present.
+     */
+    total?: number;
+}
+export interface HttpResponseHeaderEvent extends HttpEventBase {
+    event: HttpEventType.ResponseHeader;
+    /**
+     * Response object
+     */
+    response: HttpResponse;
+}
+export interface HttpResponseEvent extends HttpEventBase {
+    event: HttpEventType.Response;
+    /**
+     * Response object
+     */
+    response: HttpResponse;
+}
+export interface HttpUserEvent extends HttpEventBase {
+    event: HttpEventType.Custom;
+    [key: string | number | symbol]: any;
+}
+export {};

package/cjs/http/http-types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/esm/http/http-types.js

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

package/types/http/http-types.d.ts

@@ -1,57 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { HttpParams } from '@opra/common';
-import type { OpraHttpClient } from './http-client.js';
-import type { HttpRequest } from './http-request.js';
-import type { HttpResponse } from './http-response.js';
-export type ObserveType = 'response' | 'body' | 'events';
-export type HttpEventType = 'request' | 'upload-progress' | 'headers-received' | 'download-progress' | 'response';
-export type HttpRequestHandler = (observe: ObserveType, request: HttpRequest) => Observable<any>;
-export type RequestInterceptor = (ctx: HttpClientContext, request: HttpRequest) => void | Promise<void>;
-export type ResponseInterceptor = ((ctx: HttpClientContext, observe: ObserveType, response: any) => void | Promise<void>);
-export interface HttpClientContext {
-    readonly client: OpraHttpClient;
-    readonly resourceName: string;
-    send: HttpRequestHandler;
-    requestInterceptors?: RequestInterceptor[];
-    responseInterceptors?: ResponseInterceptor[];
-}
-export type HttpRequestDefaults = Partial<Pick<HttpRequest, 'cache' | 'credentials' | 'destination' | 'integrity' | 'keepalive' | 'mode' | 'redirect' | 'referrer' | 'referrerPolicy'>> & {
-    headers?: HeadersInit;
-    params?: HttpParams.Initiator;
-};
-export interface HttpEvent {
-    event: HttpEventType | string;
-    request: HttpRequest;
-}
-export interface HttpHeadersReceivedEvent extends HttpEvent {
-    event: 'headers-received';
-    response: HttpResponse;
-}
-export interface HttpResponseEvent extends HttpEvent {
-    event: 'response';
-    response: HttpResponse;
-}
-export interface HttpUploadProgressEvent extends HttpEvent {
-    event: 'upload-progress';
-    /**
-     * Number of bytes uploaded
-     */
-    loaded: number;
-    /**
-     * Total number of bytes to upload.
-     * Depending on the request, this may not be computable and thus may not be present.
-     */
-    total?: number;
-}
-export interface HttpDownloadProgressEvent extends HttpEvent {
-    event: 'download-progress';
-    /**
-     * Number of bytes download
-     */
-    loaded: number;
-    /**
-     * Total number of bytes to download.
-     * Depending on the response, this may not be computable and thus may not be present.
-     */
-    total?: number;
-}