@opra/client 0.20.3 → 0.22.0

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, HttpHeaders, 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) {
@@ -21,8 +22,8 @@ export class OpraHttpClient {
         });
         this.defaults = {
             ...options?.defaults,
-            headers: options?.defaults?.headers instanceof HttpHeaders
-                ? options?.defaults?.headers : new HttpHeaders(options?.defaults?.headers),
+            headers: options?.defaults?.headers instanceof Headers
+                ? options?.defaults?.headers : new Headers(options?.defaults?.headers),
             params: options?.defaults?.params instanceof HttpParams
                 ? options?.defaults?.params : new HttpParams(options?.defaults?.params)
         };
@@ -37,10 +38,10 @@ 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 HttpHeaders({ 'accept': 'application/json' })
+            headers: new Headers({ 'accept': 'application/json' })
         })));
         return await promise
             .then(async (body) => {
@@ -118,13 +119,13 @@ export class OpraHttpClient {
                     else if (Buffer.isBuffer(request.body)) {
                         contentType = 'application/octet-stream';
                         body = request.body;
-                        request.headers.set('Content-Size', request.body.length);
+                        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', request.body.length);
+                        request.headers.set('Content-Size', String(request.body.length));
                         delete request.duplex;
                     }
                     else {
@@ -146,9 +147,13 @@ export class OpraHttpClient {
                         await interceptor(ctx, request);
                     }
                 }
-                if (observe === 'events')
-                    subscriber.next({ event: 'sent', request });
-                const response = await this._fetch(url, { ...request, headers: request.headers.toObject() });
+                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));
         });
