@opra/client 0.5.0 → 0.7.0

package/esm/client-request.d.ts

@@ -1,17 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { Observable } from 'rxjs';
-import type { OpraClient } from './client.js';
-import { ClientResponse, CommonQueryOptions } from './types.js';
-export declare abstract class OpraClientRequest<T = any, TResponse extends ClientResponse<T> = ClientResponse<T>> extends Observable<TResponse> {
-    readonly client: OpraClient;
-    protected _send: (req: AxiosRequestConfig) => Promise<TResponse>;
-    options: CommonQueryOptions;
-    readonly id: string;
-    protected _promise?: Promise<TResponse>;
-    protected constructor(client: OpraClient, _send: (req: AxiosRequestConfig) => Promise<TResponse>, options?: CommonQueryOptions);
-    abstract prepare(): AxiosRequestConfig;
-    toPromise(): Promise<TResponse>;
-    execute(): Promise<TResponse>;
-    protected _execute(): Promise<TResponse>;
-    binding(): any;
-}

package/esm/client-request.js

@@ -1,44 +0,0 @@
-import { Observable } from 'rxjs';
-import { uid } from 'uid';
-import { HeadersMap } from '@opra/common';
-export class OpraClientRequest extends Observable {
-    client;
-    _send;
-    options;
-    id;
-    _promise;
-    constructor(client, _send, options = {}) {
-        super((subscriber) => {
-            this.execute().then(v => {
-                subscriber.next(v);
-                subscriber.complete();
-            }).catch(e => subscriber.error(e));
-        });
-        this.client = client;
-        this._send = _send;
-        this.options = options;
-        this.id = uid(10);
-        this.options = options;
-    }
-    async toPromise() {
-        return this.execute();
-    }
-    async execute() {
-        const promise = this._promise || (this._promise = this._execute());
-        return await promise;
-    }
-    async _execute() {
-        const req = this.prepare();
-        const headers = this.options.http?.headers
-            ? new HeadersMap({ ...req.headers, ...this.options.http.headers }).toObject()
-            : req.headers;
-        return this._send({
-            ...this.options.http,
-            ...req,
-            headers
-        });
-    }
-    binding() {
-        return {};
-    }
-}

package/esm/client.d.ts

@@ -1,34 +0,0 @@
-import { AxiosInstance, AxiosInterceptorManager, AxiosRequestConfig, AxiosResponse } from 'axios';
-import { TaskQueue } from 'power-tasks';
-import { Type } from 'ts-gems';
-import { OpraDocument } from '@opra/schema';
-import { OpraClientRequest } from './client-request.js';
-import { CollectionNode } from './services/collection-node.js';
-import { SingletonNode } from './services/singleton-node.js';
-import { ClientAdapter, ClientResponse, HttpRequestOptions } from './types.js';
-export interface OpraClientOptions {
-    adapter?: ClientAdapter;
-    defaults?: HttpRequestOptions;
-    invalidateCache?: boolean;
-    concurrency?: number;
-    maxQueue?: number;
-}
-export declare class OpraClient {
-    protected _axios: AxiosInstance;
-    protected _metadata: OpraDocument;
-    protected _taskQueue: TaskQueue;
-    constructor(serviceUrl: string, options?: OpraClientOptions);
-    constructor(serviceUrl: string, metadata: OpraDocument, options?: OpraClientOptions);
-    get requestInterceptors(): AxiosInterceptorManager<AxiosRequestConfig>;
-    get responseInterceptors(): AxiosInterceptorManager<AxiosResponse>;
-    get serviceUrl(): string;
-    get initialized(): boolean;
-    get metadata(): OpraDocument;
-    init(): Promise<void>;
-    batch<TResponse extends ClientResponse<any> = ClientResponse<any>>(requests: OpraClientRequest[]): OpraClientRequest<any, TResponse>;
-    collection<T = any, TResponse extends ClientResponse<T> = ClientResponse<T>>(name: string): CollectionNode<T, TResponse>;
-    singleton<T = any, TResponse extends ClientResponse<T> = ClientResponse<T>>(name: string): SingletonNode<T, TResponse>;
-    protected _send<TResponse extends ClientResponse>(req: AxiosRequestConfig): Promise<TResponse>;
-    protected _assertMetadata(): void;
-    static create<T extends OpraClient>(this: Type<T>, serviceUrl: string, options?: OpraClientOptions): Promise<T>;
-}

