@opra/client 0.11.7 → 0.12.0

package/typings/http/http-collection-service.d.ts

@@ -1,22 +1,76 @@
-import type { CollectionCreateQueryOptions, CollectionDeleteManyQueryOptions, CollectionGetQueryOptions, CollectionResourceInfo, CollectionSearchQueryOptions, CollectionUpdateManyQueryOptions, CollectionUpdateQueryOptions, PartialInput } from '../common';
-import { HttpResponse } from './http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler } from './http-types.js';
+import { StrictOmit } from 'ts-gems';
+import type { CollectionCreateQueryOptions, CollectionDeleteManyQueryOptions, CollectionGetQueryOptions, CollectionResourceInfo, CollectionSearchQueryOptions, CollectionUpdateManyQueryOptions, CollectionUpdateQueryOptions, HttpResponse, PartialInput } from '../common';
+import { CommonHttpRequestOptions, HttpEvent, HttpRequestHandler } from './http-types.js';
 import { CollectionCreateRequest } from './requests/collection-create-request.js';
 import { CollectionDeleteManyRequest } from './requests/collection-delete-many-request.js';
 import { CollectionDeleteRequest } from './requests/collection-delete-request.js';
 import { CollectionGetRequest } from './requests/collection-get-request.js';
 import { CollectionSearchRequest } from './requests/collection-search-request.js';