@@ -160,8 +165,8 @@ export class OpraHttpClient {
         return new HttpResponse(init);
     }
     async _handleResponse(observe, subscriber, request, fetchResponse, ctx) {
-        const headers = new HttpHeaders(fetchResponse.headers);
-        if (observe === 'events') {
+        const headers = fetchResponse.headers;
+        if (observe === HttpObserveType.Events) {
             const response = this._createResponse({
                 url: fetchResponse.url,
                 headers,
@@ -169,18 +174,23 @@ 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) {
-            if (JSON_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get('Content-Type') || '')) {
+            if (JSON_CONTENT_TYPE_PATTERN.test(headers.get('Content-Type') || '')) {
                 body = await fetchResponse.json();
                 if (typeof body === 'string')
                     body = JSON.parse(body);
             }
-            else if (TEXT_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get('Content-Type') || ''))
+            else if (TEXT_CONTENT_TYPE_PATTERN.test(headers.get('Content-Type') || ''))
                 body = await fetchResponse.text();
-            else if (FORMDATA_CONTENT_TYPE_PATTERN.test(fetchResponse.headers.get('Content-Type') || ''))
+            else if (FORMDATA_CONTENT_TYPE_PATTERN.test(headers.get('Content-Type') || ''))
                 body = await fetchResponse.formData();
             else {
                 const buf = await fetchResponse.arrayBuffer();
@@ -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,19 +1,24 @@
 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);
         this.contentId = uid(6);
     }
     header(name, value) {
-        this[kRequest].headers.append(name, value);
+        const headers = this[kRequest].headers;
+        if (Array.isArray(value))
+            value.forEach(v => headers.append(name, String(v)));
+        else
+            headers.append(name, value);
         return this;
     }
     param(name, value) {
@@ -21,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-request.js → http-request.js}

@@ -1,5 +1,5 @@
 /// <reference lib="dom" />
-import { HttpHeaders, OpraURL } from '@opra/common';
+import { OpraURL } from '@opra/common';
 const directCopyProperties = ['cache', 'credentials', 'destination', 'headers', 'integrity',
     'keepalive', 'mode', 'redirect', 'referrer', 'referrerPolicy'];
 export class HttpRequest {
@@ -7,7 +7,7 @@ export class HttpRequest {
         this.cache = init?.cache || 'default';
         this.credentials = init?.credentials || 'same-origin';
         this.destination = init?.destination || '';
-        this.headers = new HttpHeaders(init?.headers);
+        this.headers = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
         this.integrity = init?.integrity || '';
         this.keepalive = init?.keepalive ?? false;
         this.method = (init?.method || 'GET').toUpperCase();
@@ -51,9 +51,9 @@ export class HttpRequest {
                 this[k] = update[k];
         });
         if (update.headers) {
-            const h = update.headers instanceof HttpHeaders
+            const h = update.headers instanceof Headers
                 ? update.headers
-                : new HttpHeaders(update.headers);
+                : new Headers(update.headers);
             h.forEach((v, k) => {
                 if (k.toLowerCase() === 'set-cookie') {
                     this.headers.append(k, v);
@@ -69,9 +69,9 @@ export class HttpRequest {
                 this[k] = src[k];
         });
         if (src.headers) {
-            const h = src.headers instanceof HttpHeaders
+            const h = src.headers instanceof Headers
                 ? src.headers
-                : new HttpHeaders(src.headers);
+                : new Headers(src.headers);
             h.forEach((v, k) => {
                 if (k.toLowerCase() === 'set-cookie') {
                     this.headers.append(k, v);

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

@@ -1,19 +1,18 @@
-import { HttpHeaders } from '@opra/common';
 export class HttpResponse {
     constructor(init) {
         /**
          * Returns true if response has body to be received
          */
         this.hasBody = false;
-        this.headers = init?.headers instanceof HttpHeaders ? init?.headers
-            : new HttpHeaders(init?.headers);
+        this.headers = init?.headers instanceof Headers ? init?.headers
+            : new Headers(init?.headers);
         this.status = init?.status || 200;
         this.statusText = init?.statusText || 'OK';
         this.url = init?.url || null;
         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.20.3",
+  "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.20.3",
+    "@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, HttpHeaders, HttpParams } from '@opra/common';
-import { HttpCollectionNode } from './http-collection-node.js';
+import { ApiDocument, HttpParams } from '@opra/common';
+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
@@ -29,7 +29,7 @@ export declare class OpraHttpClient {
         responseInterceptors: ResponseInterceptor[];
     };
     defaults: StrictOmit<HttpRequestDefaults, 'headers' | 'params'> & {
-        headers: HttpHeaders;
+        headers: Headers;
         params: HttpParams;
     };
     constructor(serviceUrl: string, options?: OpraHttpClientOptions);
@@ -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-request.d.ts → http-request.d.ts}

@@ -1,21 +1,23 @@
 /// <reference lib="dom" />
-import { HttpHeaders, HttpParams, OpraURL, OpraURLPath } from '@opra/common';
-export interface HttpRequestInit {
-    cache?: RequestCache;
-    credentials?: RequestCredentials;
-    destination?: RequestDestination;
-    headers?: HttpHeaders.Initiator;
-    integrity?: string;
-    keepalive?: boolean;
-    method?: string;
-    mode?: RequestMode;
-    params?: HttpParams.Initiator;
-    redirect?: RequestRedirect;
-    referrer?: string;
-    referrerPolicy?: ReferrerPolicy;
-    signal?: AbortSignal;
-    url?: string;
-    body?: any;
+import { HttpParams, OpraURL, OpraURLPath } from '@opra/common';
+export declare namespace HttpRequest {
+    interface Initiator {
+        cache?: RequestCache;
+        credentials?: RequestCredentials;
+        destination?: RequestDestination;
+        headers?: HeadersInit;
+        integrity?: string;
+        keepalive?: boolean;
+        method?: string;
+        mode?: RequestMode;
+        params?: HttpParams.Initiator;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal;
+        url?: string;
+        body?: any;
+    }
 }
 export declare class HttpRequest {
     /** Returns the cache mode associated with request, which is a string indicating
@@ -30,7 +32,7 @@ export declare class HttpRequest {
     /** Returns a Headers object consisting of the headers associated with request.
      * Note that headers added in the network layer by the user agent will not be accounted for in this object,
      * e.g., the "Host" header. */
-    headers: HttpHeaders;
+    headers: Headers;
     /** Returns request's subresource integrity metadata, which is a cryptographic
      * hash of the resource being fetched.
      * Its value consists of multiple hashes separated by whitespace. [SRI] */
@@ -60,7 +62,7 @@ export declare class HttpRequest {
     /** Body of the http request */
     body?: any;
     duplex?: 'half';
-    constructor(init?: HttpRequestInit);
+    constructor(init?: HttpRequest.Initiator);
     /** Returns the URL of request as a string. */
     get url(): string;
     set url(value: string);
@@ -68,7 +70,7 @@ export declare class HttpRequest {
     get params(): HttpParams;
     /** Returns the path part of URL as OpraURLPath */
     get path(): OpraURLPath;
-    clone(...update: (HttpRequest | HttpRequestInit)[]): HttpRequest;
-    merge(update: HttpRequest | HttpRequestInit): void;
-    inset(src: HttpRequest | HttpRequestInit): void;
+    clone(...update: (HttpRequest | HttpRequest.Initiator)[]): HttpRequest;
+    merge(update: HttpRequest | HttpRequest.Initiator): void;
+    inset(src: HttpRequest | HttpRequest.Initiator): void;
 }