package/esm/client.js

@@ -1,134 +0,0 @@
-import axios from 'axios';
-import { TaskQueue } from 'power-tasks';
-import { ResponsiveMap } from '@opra/common';
-import { OpraDocument } from '@opra/schema';
-import { normalizePath } from '@opra/url';
-import { ClientError } from './client-error.js';
-import { BatchRequest } from './requests/batch-request.js';
-import { CollectionNode } from './services/collection-node.js';
-import { SingletonNode } from './services/singleton-node.js';
-const documentCache = new Map();
-const documentCacheResolvers = new Map();
-export class OpraClient {
-    _axios;
-    _metadata;
-    _taskQueue;
-    constructor(serviceUrl, arg1, arg2) {
-        let options;
-        if (arg1 instanceof OpraDocument) {
-            this._metadata = arg1;
-            options = arg2;
-        }
-        else
-            options = arg1 || arg2;
-        this._taskQueue = new TaskQueue({
-            maxQueue: options?.maxQueue,
-            concurrency: options?.concurrency
-        });
-        this._axios = axios.create();
-        this._axios.defaults.baseURL = normalizePath(serviceUrl);
-        this._axios.defaults.adapter = options?.adapter;
-        if (options?.defaults?.headers)
-            this._axios.defaults.headers.common = options.defaults.headers;
-        this._axios.defaults.auth = options?.defaults?.auth;
-        this._axios.defaults.timeout = options?.defaults?.timeout;
-        this._axios.defaults.timeoutErrorMessage = options?.defaults?.timeoutErrorMessage;
-        this._axios.defaults.xsrfCookieName = options?.defaults?.xsrfCookieName;
-        this._axios.defaults.xsrfHeaderName = options?.defaults?.xsrfHeaderName;
-        this._axios.defaults.maxRedirects = options?.defaults?.maxRedirects;
-        this._axios.defaults.maxRate = options?.defaults?.maxRate;
-        this._axios.defaults.httpAgent = options?.defaults?.httpAgent;
-        this._axios.defaults.httpsAgent = options?.defaults?.httpsAgent;
-        this._axios.defaults.proxy = options?.defaults?.proxy;
-        this._axios.defaults.validateStatus = options?.defaults?.validateStatus;
-        const document = documentCache.get(serviceUrl.toLowerCase());
-        if (document)
-            this._metadata = document;
-    }
-    get requestInterceptors() {
-        return this._axios.interceptors.request;
-    }
-    get responseInterceptors() {
-        return this._axios.interceptors.response;
-    }
-    get serviceUrl() {
-        return this._axios.defaults.baseURL || '';
-    }
-    get initialized() {
-        return !!this._metadata;
-    }
-    get metadata() {
-        this._assertMetadata();
-        return this._metadata;
-    }
-    async init() {
-        let promise = documentCacheResolvers.get(this.serviceUrl.toLowerCase());
-        if (promise) {
-            await promise;
-            return;
-        }
-        promise = this._send({
-            method: 'GET',
-            url: '/$metadata',
-        });
-        documentCacheResolvers.set(this.serviceUrl.toLowerCase(), promise);
-        try {
-            const resp = await promise;
-            this._metadata = new OpraDocument(resp.data);
-        }
-        finally {
-            documentCacheResolvers.delete(this.serviceUrl.toLowerCase());
-        }
-    }
-    batch(requests) {
-        this._assertMetadata();
-        return new BatchRequest(this, requests, req => this._send(req));
-    }
-    collection(name) {
-        this._assertMetadata();
-        const resource = this.metadata.getCollectionResource(name);
-        return new CollectionNode(this, resource, req => this._send(req));
-    }
-    singleton(name) {
-        this._assertMetadata();
-        const resource = this.metadata.getSingletonResource(name);
-        return new SingletonNode(this, resource, req => this._send(req));
-    }
-    async _send(req) {
-        return this._taskQueue.enqueue(async () => {
-            const resp = await this._axios.request({
-                ...req,
-                validateStatus: () => true
-            });
-            if ((resp.status >= 400 && resp.status < 600) &&
-                (this._axios.defaults.validateStatus && !this._axios.defaults.validateStatus(resp.status))) {
-                throw new ClientError({
-                    message: resp.status + ' ' + resp.statusText,
-                    status: resp.status,
-                    issues: resp.data.errors
-                });
-            }
-            const rawHeaders = (typeof resp.headers.toJSON === 'function'
-                ? resp.headers.toJSON()
-                : { ...resp.headers });
-            const headers = new ResponsiveMap(rawHeaders);
-            return {
-                status: resp.status,
-                statusText: resp.statusText,
-                data: resp.data,
-                rawHeaders,
-                headers
-            };
-        }).toPromise();
-    }
-    _assertMetadata() {
-        if (!this._metadata)
-            throw new Error('You must call init() to before using the client instance');
-    }
-    static async create(serviceUrl, options) {
-        const client = new this(serviceUrl, options);
-        if (!client._metadata)
-            await client.init();
-        return client;
-    }
-}

