@opra/client 0.13.0 → 0.15.0

package/typings/common/schema/implementation/resource/container-resource-info.d.ts

@@ -1,13 +0,0 @@
-import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
-import { OpraSchema } from '../../opra-schema.definition.js';
-import type { OpraDocument } from '../opra-document.js';
-import { CollectionResourceInfo } from './collection-resource-info.js';
-import { ResourceInfo } from './resource-info.js';
-import { SingletonResourceInfo } from './singleton-resource-info.js';
-export declare class ContainerResourceInfo extends ResourceInfo implements IResourceContainer {
-    readonly metadata: OpraSchema.ContainerResource;
-    constructor(service: OpraDocument, name: string, metadata: OpraSchema.ContainerResource);
-    getResource<T extends ResourceInfo>(name: string): T;
-    getCollectionResource(name: string): CollectionResourceInfo;
-    getSingletonResource(name: string): SingletonResourceInfo;
-}

package/typings/common/schema/implementation/resource/resource-info.d.ts

@@ -1,17 +0,0 @@
-import { OpraSchema } from '../../opra-schema.definition.js';
-import { nodeInspectCustom } from '../../utils/inspect.util.js';
-import type { OpraDocument } from '../opra-document.js';
-export declare abstract class ResourceInfo {
-    readonly metadata: OpraSchema.Resource;
-    readonly document: OpraDocument;
-    readonly name: string;
-    protected path: string;
-    protected constructor(document: OpraDocument, name: string, metadata: OpraSchema.Resource);
-    get instance(): {} | undefined;
-    get kind(): OpraSchema.ResourceKind;
-    get description(): string | undefined;
-    toString(): string;
-    validateQueryOptions(): any;
-    getSchema(jsonOnly?: boolean): OpraSchema.Resource;
-    [nodeInspectCustom](): string;
-}

package/typings/common/schema/implementation/resource/singleton-resource-info.d.ts

@@ -1,15 +0,0 @@
-import { OpraSchema } from '../../opra-schema.definition.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import type { OpraDocument } from '../opra-document.js';
-import { ResourceInfo } from './resource-info.js';
-export declare class SingletonResourceInfo extends ResourceInfo {
-    readonly metadata: OpraSchema.SingletonResource;
-    readonly dataType: ComplexType;
-    constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.SingletonResource);
-    get create(): OpraSchema.CreateMethodResolver | undefined;
-    get delete(): OpraSchema.MethodResolver | undefined;
-    get get(): OpraSchema.GetMethodResolver | undefined;
-    get update(): OpraSchema.UpdateMethodResolver | undefined;
-    getHandlerNames(): string[];
-    getSchema(jsonOnly?: boolean): OpraSchema.SingletonResource;
-}

package/typings/common/schema/implementation/schema-builder/extract-resource-metadata.util.d.ts

@@ -1,3 +0,0 @@
-import { OpraSchema } from '../../opra-schema.definition.js';
-import { Named } from '../../types.js';
-export declare function extractResourceSchema(instance: object): Promise<Named<OpraSchema.Resource>>;

package/typings/common/schema/implementation/schema-builder/extract-type-metadata.util.d.ts

@@ -1,4 +0,0 @@
-import { Type } from 'ts-gems';
-import { OpraSchema } from '../../opra-schema.definition.js';
-import { Named } from '../../types.js';
-export declare function extractDataTypeSchema(ctor: Type | Function): Promise<Named<OpraSchema.DataType>>;

package/typings/common/schema/interfaces/child-field-query.interface.d.ts

@@ -1,4 +0,0 @@
-import type { FieldGetQueryOptions } from '../implementation/query/index.js';
-export interface IChildFieldQuery {
-    child?: FieldGetQueryOptions;
-}

package/typings/common/schema/interfaces/data-type.metadata.d.ts

@@ -1,18 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../opra-schema.definition.js';
-import { TypeThunkAsync } from '../types.js';
-export type SimpleTypeMetadata = OpraSchema.SimpleType & {
-    name: string;
-};
-export type ComplexTypeMetadata = StrictOmit<OpraSchema.ComplexType, 'fields' | 'extends'> & {
-    name: string;
-    extends?: ComplexTypeExtendingMetadata[];
-    fields?: Record<string, FieldMetadata>;
-};
-export type FieldMetadata = StrictOmit<OpraSchema.Field, 'type'> & {
-    type?: string | TypeThunkAsync | (string | TypeThunkAsync)[];
-};
-type ComplexTypeExtendingMetadata = StrictOmit<OpraSchema.ComplexTypeExtendingInfo, 'type'> & {
-    type: string | Type;
-};
-export {};