-import { CollectionUpdateManyRequest } from './requests/collection-update-many-request.js';
-import { CollectionUpdateRequest } from './requests/collection-update-request.js';
-export declare class HttpCollectionService<T, TResponse extends HttpResponse<T> = HttpResponse<T>> {
+export declare class HttpCollectionService<TType, TResponseExt> {
     readonly resource: CollectionResourceInfo;
     protected _handler: HttpRequestHandler;
     constructor(resource: CollectionResourceInfo, _handler: HttpRequestHandler);
-    create(data: PartialInput<T>, options?: CollectionCreateQueryOptions & CommonHttpRequestOptions): CollectionCreateRequest<T, TResponse>;
-    delete(keyValue: any, options?: CommonHttpRequestOptions): CollectionDeleteRequest<T, TResponse>;
-    deleteMany(options?: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions): CollectionDeleteManyRequest<T, TResponse>;
-    get(keyValue: any, options?: CollectionGetQueryOptions & CommonHttpRequestOptions): CollectionGetRequest<T, TResponse>;
-    search(options?: CollectionSearchQueryOptions & CommonHttpRequestOptions): CollectionSearchRequest<T, TResponse>;
-    update(keyValue: any, data: PartialInput<T>, options?: CollectionUpdateQueryOptions & CommonHttpRequestOptions): CollectionUpdateRequest<T, TResponse>;
-    updateMany(data: PartialInput<T>, options?: CollectionUpdateManyQueryOptions & CommonHttpRequestOptions): CollectionUpdateManyRequest<T, TResponse>;
+    create(data: PartialInput<TType>, options?: CollectionCreateQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): CollectionCreateRequest<TType, TType, HttpResponse<TType> & TResponseExt>;
+    create(data: PartialInput<TType>, options?: CollectionCreateQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): CollectionCreateRequest<HttpResponse<TType> & TResponseExt, TType, HttpResponse<TType> & TResponseExt>;
+    create(data: PartialInput<TType>, options?: CollectionCreateQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): CollectionCreateRequest<HttpEvent, TType, HttpResponse<TType> & TResponseExt>;
+    delete(id: any, options?: StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): CollectionDeleteRequest<never, HttpResponse<never> & TResponseExt>;
+    delete(id: any, options?: StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): CollectionDeleteRequest<HttpResponse<never> & TResponseExt, HttpResponse<never> & TResponseExt>;
+    delete(id: any, options?: StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): CollectionDeleteRequest<HttpEvent, HttpResponse<never> & TResponseExt>;
+    deleteMany(options?: CollectionDeleteManyQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): CollectionDeleteManyRequest<never, HttpResponse<never> & TResponseExt>;
+    deleteMany(options?: CollectionDeleteManyQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): CollectionDeleteManyRequest<HttpResponse<never> & TResponseExt, HttpResponse<never> & TResponseExt>;
+    deleteMany(options?: CollectionDeleteManyQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): CollectionDeleteManyRequest<HttpEvent, HttpResponse<never> & TResponseExt>;
+    get(id: any, options?: CollectionGetQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): CollectionGetRequest<TType, TType, HttpResponse<TType> & TResponseExt>;
+    get(id: any, options?: CollectionGetQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): CollectionGetRequest<HttpResponse<TType> & TResponseExt, TType, HttpResponse<TType> & TResponseExt>;
+    get(id: any, options?: CollectionGetQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): CollectionGetRequest<HttpEvent, TType, HttpResponse<TType> & TResponseExt>;
+    search(options?: CollectionSearchQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): CollectionSearchRequest<TType, TType, HttpResponse<TType> & TResponseExt>;
+    search(options?: CollectionSearchQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): CollectionSearchRequest<HttpResponse<TType> & TResponseExt, TType, HttpResponse<TType> & TResponseExt>;
+    search(options?: CollectionSearchQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): CollectionSearchRequest<HttpEvent, TType, HttpResponse<TType> & TResponseExt>;
+    update(id: any, data: PartialInput<TType>, options?: CollectionUpdateQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): CollectionSearchRequest<TType, TType, HttpResponse<TType> & TResponseExt>;
+    update(id: any, data: PartialInput<TType>, options?: CollectionUpdateQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): CollectionSearchRequest<HttpResponse<TType> & TResponseExt, TType, HttpResponse<TType> & TResponseExt>;
+    update(id: any, data: PartialInput<TType>, options?: CollectionUpdateQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): CollectionSearchRequest<HttpEvent, TType, HttpResponse<TType> & TResponseExt>;
+    updateMany(data: PartialInput<TType>, options?: CollectionUpdateManyQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): CollectionSearchRequest<TType, TType, HttpResponse<TType> & TResponseExt>;
+    updateMany(data: PartialInput<TType>, options?: CollectionUpdateManyQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): CollectionSearchRequest<HttpResponse<TType> & TResponseExt, TType, HttpResponse<TType> & TResponseExt>;
+    updateMany(data: PartialInput<TType>, options?: CollectionUpdateManyQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): CollectionSearchRequest<HttpEvent, TType, HttpResponse<TType> & TResponseExt>;
 }

package/typings/http/http-request-host.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { ClientHttpHeaders, HttpRequest, HttpResponse } from '../common';
+import { CommonHttpRequestOptions, HttpRequestHandler } from './http-types.js';
+declare const kRequest: unique symbol;
+export declare class HttpRequestHost<T, TBody, TResponse extends HttpResponse<TBody>> extends Observable<T> {
+    protected static kHandler: symbol;
+    protected static kRequest: symbol;
+    readonly contentId: string;
+    protected [kRequest]: HttpRequest;
+    constructor(handler: HttpRequestHandler, options?: CommonHttpRequestOptions);
+    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<TResponse>;
+    with(cb: (_this: this) => void): this;
+}
+export {};

package/typings/http/http-singleton-service.d.ts

@@ -1,10 +1,28 @@
-import { SingletonGetQueryOptions, SingletonResourceInfo } from '../common';
-import { HttpResponse } from './http-response.js';
-import { HttpRequestHandler } from './http-types.js';
-import { HttpSingletonGetRequest } from './requests/http-singleton-get-request.js';
-export declare class HttpSingletonService<T, TResponse extends HttpResponse<T> = HttpResponse<T>> {
+import { StrictOmit } from 'ts-gems';
+import { HttpResponse, SingletonGetQueryOptions, SingletonResourceInfo } from '../common';
+import { CommonHttpRequestOptions, HttpEvent, HttpRequestHandler } from './http-types.js';
+import { SingletonDeleteRequest } from './requests/singleton-delete-request.js';
+import { SingletonGetRequest } from './requests/singleton-get-request.js';
+export declare class HttpSingletonService<TType, TResponseExt> {
     readonly resource: SingletonResourceInfo;
     protected _handler: HttpRequestHandler;
     constructor(resource: SingletonResourceInfo, _handler: HttpRequestHandler);
-    get(options?: SingletonGetQueryOptions): HttpSingletonGetRequest<T, TResponse>;
+    get(options?: SingletonGetQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): SingletonGetRequest<TType, TType, HttpResponse<TType> & TResponseExt>;
+    get(options?: SingletonGetQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): SingletonGetRequest<HttpResponse<TType> & TResponseExt, TType, HttpResponse<TType> & TResponseExt>;
+    get(options?: SingletonGetQueryOptions & StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): SingletonGetRequest<HttpEvent, TType, HttpResponse<TType> & TResponseExt>;
+    delete(options?: StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe?: 'body';
+    }): SingletonDeleteRequest<never, HttpResponse<never> & TResponseExt>;
+    delete(options?: StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'response';
+    }): SingletonDeleteRequest<HttpResponse<never> & TResponseExt, HttpResponse<never> & TResponseExt>;
+    delete(options?: StrictOmit<CommonHttpRequestOptions, 'observe'> & {
+        observe: 'events';
+    }): SingletonDeleteRequest<HttpEvent, HttpResponse<never> & TResponseExt>;
 }

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