package/esm/requests/batch-request.d.ts

@@ -1,19 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import type { OpraClient } from '../client.js';
-import { OpraClientRequest } from '../client-request.js';
-import { ClientResponse, CommonQueryOptions, OpraBatchRequestOptions } from '../types.js';
-export declare const CRLF = "\r\n";
-export declare class BatchRequest<TResponse extends ClientResponse = ClientResponse>// todo
- extends OpraClientRequest<any, TResponse> {
-    readonly client: OpraClient;
-    readonly requests: OpraClientRequest[];
-    options: OpraBatchRequestOptions & CommonQueryOptions;
-    protected _results: WeakMap<OpraClientRequest<any, ClientResponse<any>>, {
-        error?: Error | undefined;
-        response?: ClientResponse<any> | undefined;
-    }>;
-    protected _listeners: Set<(error: Error | undefined, response?: ClientResponse) => void>;
-    constructor(client: OpraClient, requests: OpraClientRequest[], send: (req: AxiosRequestConfig) => Promise<TResponse>, options?: OpraBatchRequestOptions & CommonQueryOptions);
-    prepare(): AxiosRequestConfig;
-    protected _execute(): Promise<TResponse>;
-}

package/esm/requests/batch-request.js

@@ -1,131 +0,0 @@
-import Highland from 'highland';
-import { uid } from 'uid';
-import { HeadersMap } from '@opra/common';
-import { OpraURL } from '@opra/url';
-import { OpraClientRequest } from '../client-request.js';
-export const CRLF = '\r\n';
-export class BatchRequest// todo
- extends OpraClientRequest {
-    client;
-    requests;
-    options;
-    _results = new WeakMap();
-    _listeners = new Set();
-    constructor(client, requests, send, options = {}) {
-        super(client, send, options);
-        this.client = client;
-        this.requests = requests;
-        this.options = options;
-        requests.forEach(request => {
-            Object.defineProperty(request, '_execute', {
-                writable: true,
-                enumerable: false,
-                configurable: true,
-                value: () => {
-                    return new Promise((resolve, reject) => {
-                        const x = this._results.get(request);
-                        if (x) {
-                            if (x.error)
-                                return reject(x.error);
-                            return resolve(x.response);
-                        }
-                        const callback = (e, r) => {
-                            this._listeners.delete(callback);
-                            if (e)
-                                return reject(e);
-                            resolve(r);
-                        };
-                        this._listeners.add(callback);
-                    });
-                }
-            });
-        });
-    }
-    prepare() {
-        const { boundary, stream } = buildBatchStream(this);
-        const headers = {
-            'Content-Type': 'multipart/mixed;boundary=' + boundary
-        };
-        const url = new OpraURL(this.client.serviceUrl);
-        url.path.join('/$batch');
-        return {
-            method: 'POST',
-            url: url.address,
-            params: url.searchParams,
-            headers,
-            data: stream
-        };
-    }
-    async _execute() {
-        const req = this.prepare();
-        return this._send(req);
-    }
-}
-function buildBatchStream(batch) {
-    const chunks = [];
-    let batchIndex = 0;
-    let level = 0;
-    const processBatch = (_batch) => {
-        const boundary = `batch_${++batchIndex}_L${level}_${uid(10)}`;
-        for (const req of _batch.requests) {
-            chunks.push('--' + boundary + CRLF);
-            if (req instanceof BatchRequest) {
-                const contentHeaderIndex = chunks.push('');
-                chunks.push('Content-Transfer-Encoding: binary' + CRLF + CRLF);
-                level++;
-                const subBoundary = processBatch(req);
-                level--;
-                processBatch[contentHeaderIndex] = 'Content-Type: multipart/mixed;boundary=' + subBoundary + CRLF;
-                continue;
-            }
-            const prepared = req.prepare();
-            let s = 'Content-Type: application/http' + CRLF +
-                'Content-Transfer-Encoding: binary' + CRLF +
-                'Content-ID:' + req.id + CRLF +
-                CRLF +
-                (prepared.method || 'GET').toUpperCase() + ' ' + prepared.url + ' HTTP/1.1' + CRLF;
-            const headers = new HeadersMap(prepared.headers);
-            let data;
-            let contentType = '';
-            if (prepared.data) {
-                if (typeof prepared.data === 'string') {
-                    contentType = 'text/plain; charset=utf-8';
-                    data = prepared.data;
-                }
-                else if (Highland.isStream(prepared.data) || Buffer.isBuffer(prepared.data)) {
-                    data = prepared.data;
-                }
-                else if (typeof prepared.data.stream === 'function') {
-                    contentType = prepared.data.type || 'binary';
-                    data = prepared.data.stream(); // File and Blob
-                }
-                else if (typeof prepared.data === 'object') {
-                    contentType = 'application/json; charset=utf-8';
-                    data = JSON.stringify(prepared.data);
-                }
-                else
-                    throw new TypeError(`Invalid data type ${typeof prepared.data}`);
-            }
-            if (contentType && !headers.has('Content-Type'))
-                headers.set('Content-Type', contentType);
-            headers.forEach((v, k) => {
-                s += k + ': ' + (Array.isArray(v) ? v.join(';') : v) + CRLF;
-            });
-            if (data) {
-                if (typeof data === 'string')
-                    chunks.push(s + CRLF + data + CRLF + CRLF);
-                else {
-                    chunks.push(s + CRLF);
-                    chunks.push(data);
-                    chunks.push(CRLF + CRLF);
-                }
-            }
-            else
-                chunks.push(s + CRLF + CRLF);
-        }
-        chunks.push('--' + boundary + '--' + CRLF);
-        return boundary;
-    };
-    const boundary = processBatch(batch);
-    return { boundary, stream: Highland(chunks).flatten() };
-}