package/typings/common/schema/interfaces/resource-container.interface.d.ts

@@ -1,8 +0,0 @@
-import { CollectionResourceInfo } from '../implementation/resource/collection-resource-info.js';
-import { ResourceInfo } from '../implementation/resource/resource-info.js';
-import { SingletonResourceInfo } from '../implementation/resource/singleton-resource-info.js';
-export interface IResourceContainer {
-    getResource<T extends ResourceInfo>(name: string): T;
-    getCollectionResource(name: string): CollectionResourceInfo;
-    getSingletonResource(name: string): SingletonResourceInfo;
-}

package/typings/common/schema/interfaces/resource.metadata.d.ts

@@ -1,18 +0,0 @@
-import { PartialSome, StrictOmit } from 'ts-gems';
-import { OpraSchema } from '../opra-schema.definition.js';
-import { TypeThunkAsync } from '../types.js';
-export type CollectionResourceMetadata = PartialSome<StrictOmit<OpraSchema.CollectionResource, 'type'>, 'keyFields'> & {
-    type: TypeThunkAsync | string;
-    name: string;
-};
-export type SingletonResourceMetadata = StrictOmit<OpraSchema.SingletonResource, 'type'> & {
-    type: TypeThunkAsync | string;
-    name: string;
-};
-export type ICreateResolverMetadata = StrictOmit<OpraSchema.CreateMethodResolver, 'handler'>;
-export type IDeleteResolverMetadata = StrictOmit<OpraSchema.DeleteMethodResolver, 'handler'>;
-export type IDeleteManyResolverMetadata = StrictOmit<OpraSchema.DeleteManyMethodResolver, 'handler'>;
-export type IGetResolverMetadata = StrictOmit<OpraSchema.GetMethodResolver, 'handler'>;
-export type IUpdateResolverMetadata = StrictOmit<OpraSchema.UpdateMethodResolver, 'handler'>;
-export type IUpdateManyResolverMetadata = StrictOmit<OpraSchema.UpdateManyMethodResolver, 'handler'>;
-export type ISearchResolverMetadata = StrictOmit<OpraSchema.SearchMethodResolver, 'handler'>;

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

@@ -1,178 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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/utils/class.utils.d.ts

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

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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/opra-url-search-params.d.ts

@@ -1,5 +0,0 @@
-import { HttpParams, HttpParamsInit, HttpParamsOptions } from '../http/http-params.js';
-export declare class OpraURLSearchParams extends HttpParams {
-    constructor(init?: HttpParamsInit, options?: HttpParamsOptions);
-    get [Symbol.toStringTag](): string;
-}

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

@@ -1,8 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,76 +0,0 @@
-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';
-export declare class HttpCollectionService<TType, TResponseExt = never> {
-    readonly resource: CollectionResourceInfo;
-    protected _handler: HttpRequestHandler;
-    constructor(resource: CollectionResourceInfo, _handler: HttpRequestHandler);
-    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

@@ -1,18 +0,0 @@
-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,28 +0,0 @@
-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 & 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/requests/collection-create-request.d.ts

@@ -1,7 +0,0 @@
-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;
-    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, data: PartialInput<TType>, options?: CollectionCreateQueryOptions & CommonHttpRequestOptions);
-}

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

@@ -1,7 +0,0 @@
-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;
-    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, options?: CollectionDeleteManyQueryOptions & CommonHttpRequestOptions);
-}

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

@@ -1,7 +0,0 @@
-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;
-    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, id: any, options?: CommonHttpRequestOptions);
-}

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

@@ -1,7 +0,0 @@
-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;
-    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, id: any, options?: CollectionGetQueryOptions & CommonHttpRequestOptions);
-}

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

@@ -1,7 +0,0 @@
-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;
-    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, options?: CollectionSearchQueryOptions & CommonHttpRequestOptions);
-}

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

@@ -1,7 +0,0 @@
-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;
-    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, data: PartialInput<TType>, options?: CollectionUpdateManyQueryOptions & CommonHttpRequestOptions);
-}

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

@@ -1,7 +0,0 @@
-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;
-    constructor(handler: HttpRequestHandler, resource: CollectionResourceInfo, id: any, data: PartialInput<TType>, options?: CollectionUpdateQueryOptions & CommonHttpRequestOptions);
-}

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

@@ -1,7 +0,0 @@
-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);
-}