@@ -1,26 +1,49 @@
-/// <reference types="node" />
-/// <reference lib="dom" />
-import { StrictOmit } from 'ts-gems';
-import { URLSearchParams } from 'url';
-import { ClientHttpHeaders, OpraDocument, OpraURLSearchParams } from '../common';
-import type { HttpResponse } from './http-response';
-export declare type CommonHttpRequestOptions = {
-    observe?: 'body' | 'response';
-    http?: HttpRequestDefaults;
+import { Observable } from 'rxjs';
+import { HttpHeadersInit, HttpParamsInit, HttpRequest, HttpResponse } from '../common';
+export type ObserveType = 'response' | 'body' | 'events';
+export type HttpEventType = 'request' | 'upload-progress' | 'headers-received' | 'download-progress' | 'response';
+export type HttpRequestHandler = (observe: ObserveType, req: HttpRequest) => Observable<any>;
+export type HttpRequestDefaults = Partial<Pick<HttpRequest, 'cache' | 'credentials' | 'destination' | 'integrity' | 'keepalive' | 'mode' | 'redirect' | 'referrer' | 'referrerPolicy'>> & {
+    headers?: HttpHeadersInit;
+    params?: HttpParamsInit;
 };
-export declare type RawHttpRequest = StrictOmit<RequestInit, 'headers' | 'body' | 'method'> & {
-    method: string;
-    path: string;
-    headers?: ClientHttpHeaders;
-    params?: URLSearchParams | OpraURLSearchParams;
-    body?: any;
+export type CommonHttpRequestOptions = {
+    observe?: ObserveType;
+    http?: HttpRequestDefaults;
 };
-export declare type HttpRequestDefaults = Pick<RawHttpRequest, 'headers' | 'params' | 'mode' | 'credentials' | 'cache' | 'redirect' | 'referrer' | 'referrerPolicy' | 'integrity' | 'keepalive' | 'signal'>;
-export declare type HttpRequestHandler<TResult = any> = (req: RawHttpRequest) => Promise<HttpResponse<TResult>>;
-export interface OpraHttpClientOptions {
+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;
     /**
-     * Opra Service Metadata Document
+     * Total number of bytes to download.
+     * Depending on the response, this may not be computable and thus may not be present.
      */
-    document?: OpraDocument;
-    defaults?: HttpRequestDefaults;
+    total?: number;
 }

package/typings/http/requests/batch-request.d.ts

@@ -1,18 +0,0 @@
-import { BatchMultipart } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class BatchRequest extends HttpRequest {
-    protected _handler: HttpRequestHandler;
-    readonly requests: HttpRequest[];
-    options: CommonHttpRequestOptions;
-    protected _results: WeakMap<HttpRequest<any, HttpResponse<any>>, {
-        error?: Error | undefined;
-        response?: HttpResponse<any> | undefined;
-    }>;
-    protected _listeners: Set<(error: Error | undefined, response?: HttpResponse) => void>;
-    constructor(_handler: HttpRequestHandler, requests: HttpRequest[], options?: CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
-    protected _buildBatchMultipart(batch: BatchRequest): BatchMultipart;
-    protected _execute(): Promise<HttpResponse>;
-}

package/typings/http/requests/collection-create-request.d.ts

@@ -1,12 +1,7 @@
-import { CollectionCreateQueryOptions, CollectionResourceInfo, PartialInput } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class CollectionCreateRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
+import { CollectionCreateQueryOptions, CollectionResourceInfo, HttpResponse, PartialInput } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class CollectionCreateRequest<T, TType, TResponse extends HttpResponse<TType>> extends HttpRequestHost<T, TType, TResponse> {
     readonly resource: CollectionResourceInfo;
-    data: PartialInput<T>;
-    options: CollectionCreateQueryOptions & CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, data: PartialInput<T>, options?: CollectionCreateQueryOptions & CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
+    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, data: PartialInput<TType>, options?: CollectionCreateQueryOptions & CommonHttpRequestOptions);
 }

package/typings/http/requests/collection-delete-many-request.d.ts

@@ -1,11 +1,7 @@
-import { CollectionDeleteManyQueryOptions, CollectionResourceInfo } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class CollectionDeleteManyRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
+import { CollectionDeleteManyQueryOptions, CollectionResourceInfo, HttpResponse } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class CollectionDeleteManyRequest<T, TResponse extends HttpResponse<never>> extends HttpRequestHost<T, never, TResponse> {
     readonly resource: CollectionResourceInfo;
-    options: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, options?: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
+    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, options?: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions);
 }

package/typings/http/requests/collection-delete-request.d.ts

@@ -1,12 +1,7 @@
-import { CollectionResourceInfo } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class CollectionDeleteRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
+import { CollectionResourceInfo, HttpResponse } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class CollectionDeleteRequest<T, TResponse extends HttpResponse<never>> extends HttpRequestHost<T, never, TResponse> {
     readonly resource: CollectionResourceInfo;
-    keyValue: any;
-    options: CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, keyValue: any, options?: CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
+    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, id: any, options?: CommonHttpRequestOptions);
 }