package/esm/requests/collection-create-request.d.ts

@@ -1,13 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { CollectionCreateQueryOptions, CollectionResourceInfo } from '@opra/schema';
-import type { OpraClient } from '../client.js';
-import { OpraClientRequest } from '../client-request.js';
-import { ClientResponse, CommonQueryOptions, PartialInput } from '../types.js';
-export declare class CollectionCreateRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
-    readonly client: OpraClient;
-    readonly resource: CollectionResourceInfo;
-    data: PartialInput<T>;
-    options: CollectionCreateQueryOptions & CommonQueryOptions;
-    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, data: PartialInput<T>, options?: CollectionCreateQueryOptions & CommonQueryOptions);
-    prepare(): AxiosRequestConfig;
-}

package/esm/requests/collection-create-request.js

@@ -1,31 +0,0 @@
-import { OpraURL } from '@opra/url';
-import { OpraClientRequest } from '../client-request.js';
-export class CollectionCreateRequest extends OpraClientRequest {
-    client;
-    resource;
-    data;
-    options;
-    constructor(client, send, resource, data, options = {}) {
-        super(client, send, options);
-        this.client = client;
-        this.resource = resource;
-        this.data = data;
-        this.options = options;
-    }
-    prepare() {
-        const url = new OpraURL(this.client.serviceUrl);
-        url.path.join(this.resource.name);
-        if (this.options.include)
-            url.searchParams.set('$include', this.options.include);
-        if (this.options.pick)
-            url.searchParams.set('$pick', this.options.pick);
-        if (this.options.omit)
-            url.searchParams.set('$omit', this.options.omit);
-        return {
-            method: 'POST',
-            url: url.address,
-            data: this.data,
-            params: url.searchParams
-        };
-    }
-}

package/esm/requests/collection-delete-many-request.d.ts

