@opra/client 0.4.0

package/esm/client.js

@@ -0,0 +1,91 @@
+import axios from 'axios';
+import { ResponsiveMap } from '@opra/common';
+import { OpraDocument } from '@opra/schema';
+import { joinPath, normalizePath } from '@opra/url';
+import { ClientError } from './client-error.js';
+import { CollectionService } from './services/collection-service.js';
+import { SingletonService } from './services/singleton-service.js';
+export class OpraClient {
+    serviceUrl;
+    options;
+    _metadata;
+    constructor(serviceUrl, options) {
+        this.options = { ...options };
+        this.serviceUrl = normalizePath(serviceUrl);
+    }
+    get metadata() {
+        return this._metadata;
+    }
+    collection(name, options) {
+        const resource = this.metadata.getCollectionResource(name);
+        const commonOptions = {
+            headers: this.options.defaultHeaders,
+            validateStatus: this.options.validateStatus,
+            ...options,
+        };
+        return new CollectionService(this.serviceUrl, this.metadata, (req) => this._send(req, commonOptions), resource);
+    }
+    singleton(name, options) {
+        const resource = this.metadata.getSingletonResource(name);
+        const commonOptions = {
+            headers: this.options.defaultHeaders,
+            validateStatus: this.options.validateStatus,
+            ...options,
+        };
+        return new SingletonService(this.serviceUrl, this.metadata, (req) => this._send(req, commonOptions), resource);
+    }
+    async _send(req, options) {
+        const axiosInstance = this._createAxiosInstance(options);
+        const resp = await axiosInstance.request({ ...req, validateStatus: undefined });
+        const validateStatus = options?.validateStatus;
+        if ((validateStatus === true && !(resp.status >= 200 && resp.status < 300)) ||
+            (typeof validateStatus === 'function' && !validateStatus(resp.status))) {
+            throw new ClientError({
+                message: 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
+        };
+    }
+    _createAxiosInstance(options) {
+        const axiosInstance = axios.create();
+        axiosInstance.defaults.adapter = this.options.adapter;
+        axiosInstance.defaults.headers.common = { ...options?.headers, ...this.options.defaultHeaders };
+        if (options?.validateStatus != null) {
+            if (options.validateStatus === false)
+                axiosInstance.defaults.validateStatus = () => true;
+            else if (typeof options.validateStatus === 'function')
+                axiosInstance.defaults.validateStatus = options.validateStatus;
+        }
+        else if (this.options.validateStatus != null) {
+            if (this.options.validateStatus === false)
+                axiosInstance.defaults.validateStatus = () => true;
+            else if (typeof this.options.validateStatus === 'function')
+                axiosInstance.defaults.validateStatus = this.options.validateStatus;
+        }
+        return axiosInstance;
+    }
+    async _fetchMetadata() {
+        const resp = await this._send({
+            method: 'GET',
+            url: joinPath(this.serviceUrl || '/', '$metadata'),
+        }, { validateStatus: true });
+        this._metadata = new OpraDocument(resp.data);
+    }
+    static async create(serviceUrl, options) {
+        const client = new this(serviceUrl, options);
+        await client._fetchMetadata();
+        return client;
+    }
+}

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './response.js';
+export * from './types.js';
+export * from './services/collection-service.js';
+export * from './services/singleton-service.js';

package/esm/index.js

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './response.js';
+export * from './types.js';
+export * from './services/collection-service.js';
+export * from './services/singleton-service.js';

package/esm/observable-promise.d.ts

@@ -0,0 +1,2 @@
+import { ObservablePromiseLike } from './types.js';
+export declare function observablePromise<T>(promise: Promise<T>): ObservablePromiseLike<T>;

package/esm/observable-promise.js

@@ -0,0 +1,6 @@
+import { from } from 'rxjs';
+export function observablePromise(promise) {
+    const observable = from(promise);
+    observable.then = (...args) => promise.then(...args);
+    return observable;
+}

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

@@ -0,0 +1,8 @@
+import { CollectionCreateQueryOptions } from '@opra/schema';
+export declare class CollectionCreateRequest {
+    protected _options: CollectionCreateQueryOptions;
+    constructor(_options?: CollectionCreateQueryOptions);
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+}

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

@@ -0,0 +1,18 @@
+export class CollectionCreateRequest {
+    _options;
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+    omit(...fields) {
+        this._options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._options.include = fields.flat();
+        return this;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { CollectionDeleteManyQueryOptions } from '@opra/schema';
+import { Expression } from '@opra/url';
+export declare class CollectionDeleteManyRequest {
+    protected _options: CollectionDeleteManyQueryOptions;
+    constructor(_options?: CollectionDeleteManyQueryOptions);
+    filter(value: string | Expression): this;
+}

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

@@ -0,0 +1,10 @@
+export class CollectionDeleteManyRequest {
+    _options;
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+    filter(value) {
+        this._options.filter = value;
+        return this;
+    }
+}

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

@@ -0,0 +1,8 @@
+import { CollectionGetQueryOptions } from '@opra/schema';
+export declare class CollectionGetRequest {
+    protected _options: CollectionGetQueryOptions;
+    constructor(_options?: CollectionGetQueryOptions);
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+}

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

@@ -0,0 +1,18 @@
+export class CollectionGetRequest {
+    _options;
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+    omit(...fields) {
+        this._options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._options.include = fields.flat();
+        return this;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { CollectionSearchQueryOptions } from '@opra/schema';
+import { Expression } from '@opra/url';
+export declare class CollectionSearchRequest {
+    protected _options: CollectionSearchQueryOptions;
+    constructor(_options?: CollectionSearchQueryOptions);
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+    limit(value: number): this;
+    skip(value: number): this;
+    count(value?: boolean): this;
+    distinct(value: boolean): this;
+    sort(...fields: (string | string[])[]): this;
+    filter(value: string | Expression): this;
+}

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

@@ -0,0 +1,42 @@
+export class CollectionSearchRequest {
+    _options;
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+    omit(...fields) {
+        this._options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._options.include = fields.flat();
+        return this;
+    }
+    limit(value) {
+        this._options.limit = value;
+        return this;
+    }
+    skip(value) {
+        this._options.skip = value;
+        return this;
+    }
+    count(value = true) {
+        this._options.count = value;
+        return this;
+    }
+    distinct(value) {
+        this._options.distinct = value;
+        return this;
+    }
+    sort(...fields) {
+        this._options.sort = fields.flat();
+        return this;
+    }
+    filter(value) {
+        this._options.filter = value;
+        return this;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { CollectionUpdateManyQueryOptions } from '@opra/schema';
+import { Expression } from '@opra/url';
+export declare class CollectionUpdateManyRequest {
+    protected _options: CollectionUpdateManyQueryOptions;
+    constructor(_options?: CollectionUpdateManyQueryOptions);
+    filter(value: string | Expression): this;
+}

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

@@ -0,0 +1,10 @@
+export class CollectionUpdateManyRequest {
+    _options;
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+    filter(value) {
+        this._options.filter = value;
+        return this;
+    }
+}

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

@@ -0,0 +1,8 @@
+import { CollectionUpdateQueryOptions } from '@opra/schema';
+export declare class CollectionUpdateRequest {
+    protected _options: CollectionUpdateQueryOptions;
+    constructor(_options?: CollectionUpdateQueryOptions);
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+}

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

@@ -0,0 +1,18 @@
+export class CollectionUpdateRequest {
+    _options;
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+    omit(...fields) {
+        this._options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._options.include = fields.flat();
+        return this;
+    }
+}

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

@@ -0,0 +1,8 @@
+import { SingletonGetQueryOptions } from '@opra/schema';
+export declare class SingletonGetRequest {
+    protected _options: SingletonGetQueryOptions;
+    constructor(_options?: SingletonGetQueryOptions);
+    omit(...fields: (string | string[])[]): this;
+    pick(...fields: (string | string[])[]): this;
+    include(...fields: (string | string[])[]): this;
+}

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

@@ -0,0 +1,18 @@
+export class SingletonGetRequest {
+    _options;
+    constructor(_options = {}) {
+        this._options = _options;
+    }
+    omit(...fields) {
+        this._options.omit = fields.flat();
+        return this;
+    }
+    pick(...fields) {
+        this._options.pick = fields.flat();
+        return this;
+    }
+    include(...fields) {
+        this._options.include = fields.flat();
+        return this;
+    }
+}

package/esm/response.d.ts

@@ -0,0 +1,9 @@
+import { ResponsiveMap } from '@opra/common';
+import { ResponseHeaders } from './types.js';
+export declare type OpraResponse<T = any> = {
+    status: number;
+    statusText: string;
+    rawHeaders: ResponseHeaders;
+    headers: ResponsiveMap<string, string | string[]>;
+    data?: T;
+};

package/esm/response.js

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

package/esm/services/collection-service.d.ts

@@ -0,0 +1,31 @@
+import { AxiosRequestConfig } from 'axios';
+import { CollectionCreateQueryOptions, CollectionDeleteManyQueryOptions, CollectionGetQueryOptions, CollectionResourceInfo, CollectionSearchQueryOptions, CollectionUpdateManyQueryOptions, CollectionUpdateQueryOptions, OpraDocument } from '@opra/schema';
+import { CollectionCreateRequest } from '../requests/collection-create-request.js';
+import { CollectionDeleteManyRequest } from '../requests/collection-delete-many-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';
+import { OpraResponse } from '../response.js';
+import { ObservablePromiseLike, PartialInput, RequestConfig } from '../types.js';
+export declare class CollectionService<T, TResponse extends OpraResponse<T>> {
+    protected _serviceUrl: string;
+    protected _document: OpraDocument;
+    protected _handler: (req: AxiosRequestConfig) => Promise<any>;
+    protected _resource: CollectionResourceInfo;
+    constructor(_serviceUrl: string, _document: OpraDocument, _handler: (req: AxiosRequestConfig) => Promise<any>, _resource: CollectionResourceInfo);
+    create(data: PartialInput<T>, options?: CollectionCreateQueryOptions | ((req: CollectionCreateRequest) => void)): ObservablePromiseLike<TResponse>;
+    delete(keyValue: any): ObservablePromiseLike<TResponse>;
+    deleteMany(options?: CollectionDeleteManyQueryOptions | ((req: CollectionDeleteManyRequest) => void)): ObservablePromiseLike<TResponse>;
+    get(keyValue: any, options?: CollectionGetQueryOptions | ((req: CollectionGetRequest) => void)): ObservablePromiseLike<TResponse>;
+    search(options?: CollectionSearchQueryOptions | ((req: CollectionSearchRequest) => void)): ObservablePromiseLike<TResponse>;
+    update(keyValue: any, data: PartialInput<T>, options?: CollectionUpdateQueryOptions | ((req: CollectionUpdateRequest) => void)): ObservablePromiseLike<TResponse>;
+    updateMany(data: PartialInput<T>, options?: CollectionUpdateManyQueryOptions | ((req: CollectionUpdateManyRequest) => void)): ObservablePromiseLike<TResponse>;
+    protected _prepareCreateRequest(data: any, options: CollectionCreateQueryOptions): AxiosRequestConfig;
+    protected _prepareDeleteRequest(keyValue: any): AxiosRequestConfig;
+    protected _prepareDeleteManyRequest(options: CollectionDeleteManyQueryOptions): AxiosRequestConfig;
+    protected _prepareGetRequest(keyValue: any, options: CollectionGetQueryOptions): RequestConfig;
+    protected _prepareSearchRequest(options: CollectionSearchQueryOptions): AxiosRequestConfig;
+    protected _prepareUpdateRequest(keyValue: any, data: any, options: CollectionUpdateQueryOptions): RequestConfig;
+    protected _prepareUpdateManyRequest(data: any, options: CollectionUpdateManyQueryOptions): RequestConfig;
+}

package/esm/services/collection-service.js

@@ -0,0 +1,188 @@
+import { OpraURL } from '@opra/url';
+import { observablePromise } from '../observable-promise.js';
+import { CollectionCreateRequest } from '../requests/collection-create-request.js';
+import { CollectionDeleteManyRequest } from '../requests/collection-delete-many-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 class CollectionService {
+    _serviceUrl;
+    _document;
+    _handler;
+    _resource;
+    constructor(_serviceUrl, _document, _handler, _resource) {
+        this._serviceUrl = _serviceUrl;
+        this._document = _document;
+        this._handler = _handler;
+        this._resource = _resource;
+    }
+    create(data, options) {
+        const requestOptions = options && typeof options === 'object' ? options : {};
+        const requestWrapper = new CollectionCreateRequest(requestOptions);
+        if (typeof options === 'function')
+            options(requestWrapper);
+        const req = this._prepareCreateRequest(data, requestOptions);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    delete(keyValue) {
+        const req = this._prepareDeleteRequest(keyValue);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    deleteMany(options) {
+        const requestOptions = options && typeof options === 'object' ? options : {};
+        const requestWrapper = new CollectionDeleteManyRequest(requestOptions);
+        if (typeof options === 'function')
+            options(requestWrapper);
+        const req = this._prepareDeleteManyRequest(requestOptions);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    get(keyValue, options) {
+        const requestOptions = options && typeof options === 'object' ? options : {};
+        const requestWrapper = new CollectionGetRequest(requestOptions);
+        if (typeof options === 'function')
+            options(requestWrapper);
+        const req = this._prepareGetRequest(keyValue, requestOptions);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    search(options) {
+        const requestOptions = options && typeof options === 'object' ? options : {};
+        const requestWrapper = new CollectionSearchRequest(requestOptions);
+        if (typeof options === 'function')
+            options(requestWrapper);
+        const req = this._prepareSearchRequest(requestOptions);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    update(keyValue, data, options) {
+        const requestOptions = options && typeof options === 'object' ? options : {};
+        const requestWrapper = new CollectionUpdateRequest(requestOptions);
+        if (typeof options === 'function')
+            options(requestWrapper);
+        const req = this._prepareUpdateRequest(keyValue, data, requestOptions);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    updateMany(data, options) {
+        const requestOptions = options && typeof options === 'object' ? options : {};
+        const requestWrapper = new CollectionUpdateManyRequest(requestOptions);
+        if (typeof options === 'function')
+            options(requestWrapper);
+        const req = this._prepareUpdateManyRequest(data, requestOptions);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    _prepareCreateRequest(data, options) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        if (options.include)
+            url.searchParams.set('$include', options.include);
+        if (options.pick)
+            url.searchParams.set('$pick', options.pick);
+        if (options.omit)
+            url.searchParams.set('$omit', options.omit);
+        return {
+            method: 'POST',
+            url: url.address,
+            data,
+            params: url.searchParams
+        };
+    }
+    _prepareDeleteRequest(keyValue) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        url.path.get(url.path.size - 1).key = keyValue;
+        return {
+            method: 'DELETE',
+            url: url.address,
+            params: url.searchParams
+        };
+    }
+    _prepareDeleteManyRequest(options) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        if (options.filter)
+            url.searchParams.set('$filter', options.filter);
+        return {
+            method: 'DELETE',
+            url: url.address,
+            params: url.searchParams
+        };
+    }
+    _prepareGetRequest(keyValue, options) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        url.path.get(url.path.size - 1).key = keyValue;
+        if (options.include)
+            url.searchParams.set('$include', options.include);
+        if (options.pick)
+            url.searchParams.set('$pick', options.pick);
+        if (options.omit)
+            url.searchParams.set('$omit', options.omit);
+        return {
+            method: 'GET',
+            url: url.address,
+            params: url.searchParams
+        };
+    }
+    _prepareSearchRequest(options) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        if (options.include)
+            url.searchParams.set('$include', options.include);
+        if (options.pick)
+            url.searchParams.set('$pick', options.pick);
+        if (options.omit)
+            url.searchParams.set('$omit', options.omit);
+        if (options.sort)
+            url.searchParams.set('$sort', options.sort);
+        if (options.filter)
+            url.searchParams.set('$filter', options.filter);
+        if (options.limit != null)
+            url.searchParams.set('$limit', options.limit);
+        if (options.skip != null)
+            url.searchParams.set('$skip', options.skip);
+        if (options.count != null)
+            url.searchParams.set('$count', options.count);
+        if (options.distinct != null)
+            url.searchParams.set('$distinct', options.distinct);
+        return {
+            method: 'GET',
+            url: url.address,
+            params: url.searchParams
+        };
+    }
+    _prepareUpdateRequest(keyValue, data, options) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        url.path.get(url.path.size - 1).key = keyValue;
+        if (options.include)
+            url.searchParams.set('$include', options.include);
+        if (options.pick)
+            url.searchParams.set('$pick', options.pick);
+        if (options.omit)
+            url.searchParams.set('$omit', options.omit);
+        return {
+            method: 'PATCH',
+            url: url.address,
+            data,
+            params: url.searchParams
+        };
+    }
+    _prepareUpdateManyRequest(data, options) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        if (options.filter)
+            url.searchParams.set('$filter', options.filter);
+        return {
+            method: 'PATCH',
+            url: url.address,
+            data,
+            params: url.searchParams
+        };
+    }
+}

package/esm/services/singleton-service.d.ts

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from 'axios';
+import { OpraDocument, SingletonGetQueryOptions, SingletonResourceInfo } from '@opra/schema';
+import { SingletonGetRequest } from '../requests/singleton-get-request.js';
+import { OpraResponse } from '../response.js';
+import { ObservablePromiseLike, RequestConfig } from '../types.js';
+export declare class SingletonService<T, TResponse extends OpraResponse<T> = OpraResponse<T>> {
+    protected _serviceUrl: string;
+    protected _document: OpraDocument;
+    protected _handler: (req: AxiosRequestConfig) => Promise<any>;
+    protected _resource: SingletonResourceInfo;
+    constructor(_serviceUrl: string, _document: OpraDocument, _handler: (req: AxiosRequestConfig) => Promise<any>, _resource: SingletonResourceInfo);
+    get(options?: SingletonGetQueryOptions | ((req: SingletonGetRequest) => void)): ObservablePromiseLike<TResponse>;
+    protected _prepareGetRequest(options: SingletonGetQueryOptions): RequestConfig;
+}

package/esm/services/singleton-service.js

@@ -0,0 +1,39 @@
+import { OpraURL } from '@opra/url';
+import { observablePromise } from '../observable-promise.js';
+import { SingletonGetRequest } from '../requests/singleton-get-request.js';
+export class SingletonService {
+    _serviceUrl;
+    _document;
+    _handler;
+    _resource;
+    constructor(_serviceUrl, _document, _handler, _resource) {
+        this._serviceUrl = _serviceUrl;
+        this._document = _document;
+        this._handler = _handler;
+        this._resource = _resource;
+    }
+    get(options) {
+        const requestOptions = options && typeof options === 'object' ? options : {};
+        const requestWrapper = new SingletonGetRequest(requestOptions);
+        if (typeof options === 'function')
+            options(requestWrapper);
+        const req = this._prepareGetRequest(requestOptions);
+        const promise = this._handler(req);
+        return observablePromise(promise);
+    }
+    _prepareGetRequest(options) {
+        const url = new OpraURL(this._serviceUrl);
+        url.path.join(this._resource.name);
+        if (options.include)
+            url.searchParams.set('$include', options.include);
+        if (options.pick)
+            url.searchParams.set('$pick', options.pick);
+        if (options.omit)
+            url.searchParams.set('$omit', options.omit);
+        return {
+            method: 'GET',
+            url: url.address,
+            params: url.searchParams
+        };
+    }
+}

package/esm/types.d.ts

@@ -0,0 +1,10 @@
+import { AxiosRequestConfig } from 'axios';
+import { Observable } from 'rxjs';
+export declare type ObservablePromiseLike<T> = Observable<T> & PromiseLike<T>;
+export { PartialInput, PartialOutput } from '@opra/common';
+export declare type ResponseHeaders = Partial<Record<string, string | string[]>>;
+export declare type CommonRequestOptions = {
+    headers?: Record<string, string>;
+    validateStatus?: boolean | ((status: number) => boolean);
+};
+export declare type RequestConfig = AxiosRequestConfig & CommonRequestOptions;

package/esm/types.js

@@ -0,0 +1,10 @@
+export {};
+// export type CollectionCreateRequestOptions = CollectionCreateQueryOptions & CommonRequestOptions;
+// export type CollectionDeleteRequestOptions = CommonRequestOptions;
+// export type CollectionDeleteManyRequestOptions = CollectionDeleteManyQueryOptions & CommonRequestOptions;
+// export type CollectionGetRequestOptions = CollectionGetQueryOptions & CommonRequestOptions;
+// export type CollectionUpdateRequestOptions = CollectionUpdateQueryOptions & CommonRequestOptions;
+// export type CollectionUpdateManyRequestOptions = CollectionUpdateManyQueryOptions & CommonRequestOptions;
+// export type CollectionSearchRequestOptions = CollectionSearchQueryOptions & CommonRequestOptions;
+//
+// export type SingletonGetRequestOptions = SingletonGetQueryOptions & CommonRequestOptions;