package/typings/http/requests/collection-get-request.d.ts

@@ -1,12 +1,7 @@
-import { CollectionGetQueryOptions, CollectionResourceInfo } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class CollectionGetRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
+import { CollectionGetQueryOptions, CollectionResourceInfo, HttpResponse } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class CollectionGetRequest<T, TType, TResponse extends HttpResponse<TType>> extends HttpRequestHost<T, TType, TResponse> {
     readonly resource: CollectionResourceInfo;
-    keyValue: any;
-    options: CollectionGetQueryOptions & CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, keyValue: any, options?: CollectionGetQueryOptions & CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
+    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, id: any, options?: CollectionGetQueryOptions & CommonHttpRequestOptions);
 }

package/typings/http/requests/collection-search-request.d.ts

@@ -1,11 +1,7 @@
-import { CollectionResourceInfo, CollectionSearchQueryOptions } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class CollectionSearchRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
+import { CollectionResourceInfo, CollectionSearchQueryOptions, HttpResponse } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class CollectionSearchRequest<T, TType, TResponse extends HttpResponse<TType>> extends HttpRequestHost<T, TType, TResponse> {
     readonly resource: CollectionResourceInfo;
-    options: CollectionSearchQueryOptions & CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, options?: CollectionSearchQueryOptions & CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
+    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, options?: CollectionSearchQueryOptions & CommonHttpRequestOptions);
 }

package/typings/http/requests/collection-update-many-request.d.ts