@@ -1,12 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { CollectionDeleteManyQueryOptions, CollectionResourceInfo } from '@opra/schema';
-import type { OpraClient } from '../client.js';
-import { OpraClientRequest } from '../client-request.js';
-import { ClientResponse, CommonQueryOptions } from '../types.js';
-export declare class CollectionDeleteManyRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
-    readonly client: OpraClient;
-    readonly resource: CollectionResourceInfo;
-    options: CollectionDeleteManyQueryOptions & CommonQueryOptions;
-    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, options?: CollectionDeleteManyQueryOptions & CommonQueryOptions);
-    prepare(): AxiosRequestConfig;
-}

package/esm/requests/collection-delete-many-request.js

@@ -1,24 +0,0 @@
-import { OpraURL } from '@opra/url';
-import { OpraClientRequest } from '../client-request.js';
-export class CollectionDeleteManyRequest extends OpraClientRequest {
-    client;
-    resource;
-    options;
-    constructor(client, send, resource, options = {}) {
-        super(client, send, options);
-        this.client = client;
-        this.resource = resource;
-        this.options = options;
-    }
-    prepare() {
-        const url = new OpraURL(this.client.serviceUrl);
-        url.path.join(this.resource.name);
-        if (this.options.filter)
-            url.searchParams.set('$filter', this.options.filter);
-        return {
-            method: 'DELETE',
-            url: url.address,
-            params: url.searchParams
-        };
-    }
-}

package/esm/requests/collection-delete-request.d.ts

@@ -1,13 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { CollectionResourceInfo } from '@opra/schema';
-import type { OpraClient } from '../client.js';
-import { OpraClientRequest } from '../client-request.js';
-import { ClientResponse, CommonQueryOptions } from '../types.js';
-export declare class CollectionDeleteRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
-    readonly client: OpraClient;
-    readonly resource: CollectionResourceInfo;
-    keyValue: any;
-    options: CommonQueryOptions;
-    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, keyValue: any, options?: CommonQueryOptions);
-    prepare(): AxiosRequestConfig;
-}

package/esm/requests/collection-delete-request.js

@@ -1,25 +0,0 @@
-import { OpraURL } from '@opra/url';
-import { OpraClientRequest } from '../client-request.js';
-export class CollectionDeleteRequest extends OpraClientRequest {
-    client;
-    resource;
-    keyValue;
-    options;
-    constructor(client, send, resource, keyValue, options = {}) {
-        super(client, send, options);
-        this.client = client;
-        this.resource = resource;
-        this.keyValue = keyValue;
-        this.options = options;
-    }
-    prepare() {
-        const url = new OpraURL(this.client.serviceUrl);
-        url.path.join(this.resource.name);
-        url.path.get(url.path.size - 1).key = this.keyValue;
-        return {
-            method: 'DELETE',
-            url: url.address,
-            params: url.searchParams
-        };
-    }
-}

package/esm/requests/collection-get-request.d.ts

@@ -1,13 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { CollectionGetQueryOptions, CollectionResourceInfo } from '@opra/schema';
-import type { OpraClient } from '../client.js';
-import { OpraClientRequest } from '../client-request.js';
-import { ClientResponse, CommonQueryOptions } from '../types.js';
-export declare class CollectionGetRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
-    readonly client: OpraClient;
-    readonly resource: CollectionResourceInfo;
-    keyValue: any;
-    options: CollectionGetQueryOptions & CommonQueryOptions;
-    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, keyValue: any, options?: CollectionGetQueryOptions & CommonQueryOptions);
-    prepare(): AxiosRequestConfig;
-}

package/esm/requests/collection-get-request.js

@@ -1,31 +0,0 @@
-import { OpraURL } from '@opra/url';
-import { OpraClientRequest } from '../client-request.js';
-export class CollectionGetRequest extends OpraClientRequest {
-    client;
-    resource;
-    keyValue;
-    options;
-    constructor(client, send, resource, keyValue, options = {}) {
-        super(client, send, options);
-        this.client = client;
-        this.resource = resource;
-        this.keyValue = keyValue;
-        this.options = options;
-    }
-    prepare() {
-        const url = new OpraURL(this.client.serviceUrl);
-        url.path.join(this.resource.name);
-        url.path.get(url.path.size - 1).key = this.keyValue;
-        if (this.options.include)
-            url.searchParams.set('$include', this.options.include);
-        if (this.options.pick)
-            url.searchParams.set('$pick', this.options.pick);
-        if (this.options.omit)
-            url.searchParams.set('$omit', this.options.omit);
-        return {
-            method: 'GET',
-            url: url.address,
-            params: url.searchParams
-        };
-    }
-}

