@opra/client 0.7.0 → 0.8.0

package/typings/common/schema/opra-schema.definition.d.ts

@@ -0,0 +1,178 @@
+import { Type } from 'ts-gems';
+import { ComparisonOperator } from '../filter/index.js';
+export declare namespace OpraSchema {
+    /**
+     * *** === Constants === ***
+     */
+    export const Version = "1.0";
+    /**
+     * *** === Type definitions === ***
+     */
+    export type Extensible<T = any> = {
+        [key: `$${string}`]: T;
+    };
+    export type ResourceKind = 'ContainerResource' | 'CollectionResource' | 'SingletonResource';
+    export type DataTypeKind = 'SimpleType' | 'ComplexType' | 'UnionType';
+    export type SingletonMethod = 'get' | 'create' | 'update' | 'delete';
+    export type CollectionMethod = SingletonMethod | 'search' | 'count' | 'updateMany' | 'deleteMany';
+    /**
+     * *** === Document related === ***
+     */
+    export interface Document {
+        version: string;
+        info: DocumentInfo;
+        references?: Record<string, Reference>;
+        types?: Record<string, DataType>;
+        resources?: Record<string, Resource>;
+        servers?: ServerInfo[];
+    }
+    export type ServerInfo = Extensible & {
+        url: string;
+        description?: string;
+    };
+    export type Reference = Extensible & {
+        url?: string;
+        document?: Document;
+    };
+    export type DocumentInfo = Extensible & {
+        title: string;
+        version: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: ContactPerson[];
+        license?: LicenseInfo;
+    };
+    export type ContactPerson = Extensible & {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    export type LicenseInfo = Extensible & {
+        name: string;
+        url?: string;
+        content?: string;
+    };
+    /**
+     * *** === Data Type related === ***
+     */
+    export type DataType = ComplexType | SimpleType | UnionType;
+    export type BaseDataType = {
+        kind: DataTypeKind;
+        description?: string;
+        ctor?: Type;
+        parse?: (v: any) => any;
+        serialize?: (v: any) => any;
+    };
+    export interface SimpleType extends BaseDataType {
+        kind: 'SimpleType';
+    }
+    export interface UnionType extends BaseDataType {
+        kind: 'UnionType';
+        types: DataType[];
+    }
+    export interface ComplexType extends BaseDataType {
+        kind: 'ComplexType';
+        description?: string;
+        abstract?: boolean;
+        extends?: ComplexTypeExtendingInfo[];
+        fields?: Record<string, Field>;
+        additionalFields?: boolean | string | Pick<Field, 'type' | 'format' | 'isArray' | 'enum'>;
+    }
+    export interface ComplexTypeExtendingInfo {
+        type: string;
+        pick?: string[];
+        omit?: string[];
+    }
+    export type Field = Extensible & {
+        type: string;
+        description?: string;
+        required?: boolean;
+        isArray?: boolean;
+        format?: string;
+        default?: any;
+        fixed?: string | number;
+        enum?: string | string[] | Record<string, string>;
+        enumName?: string;
+        examples?: any[] | Record<string, any>;
+        deprecated?: boolean | string;
+        /**
+         * If true, this property will not be included in results by default.
+         * The client side should include the property name in the "include" query parameter.
+         */
+        exclusive?: boolean;
+    };
+    /**
+     * *** === Resource related === ***
+     */
+    export type Resource = ContainerResource | CollectionResource | SingletonResource;
+    export interface BaseResource {
+        kind: ResourceKind;
+        description?: string;
+        instance?: {};
+    }
+    export interface CollectionResource extends BaseResource {
+        kind: 'CollectionResource';
+        type: string;
+        keyFields: string | string[];
+        create?: CreateMethodResolver;
+        count?: CountMethodResolver;
+        delete?: DeleteMethodResolver;
+        deleteMany?: DeleteManyMethodResolver;
+        get?: GetMethodResolver;
+        update?: UpdateMethodResolver;
+        updateMany?: UpdateManyMethodResolver;
+        search?: SearchMethodResolver;
+    }
+    export interface SingletonResource extends BaseResource {
+        kind: 'SingletonResource';
+        type: string;
+        create?: CreateMethodResolver;
+        get?: GetMethodResolver;
+        update?: UpdateMethodResolver;
+        delete?: DeleteMethodResolver;
+    }
+    export interface ContainerResource extends BaseResource {
+        kind: 'ContainerResource';
+        resources: Resource[];
+    }
+    export type MethodResolver = {
+        handler?: Function;
+    };
+    type MethodResolverInputOptions = {
+        inputPick?: string[];
+        inputOmit?: string[];
+    };
+    type MethodResolverOutputOptions = {
+        outputPick?: string[];
+        outputOmit?: string[];
+    };
+    type MethodResolverFilterOptions = {
+        filters?: {
+            field: string;
+            operators?: ComparisonOperator[];
+        }[];
+    };
+    export type CreateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
+    export type CountMethodResolver = MethodResolver & {};
+    export type DeleteMethodResolver = MethodResolver & {};
+    export type DeleteManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
+    export type GetMethodResolver = MethodResolver & MethodResolverOutputOptions;
+    export type UpdateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
+    export type UpdateManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
+    export type SearchMethodResolver = MethodResolver & MethodResolverOutputOptions & {
+        sortFields?: string[];
+        defaultSort?: string[];
+    } & MethodResolverFilterOptions;
+    /**
+     * *** === Type Guards === ***
+     */
+    export function isDataType(obj: any): obj is DataType;
+    export function isComplexType(obj: any): obj is ComplexType;
+    export function isSimpleType(obj: any): obj is SimpleType;
+    export function isUnionTypee(obj: any): obj is UnionType;
+    export function isResource(obj: any): obj is Resource;
+    export function isCollectionResource(obj: any): obj is CollectionResource;
+    export function isSingletonResource(obj: any): obj is SingletonResource;
+    export function isContainerResource(obj: any): obj is ContainerResource;
+    export {};
+}

package/typings/common/schema/type-helpers/extend-type.helper.d.ts

@@ -0,0 +1,3 @@
+import { Class } from 'ts-gems';
+export declare function PickType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Pick<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;
+export declare function OmitType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Omit<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;

package/typings/common/schema/type-helpers/mixin-type.helper.d.ts

@@ -0,0 +1,2 @@
+import { Class } from 'ts-gems';
+export declare function MixinType<A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;

package/typings/common/schema/type-helpers/mixin.utils.d.ts

@@ -0,0 +1,3 @@
+import { Type } from 'ts-gems';
+export declare function applyMixins(derivedCtor: any, baseCtor: any, filter?: (k: string) => boolean): void;
+export declare function inheritPropertyInitializers(target: Record<string, any>, sourceClass: Type, isPropertyInherited?: (key: string) => boolean): void;

package/typings/common/schema/types.d.ts

@@ -0,0 +1,14 @@
+import { Builtin, DeepPickWritable, Type } from 'ts-gems';
+export declare type PartialInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
+export declare type PartialOutput<T> = DeepNullablePartial<T>;
+declare type DeepNullablePartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullablePartial<U>> : T extends (infer U)[] ? DeepNullablePartial<U>[] : {
+    [P in keyof T]?: DeepNullablePartial<Exclude<T[P], undefined>> | null;
+};
+export declare type Thunk<T> = T | (() => T);
+export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export declare type TypeThunk<T = any> = Thunk<Type<T>>;
+export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
+export declare type Named<T> = T & {
+    name: string;
+};
+export {};

package/typings/common/schema/utils/class.utils.d.ts

@@ -0,0 +1,2 @@
+import { Type } from 'ts-gems';
+export declare function isConstructor(obj: any): obj is Type;

package/typings/common/schema/utils/clone-object.util.d.ts

@@ -0,0 +1 @@
+export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;

package/typings/common/schema/utils/inspect.util.d.ts

@@ -0,0 +1,4 @@
+export declare const nodeInspectCustom: unique symbol;
+export declare const colorReset = "\u001B[0m";
+export declare const colorFgYellow = "\u001B[33m";
+export declare const colorFgMagenta = "\u001B[35m";

package/typings/common/schema/utils/normalize-field-array.util.d.ts

@@ -0,0 +1,3 @@
+import { ComplexType } from '../implementation/data-type/complex-type.js';
+import type { OpraDocument } from '../implementation/opra-document.js';
+export declare function normalizeFieldArray(document: OpraDocument, dataType: ComplexType | undefined, fields: string[], parentPath?: string): string[];

package/typings/common/schema/utils/path-to-tree.util.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function pathToTree(arr: string[]): ObjectTree | undefined;

package/typings/common/schema/utils/string-compare.util.d.ts

@@ -0,0 +1 @@
+export declare function stringCompare(a: string, b: string): number;

package/typings/common/url/formats/boolean-format.d.ts

@@ -0,0 +1,5 @@
+import { Format } from './format.js';
+export declare class BooleanFormat extends Format {
+    parse(value: string): boolean;
+    stringify(value: any): string;
+}

package/typings/common/url/formats/date-format.d.ts

@@ -0,0 +1,16 @@
+import { Format } from './format.js';
+export interface DateFormatOptions {
+    time?: boolean;
+    timeZone?: boolean;
+    min?: string;
+    max?: string;
+}
+export declare class DateFormat extends Format {
+    time: boolean;
+    timeZone: boolean;
+    min?: string;
+    max?: string;
+    constructor(options?: DateFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/typings/common/url/formats/filter-format.d.ts

@@ -0,0 +1,6 @@
+import { Ast, Expression } from '../../filter/ast/index.js';
+import { Format } from './format.js';
+export declare class FilterFormat extends Format {
+    parse(value: string | Expression): object;
+    stringify(value: Ast): string;
+}

package/typings/common/url/formats/format.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Format {
+    abstract parse(value: string): any;
+    abstract stringify(value: any): string;
+}

package/typings/common/url/formats/integer-format.d.ts

@@ -0,0 +1,9 @@
+import { NumberFormat, NumberFormatOptions } from './number-format.js';
+export interface IntegerFormatOptions extends NumberFormatOptions {
+    enum?: number[];
+}
+export declare class IntegerFormat extends NumberFormat {
+    enum?: number[];
+    constructor(options?: IntegerFormatOptions);
+    parse(value: string): number;
+}

package/typings/common/url/formats/number-format.d.ts

@@ -0,0 +1,12 @@
+import { Format } from './format.js';
+export interface NumberFormatOptions {
+    max?: number;
+    min?: number;
+}
+export declare class NumberFormat extends Format {
+    max?: number;
+    min?: number;
+    constructor(options?: NumberFormatOptions);
+    parse(value: string): number;
+    stringify(value: any): string;
+}

package/typings/common/url/formats/string-format.d.ts

@@ -0,0 +1,14 @@
+import { Format } from './format.js';
+export interface StringFormatOptions {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+}
+export declare class StringFormat extends Format {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+    constructor(options?: StringFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/typings/common/url/index.d.ts

@@ -0,0 +1,5 @@
+export * from './opra-url.js';
+export * from './opra-url-path.js';
+export * from './opra-url-path-component.js';
+export * from './opra-url-search-params.js';
+export * from './utils/path-utils.js';

package/typings/common/url/opra-url-path-component.d.ts

@@ -0,0 +1,15 @@
+declare const nodeInspectCustom: unique symbol;
+export declare type OpraURLPathComponentInit = {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+};
+export declare class OpraURLPathComponent {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+    constructor(init: OpraURLPathComponentInit);
+    toString(): string;
+    [nodeInspectCustom](): any;
+}
+export {};

package/typings/common/url/opra-url-path.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { OpraURLPathComponent, OpraURLPathComponentInit } from './opra-url-path-component.js';
+declare const nodeInspectCustom: unique symbol;
+export declare class OpraURLPath extends EventEmitter {
+    private _entries;
+    constructor(...components: (OpraURLPathComponent | OpraURLPathComponentInit)[]);
+    constructor(init?: string | OpraURLPath | URL | OpraURLPathComponent | OpraURLPathComponentInit);
+    get size(): number;
+    add(component: OpraURLPathComponent | {
+        resource: string;
+        key?: any;
+        typeCast?: string;
+    }): void;
+    add(name: string, key?: any, typeCast?: string): void;
+    clear(): void;
+    get(index: number): OpraURLPathComponent;
+    join(pathString: string): this;
+    entries(): IterableIterator<[OpraURLPathComponent, number]>;
+    values(): IterableIterator<OpraURLPathComponent>;
+    forEach(callback: (name: string, key: any, _this: this) => void): void;
+    getResource(index: number): string | undefined;
+    getKey(index: number): any;
+    toString(): string;
+    [Symbol.iterator](): IterableIterator<[OpraURLPathComponent, number]>;
+    [nodeInspectCustom](): OpraURLPathComponent[];
+    protected _add(component: any, key?: any, typeCast?: string): void;
+    protected _parse(v: string): void;
+}
+export {};

package/typings/common/url/opra-url-search-params.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { StrictOmit } from 'ts-gems';
+import { ResponsiveMap } from '../helpers/index.js';
+import { Format } from './formats/format.js';
+declare const nodeInspectCustom: unique symbol;
+interface OpraURLSearchParamItem {
+    name: string;
+    format?: Format | string;
+    array?: boolean | 'strict';
+    arrayDelimiter?: string;
+    minArrayItems?: number;
+    maxArrayItems?: number;
+}
+export declare class OpraURLSearchParams extends EventEmitter {
+    protected _params: ResponsiveMap<string, OpraURLSearchParamItem>;
+    private _entries;
+    private _size;
+    constructor(init?: (string | URLSearchParams | OpraURLSearchParams));
+    get size(): number;
+    addAll(values: URLSearchParams | OpraURLSearchParams | Map<string, any> | Record<string, any>): void;
+    append(name: string, value?: any): void;
+    clear(): void;
+    defineParam(name: string, options?: StrictOmit<OpraURLSearchParamItem, 'name'>): this;
+    delete(name: string): void;
+    entries(): IterableIterator<[string, any]>;
+    forEach(callback: (value: any, name: string, _this: this) => void): void;
+    get(name: string, index?: number): any | null;
+    getAll(name: string): any[];
+    has(name: string): boolean;
+    keys(): IterableIterator<string>;
+    set(name: string, value?: any): void;
+    sort(compareFn?: (a: string, b: string) => number): void;
+    values(): IterableIterator<any>;
+    toString(): string;
+    parse(input: string): void;
+    toURLSearchParams(): URLSearchParams;
+    [Symbol.iterator](): IterableIterator<[string, any]>;
+    get [Symbol.toStringTag](): string;
+    [nodeInspectCustom](): ResponsiveMap<string, any[]>;
+    protected _delete(name: string): boolean;
+    protected _add(name: string, value: any): boolean;
+}
+export {};

package/typings/common/url/opra-url.d.ts

@@ -0,0 +1,79 @@
+import { OpraURLPath } from './opra-url-path.js';
+import { OpraURLSearchParams } from './opra-url-search-params.js';
+declare const nodeInspectCustom: unique symbol;
+declare const CONTEXT_KEY: unique symbol;
+declare const PATH_KEY: unique symbol;
+declare const SEARCHPARAMS_KEY: unique symbol;
+export declare class OpraURL {
+    protected [CONTEXT_KEY]: {
+        protocol: string;
+        username: string;
+        password: string;
+        hostname: string;
+        pathPrefix: string;
+        port: number | null;
+        hash: string;
+        pathname: string;
+        search: string;
+        needUpdate: boolean;
+    };
+    protected [PATH_KEY]: OpraURLPath;
+    protected [SEARCHPARAMS_KEY]: OpraURLSearchParams;
+    constructor(input?: string, pathPrefix?: string);
+    get address(): string;
+    get href(): string;
+    get protocol(): string;
+    set protocol(v: string);
+    get username(): string;
+    set username(v: string);
+    get password(): string;
+    set password(v: string);
+    get host(): string;
+    set host(v: string);
+    get hostname(): string;
+    set hostname(v: string);
+    get port(): number | null;
+    set port(v: number | null);
+    get origin(): string;
+    get pathPrefix(): string;
+    set pathPrefix(v: string);
+    get path(): OpraURLPath;
+    get pathname(): string;
+    set pathname(v: string);
+    get searchParams(): OpraURLSearchParams;
+    get hash(): string;
+    set hash(v: string);
+    get search(): string;
+    set search(v: string);
+    addPath(name: string, key?: any): this;
+    addSearchParam(name: string, value?: any): this;
+    setHost(v: string): this;
+    setHostname(v: string): this;
+    setProtocol(v: string): this;
+    setPort(v: number | null): this;
+    setPrefix(v: string): this;
+    setPathname(v: string): this;
+    setHash(v: string): this;
+    setSearch(v: string): this;
+    setSearchParam(name: string, value?: any): this;
+    parse(input: string): this;
+    toString(): string;
+    [nodeInspectCustom](): {
+        protocol: string;
+        username: string;
+        password: string;
+        host: string;
+        hostname: string;
+        origin: string;
+        pathPrefix: string;
+        path: OpraURLPath;
+        pathname: string;
+        search: string;
+        searchParams: OpraURLSearchParams;
+        hash: string;
+    };
+    protected _invalidate(): void;
+    protected _update(): void;
+    protected _setPathname(v: string, inclSvcRoot?: boolean): void;
+}
+export {};

package/typings/common/url/utils/path-utils.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizePath(p?: string, noLeadingSlash?: boolean): string;
+export declare function joinPath(...p: string[]): string;
+export declare function decodePathComponent(input: string): {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+};
+export declare function encodePathComponent(resource: string, key?: any, typeCast?: string): string;

package/typings/common/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './path-to-tree.js';
+export * from './type-guards.js';
+export * from './is-url.js';

package/typings/common/utils/is-url.d.ts

@@ -0,0 +1 @@
+export declare function isUrl(url: any): boolean;

package/typings/common/utils/path-to-tree.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function pathToTree(arr: string[], lowerCaseKeys?: boolean): ObjectTree | undefined;

package/typings/common/utils/type-guards.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference lib="dom" />
+import { Readable } from 'stream';
+export declare function typeGuards(stream: any): boolean;
+export declare function isReadable(x: any): x is Readable;
+export declare function isReadableStream(x: any): x is ReadableStream;
+export declare function isBlob(x: any): x is Blob;
+export declare function isFormData(x: any): x is FormData;
+export declare function isURL(x: any): x is URL;

package/{esm → typings}/http/http-client.d.ts

@@ -1,5 +1,5 @@
 import { Type } from 'ts-gems';
-import { OpraDocument } from '@opra/common';
+import { OpraDocument } from '../common';
 import { HttpCollectionService } from './http-collection-service.js';
 import { HttpRequest } from './http-request.js';
 import { HttpResponse } from './http-response.js';

package/{esm → typings}/http/http-collection-service.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionCreateQueryOptions, CollectionDeleteManyQueryOptions, CollectionGetQueryOptions, CollectionResourceInfo, CollectionSearchQueryOptions, CollectionUpdateManyQueryOptions, CollectionUpdateQueryOptions, PartialInput } from '@opra/common';
+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 { CollectionCreateRequest } from './requests/collection-create-request.js';

package/{esm → typings}/http/http-request.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { ClientHttpHeaders } from '@opra/common';
+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> {

package/{esm → typings}/http/http-singleton-service.d.ts

@@ -1,4 +1,4 @@
-import { SingletonGetQueryOptions, SingletonResourceInfo } from '@opra/common';
+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';

package/{esm → typings}/http/http-types.d.ts

@@ -2,7 +2,7 @@
 /// <reference lib="dom" />
 import { StrictOmit } from 'ts-gems';
 import { URLSearchParams } from 'url';
-import { ClientHttpHeaders, OpraDocument, OpraURLSearchParams } from '@opra/common';
+import { ClientHttpHeaders, OpraDocument, OpraURLSearchParams } from '../common';
 import type { HttpResponse } from './http-response';
 export declare type CommonHttpRequestOptions = {
     observe?: 'body' | 'response';

package/{esm → typings}/http/requests/batch-request.d.ts

@@ -1,4 +1,4 @@
-import { BatchMultipart } from '@opra/common';
+import { BatchMultipart } from '../../common';
 import { HttpRequest } from '../http-request.js';
 import { HttpResponse } from '../http-response.js';
 import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';

package/{esm → typings}/http/requests/collection-create-request.d.ts

@@ -1,4 +1,4 @@
-import { CollectionCreateQueryOptions, CollectionResourceInfo, PartialInput } from '@opra/common';
+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';

package/{esm → typings}/http/requests/collection-delete-many-request.d.ts

@@ -1,4 +1,4 @@
-import { CollectionDeleteManyQueryOptions, CollectionResourceInfo } from '@opra/common';
+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';

package/{esm → typings}/http/requests/collection-delete-request.d.ts

@@ -1,4 +1,4 @@
-import { CollectionResourceInfo } from '@opra/common';
+import { CollectionResourceInfo } from '../../common';
 import { HttpRequest } from '../http-request.js';
 import { HttpResponse } from '../http-response.js';
 import { CommonHttpRequestOptions, HttpRequestHandler, RawHttpRequest } from '../http-types.js';

package/{esm → typings}/http/requests/collection-get-request.d.ts

@@ -1,4 +1,4 @@
-import { CollectionGetQueryOptions, CollectionResourceInfo } from '@opra/common';
+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';

package/{esm → typings}/http/requests/collection-search-request.d.ts

@@ -1,4 +1,4 @@
-import { CollectionResourceInfo, CollectionSearchQueryOptions } from '@opra/common';
+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';

package/{esm → typings}/http/requests/collection-update-many-request.d.ts

@@ -1,4 +1,4 @@
-import { CollectionResourceInfo, CollectionUpdateManyQueryOptions, PartialInput } from '@opra/common';
+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';

package/{esm → typings}/http/requests/collection-update-request.d.ts

@@ -1,4 +1,4 @@
-import { CollectionResourceInfo, CollectionUpdateQueryOptions, PartialInput } from '@opra/common';
+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';

package/{esm → typings}/http/requests/http-singleton-get-request.d.ts

@@ -1,4 +1,4 @@
-import { SingletonGetQueryOptions, SingletonResourceInfo } from '@opra/common';
+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';