@@ -1,12 +1,7 @@
-import { CollectionResourceInfo, CollectionUpdateManyQueryOptions, PartialInput } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class CollectionUpdateManyRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
+import { CollectionResourceInfo, CollectionUpdateManyQueryOptions, HttpResponse, PartialInput } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class CollectionUpdateManyRequest<T, TType, TResponse extends HttpResponse<TType>> extends HttpRequestHost<T, TType, TResponse> {
     readonly resource: CollectionResourceInfo;
-    data: PartialInput<T>;
-    options: CollectionUpdateManyQueryOptions & CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, data: PartialInput<T>, options?: CollectionUpdateManyQueryOptions & CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
+    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, data: PartialInput<TType>, options?: CollectionUpdateManyQueryOptions & CommonHttpRequestOptions);
 }

package/typings/http/requests/collection-update-request.d.ts

@@ -1,13 +1,7 @@
-import { CollectionResourceInfo, CollectionUpdateQueryOptions, PartialInput } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class CollectionUpdateRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
+import { CollectionResourceInfo, CollectionUpdateQueryOptions, HttpResponse, PartialInput } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class CollectionUpdateRequest<T, TType, TResponse extends HttpResponse<TType>> extends HttpRequestHost<T, TType, TResponse> {
     readonly resource: CollectionResourceInfo;
-    keyValue: any;
-    data: PartialInput<T>;
-    options: CollectionUpdateQueryOptions & CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: CollectionResourceInfo, keyValue: any, data: PartialInput<T>, options?: CollectionUpdateQueryOptions & CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
+    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, id: any, data: PartialInput<TType>, options?: CollectionUpdateQueryOptions & CommonHttpRequestOptions);
 }

package/typings/http/requests/singleton-create-request.d.ts

@@ -0,0 +1,7 @@
+import { CollectionCreateQueryOptions, HttpResponse, PartialInput, SingletonResourceInfo } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class SingletonCreateRequest<T, TType, TResponse extends HttpResponse<TType>> extends HttpRequestHost<T, TType, TResponse> {
+    readonly resource: SingletonResourceInfo;
+    constructor(handler: HttpRequestHandler, resource: SingletonResourceInfo, data: PartialInput<TType>, options?: CollectionCreateQueryOptions & CommonHttpRequestOptions);
+}

package/typings/http/requests/singleton-delete-request.d.ts

@@ -0,0 +1,7 @@
+import { HttpResponse, SingletonResourceInfo } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class SingletonDeleteRequest<T, TResponse extends HttpResponse<never>> extends HttpRequestHost<T, never, TResponse> {
+    readonly resource: SingletonResourceInfo;
+    constructor(handler: HttpRequestHandler, resource: SingletonResourceInfo, options?: CommonHttpRequestOptions);
+}

package/typings/http/requests/singleton-get-request.d.ts

@@ -0,0 +1,7 @@
+import { HttpResponse, SingletonGetQueryOptions, SingletonResourceInfo } from '../../common';
+import { HttpRequestHost } from '../http-request-host.js';
+import { CommonHttpRequestOptions, HttpRequestHandler } from '../http-types.js';
+export declare class SingletonGetRequest<T, TType, TResponse extends HttpResponse<TType>> extends HttpRequestHost<T, TType, TResponse> {
+    readonly resource: SingletonResourceInfo;
+    constructor(handler: HttpRequestHandler, resource: SingletonResourceInfo, options?: SingletonGetQueryOptions & CommonHttpRequestOptions);
+}

package/typings/index.d.ts

@@ -1,11 +1,9 @@
 export * from './http/http-client.js';
-export * from './http/http-request.js';
-export * from './http/http-response.js';
+export * from './http/http-request-host.js';
 export * from './http/http-collection-service.js';
 export * from './http/http-singleton-service.js';
 export * from './http/http-types.js';
 export * from './client-error.js';
-export * from './http/requests/batch-request.js';
 export * from './http/requests/collection-create-request.js';
 export * from './http/requests/collection-delete-request.js';
 export * from './http/requests/collection-delete-many-request.js';