package/esm/requests/collection-search-request.d.ts

@@ -1,12 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { CollectionResourceInfo, CollectionSearchQueryOptions } from '@opra/schema';
-import type { OpraClient } from '../client.js';
-import { OpraClientRequest } from '../client-request.js';
-import { ClientResponse, CommonQueryOptions } from '../types.js';
-export declare class CollectionSearchRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
-    readonly client: OpraClient;
-    readonly resource: CollectionResourceInfo;
-    options: CollectionSearchQueryOptions & CommonQueryOptions;
-    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, options?: CollectionSearchQueryOptions & CommonQueryOptions);
-    prepare(): AxiosRequestConfig;
-}

package/esm/requests/collection-search-request.js

@@ -1,40 +0,0 @@
-import { OpraURL } from '@opra/url';
-import { OpraClientRequest } from '../client-request.js';
-export class CollectionSearchRequest extends OpraClientRequest {
-    client;
-    resource;
-    options;
-    constructor(client, send, resource, options = {}) {
-        super(client, send, options);
-        this.client = client;
-        this.resource = resource;
-        this.options = options;
-    }
-    prepare() {
-        const url = new OpraURL(this.client.serviceUrl);
-        url.path.join(this.resource.name);
-        if (this.options.include)
-            url.searchParams.set('$include', this.options.include);
-        if (this.options.pick)
-            url.searchParams.set('$pick', this.options.pick);
-        if (this.options.omit)
-            url.searchParams.set('$omit', this.options.omit);
-        if (this.options.sort)
-            url.searchParams.set('$sort', this.options.sort);
-        if (this.options.filter)
-            url.searchParams.set('$filter', this.options.filter);
-        if (this.options.limit != null)
-            url.searchParams.set('$limit', this.options.limit);
-        if (this.options.skip != null)
-            url.searchParams.set('$skip', this.options.skip);
-        if (this.options.count != null)
-            url.searchParams.set('$count', this.options.count);
-        if (this.options.distinct != null)
-            url.searchParams.set('$distinct', this.options.distinct);
-        return {
-            method: 'GET',
-            url: url.address,
-            params: url.searchParams
-        };
-    }
-}

package/esm/requests/collection-update-many-request.d.ts

@@ -1,13 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { CollectionResourceInfo, CollectionUpdateManyQueryOptions } from '@opra/schema';
-import type { OpraClient } from '../client.js';
-import { OpraClientRequest } from '../client-request.js';
-import { ClientResponse, CommonQueryOptions, PartialInput } from '../types.js';
-export declare class CollectionUpdateManyRequest<T, TResponse extends ClientResponse<T>> extends OpraClientRequest<T, TResponse> {
-    readonly client: OpraClient;
-    readonly resource: CollectionResourceInfo;
-    data: PartialInput<T>;
-    options: CollectionUpdateManyQueryOptions & CommonQueryOptions;
-    constructor(client: OpraClient, send: (req: AxiosRequestConfig) => Promise<TResponse>, resource: CollectionResourceInfo, data: PartialInput<T>, options?: CollectionUpdateManyQueryOptions & CommonQueryOptions);
-    prepare(): AxiosRequestConfig;
-}

package/esm/requests/collection-update-many-request.js

@@ -1,27 +0,0 @@
-import { OpraURL } from '@opra/url';
-import { OpraClientRequest } from '../client-request.js';
-export class CollectionUpdateManyRequest extends OpraClientRequest {
-    client;
-    resource;
-    data;
-    options;
-    constructor(client, send, resource, data, options = {}) {
-        super(client, send, options);
-        this.client = client;
-        this.resource = resource;
-        this.data = data;
-        this.options = options;
-    }
-    prepare() {
-        const url = new OpraURL(this.client.serviceUrl);
-        url.path.join(this.resource.name);
-        if (this.options.filter)
-            url.searchParams.set('$filter', this.options.filter);
-        return {
-            method: 'PATCH',
-            url: url.address,
-            data: this.data,
-            params: url.searchParams
-        };
-    }
-}