@@ -13,7 +11,8 @@ export * from './http/requests/collection-get-request.js';
 export * from './http/requests/collection-search-request.js';
 export * from './http/requests/collection-update-request.js';
 export * from './http/requests/collection-update-many-request.js';
-export * from './http/requests/http-singleton-get-request.js';
+export * from './http/requests/singleton-get-request.js';
+export * from './http/requests/singleton-delete-request.js';
 
 export * from './common/filter/index.js';
 export * from './common/url/index.js';

package/typings/interfaces/http-options.interface.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { URLSearchParams } from 'url';
 import type { ClientHttpHeaders } from '../common';
-export declare type HttpRequestOptions = {
+export type HttpRequestOptions = {
     headers?: ClientHttpHeaders;
     params?: Record<string, string | string[]> | URLSearchParams;
     timeout?: number;

package/typings/interfaces/http-request-config.interface.d.ts

@@ -2,7 +2,7 @@
 import type { URLSearchParams } from 'url';
 import type { ClientHttpHeaders } from '../common';
 import type { HttpRequestOptions } from './http-options.interface.js';
-export declare type HttpRequestConfig = {
+export type HttpRequestConfig = {
     method: string;
     url: string;
     headers?: ClientHttpHeaders;

package/typings/http/http-request.d.ts

@@ -1,25 +0,0 @@
-import { Observable } from 'rxjs';
-import { ClientHttpHeaders } from '../common';
-import { HttpResponse } from './http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from './http-types.js';
-export declare abstract class HttpRequest<TResult = any, TResponse extends HttpResponse<TResult> = HttpResponse<TResult>> extends Observable<TResult | TResponse> {
-    protected _handler: HttpRequestHandler<TResult>;
-    options: CommonHttpRequestOptions;
-    readonly contentId: string;
-    protected _promise?: Promise<TResponse>;
-    protected _headers?: ClientHttpHeaders;
-    protected constructor(_handler: HttpRequestHandler<TResult>, options?: CommonHttpRequestOptions);
-    abstract prepare(): RawHttpRequest;
-    header<K extends keyof ClientHttpHeaders>(name: K, value: ClientHttpHeaders[K]): this;
-    /**
-     * Sends the request
-     */
-    fetch(): Promise<TResponse>;
-    /**
-     * Sends the request and returns response data
-     */
-    resolve(): Promise<TResult | undefined>;
-    with(cb: (_this: this) => void): this;
-    binding(): any;
-    protected _execute(): Promise<TResponse>;
-}

package/typings/http/http-response.d.ts

@@ -1,14 +0,0 @@
-/**
- * Opra Client Response Class
- */
-export interface HttpResponse<TData = any> {
-    readonly headers: Headers;
-    readonly ok: boolean;
-    readonly redirected: boolean;
-    readonly status: number;
-    readonly statusText: string;
-    readonly type: ResponseType;
-    readonly url: string;
-    readonly contentId?: string | null;
-    readonly data: TData;
-}

package/typings/http/requests/http-singleton-get-request.d.ts

@@ -1,11 +0,0 @@
-import { SingletonGetQueryOptions, SingletonResourceInfo } from '../../common';
-import { HttpRequest } from '../http-request.js';
-import { HttpResponse } from '../http-response.js';
-import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';
-export declare class HttpSingletonGetRequest<T, TResponse extends HttpResponse<T> = HttpResponse<T>> extends HttpRequest<T, TResponse> {
-    protected _handler: HttpRequestHandler;
-    readonly resource: SingletonResourceInfo;
-    options: SingletonGetQueryOptions & CommonHttpRequestOptions;
-    constructor(_handler: HttpRequestHandler, resource: SingletonResourceInfo, options?: SingletonGetQueryOptions & CommonHttpRequestOptions);
-    prepare(): RawHttpRequest;
-}

package/typings/http/utils/merge-raw-http-requests.util.d.ts

@@ -1,2 +0,0 @@
-import { RawHttpRequest } from '../http-types.js';
-export declare function mergeRawHttpRequests(target: RawHttpRequest, ...other: (Partial<RawHttpRequest> | undefined)[]): RawHttpRequest;