@opra/client 0.11.7 → 0.12.0

package/typings/common/http/param-codec/integer-codec.d.ts

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

package/typings/common/http/param-codec/number-codec.d.ts

@@ -0,0 +1,12 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export interface NumberFormatOptions {
+    max?: number;
+    min?: number;
+}
+export declare class NumberCodec extends HttpParamCodec {
+    max?: number;
+    min?: number;
+    constructor(options?: NumberFormatOptions);
+    decode(value: string): number;
+    encode(value: any): string;
+}

package/typings/common/http/param-codec/string-codec.d.ts

@@ -0,0 +1,14 @@
+import { HttpParamCodec } from '../http-param-codec.js';
+export interface StringFormatOptions {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+}
+export declare class StringCodec extends HttpParamCodec {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+    constructor(options?: StringFormatOptions);
+    decode(value: string): string;
+    encode(value: any): string;
+}

package/typings/common/http/utils/encodeURIParam.d.ts

@@ -0,0 +1 @@
+export declare function encodeURIParam(v: string): string;

package/typings/common/i18n/i18n.d.ts

@@ -1,15 +1,15 @@
 import { FallbackLng, Formatter as I18nextFormatter, i18n, InitOptions as I18nextInitOptions, Resource as I18nextResource, TFunction as I18nextTFunction, TOptions } from '@browsery/i18next';
 import * as I18next from '@browsery/i18next';
 import { Type } from 'ts-gems';
-export declare type BaseI18n = Type<I18next.i18n>;
+export type BaseI18n = Type<I18next.i18n>;
 export declare const BaseI18n: BaseI18n;
-export declare type DeepTranslateOptions = TOptions & {
+export type DeepTranslateOptions = TOptions & {
     ignore?: (input: any, inst: i18n) => boolean;
 };
-export declare type InitCallback = I18next.Callback;
-export declare type TranslateFunction = I18nextTFunction;
-export declare type Formatter = I18nextFormatter;
-export declare type LanguageResource = I18nextResource;
+export type InitCallback = I18next.Callback;
+export type TranslateFunction = I18nextTFunction;
+export type Formatter = I18nextFormatter;
+export type LanguageResource = I18nextResource;
 export type { FallbackLng };
 export interface InitOptions extends I18nextInitOptions {
     resourceDirs?: string[];

package/typings/common/schema/decorators/opr-collection-resource.decorator.d.ts

@@ -2,7 +2,7 @@ import "reflect-metadata";
 import { PartialSome, StrictOmit } from 'ts-gems';
 import { CollectionResourceMetadata } from '../interfaces/resource.metadata.js';
 import { TypeThunkAsync } from '../types.js';
-export declare type CollectionResourceOptions = PartialSome<StrictOmit<CollectionResourceMetadata, 'name' | 'kind' | 'type' | 'instance' | 'create' | 'count' | 'get' | 'update' | 'updateMany' | 'delete' | 'deleteMany' | 'search'>, 'keyFields'> & {
+export type CollectionResourceOptions = PartialSome<StrictOmit<CollectionResourceMetadata, 'name' | 'kind' | 'type' | 'instance' | 'create' | 'count' | 'get' | 'update' | 'updateMany' | 'delete' | 'deleteMany' | 'search'>, 'keyFields'> & {
     name?: string;
 };
 export declare function OprCollectionResource(entityFunc: TypeThunkAsync, options?: CollectionResourceOptions): (target: Function) => void;

package/typings/common/schema/decorators/opr-complex-type.decorator.d.ts

@@ -1,6 +1,6 @@
 import { StrictOmit } from 'ts-gems';
 import { ComplexTypeMetadata } from '../interfaces/data-type.metadata.js';
-export declare type ComplexTypeDecoratorOptions = Partial<StrictOmit<ComplexTypeMetadata, 'name' | 'kind' | 'ctor' | 'fields' | 'extends'>> & {
+export type ComplexTypeDecoratorOptions = Partial<StrictOmit<ComplexTypeMetadata, 'name' | 'kind' | 'ctor' | 'fields' | 'extends'>> & {
     name?: string;
 };
 export declare function OprComplexType(options?: ComplexTypeDecoratorOptions): ClassDecorator;

package/typings/common/schema/decorators/opr-simple-type.decorator.d.ts

@@ -1,6 +1,6 @@
 import { StrictOmit } from 'ts-gems';
 import { SimpleTypeMetadata } from '../interfaces/data-type.metadata.js';
-export declare type SimpleTypeDecoratorOptions = Partial<StrictOmit<SimpleTypeMetadata, 'name' | 'kind'>> & {
+export type SimpleTypeDecoratorOptions = Partial<StrictOmit<SimpleTypeMetadata, 'name' | 'kind'>> & {
     name?: string;
 };
 export declare function OprSimpleType(options?: SimpleTypeDecoratorOptions): ClassDecorator;

package/typings/common/schema/decorators/opr-singleton-resource.decorator.d.ts

@@ -2,7 +2,7 @@ import "reflect-metadata";
 import { StrictOmit } from 'ts-gems';
 import { SingletonResourceMetadata } from '../interfaces/resource.metadata.js';
 import { TypeThunkAsync } from '../types.js';
-export declare type SingletonResourceOptions = StrictOmit<SingletonResourceMetadata, 'name' | 'kind' | 'type' | 'instance' | 'create' | 'get' | 'update' | 'delete'> & {
+export type SingletonResourceOptions = StrictOmit<SingletonResourceMetadata, 'name' | 'kind' | 'type' | 'instance' | 'create' | 'get' | 'update' | 'delete'> & {
     name?: string;
 };
 export declare function OprSingletonResource(type: TypeThunkAsync | string, options?: SingletonResourceOptions): (target: Function) => void;

package/typings/common/schema/implementation/data-type/complex-type.d.ts

@@ -4,7 +4,7 @@ import { OpraSchema } from '../../opra-schema.definition.js';
 import { nodeInspectCustom } from '../../utils/inspect.util.js';
 import type { OpraDocument } from '../opra-document';
 import { DataType } from './data-type.js';
-export declare type ComplexTypeArgs = StrictOmit<OpraSchema.ComplexType, 'kind'>;
+export type ComplexTypeArgs = StrictOmit<OpraSchema.ComplexType, 'kind'>;
 export declare class ComplexType extends DataType {
     protected _initialized: boolean;
     protected _metadata: OpraSchema.ComplexType;

package/typings/common/schema/implementation/data-type/union-type.d.ts

@@ -3,7 +3,7 @@ import { OpraSchema } from '../../opra-schema.definition.js';
 import { nodeInspectCustom } from '../../utils/inspect.util.js';
 import type { OpraDocument } from '../opra-document';
 import { DataType } from './data-type.js';
-export declare type UnionTypeArgs = StrictOmit<OpraSchema.UnionType, 'kind'> & {
+export type UnionTypeArgs = StrictOmit<OpraSchema.UnionType, 'kind'> & {
     types: DataType[];
 };
 export declare class UnionType extends DataType {

package/typings/common/schema/implementation/document-builder.d.ts

@@ -2,7 +2,7 @@ import { Type } from 'ts-gems';
 import { ResponsiveMap } from '../../helpers/responsive-map.js';
 import { OpraSchema } from '../opra-schema.definition.js';
 import { ThunkAsync } from '../types.js';
-export declare type DocumentBuilderArgs = Pick<OpraSchema.Document, 'info' | 'servers'>;
+export type DocumentBuilderArgs = Pick<OpraSchema.Document, 'info' | 'servers'>;
 export declare class DocumentBuilder {
     protected _args: DocumentBuilderArgs;
     protected _dataTypes: ResponsiveMap<string, OpraSchema.DataType>;

package/typings/common/schema/implementation/opra-document.d.ts

@@ -11,11 +11,11 @@ import { DocumentBuilderArgs } from './document-builder.js';
 import { CollectionResourceInfo } from './resource/collection-resource-info.js';
 import { ResourceInfo } from './resource/resource-info.js';
 import { SingletonResourceInfo } from './resource/singleton-resource-info.js';
-export declare type OpraDocumentArgs = DocumentBuilderArgs & {
+export type OpraDocumentArgs = DocumentBuilderArgs & {
     types?: ThunkAsync<Type>[] | Record<string, OpraSchema.DataType>;
     resources?: ThunkAsync<any>[] | Record<string, OpraSchema.Resource>;
 };
-declare type OpraDocumentMeta = Pick<OpraSchema.Document, 'info' | 'servers'>;
+type OpraDocumentMeta = Pick<OpraSchema.Document, 'info' | 'servers'>;
 export declare namespace OpraDocument {
 }
 export declare class OpraDocument implements IResourceContainer {

package/typings/common/schema/implementation/query/collection-count-query.d.ts

@@ -1,6 +1,6 @@
 import { Expression } from '../../../filter/index.js';
 import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
-export declare type CollectionCountQueryOptions = {
+export type CollectionCountQueryOptions = {
     filter?: string | Expression;
 };
 export declare class CollectionCountQuery {

package/typings/common/schema/implementation/query/collection-create-query.d.ts

@@ -1,5 +1,5 @@
 import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
-export declare type CollectionCreateQueryOptions = {
+export type CollectionCreateQueryOptions = {
     pick?: string[];
     omit?: string[];
     include?: string[];

package/typings/common/schema/implementation/query/collection-delete-many-query.d.ts

@@ -1,6 +1,6 @@
 import { Expression } from '../../../filter/index.js';
 import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
-export declare type CollectionDeleteManyQueryOptions = {
+export type CollectionDeleteManyQueryOptions = {
     filter?: string | Expression;
 };
 export declare class CollectionDeleteManyQuery {

package/typings/common/schema/implementation/query/collection-get-query.d.ts

@@ -1,7 +1,7 @@
 import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
 import type { CollectionResourceInfo } from '../resource/collection-resource-info.js';
 import type { FieldGetQuery } from './field-get-query.js';
-export declare type CollectionGetQueryOptions = {
+export type CollectionGetQueryOptions = {
     pick?: string[];
     omit?: string[];
     include?: string[];

package/typings/common/schema/implementation/query/collection-search-query.d.ts

@@ -1,6 +1,6 @@
 import { Expression } from '../../../filter/index.js';
 import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
-export declare type CollectionSearchQueryOptions = {
+export type CollectionSearchQueryOptions = {
     pick?: string[];
     omit?: string[];
     include?: string[];

package/typings/common/schema/implementation/query/collection-update-many-query.d.ts

@@ -1,6 +1,6 @@
 import { Expression } from '../../../filter/index.js';
 import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
-export declare type CollectionUpdateManyQueryOptions = {
+export type CollectionUpdateManyQueryOptions = {
     filter?: string | Expression;
 };
 export declare class CollectionUpdateManyQuery {

package/typings/common/schema/implementation/query/collection-update-query.d.ts

@@ -1,5 +1,5 @@
 import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
-export declare type CollectionUpdateQueryOptions = {
+export type CollectionUpdateQueryOptions = {
     pick?: string[];
     omit?: string[];
     include?: string[];

package/typings/common/schema/implementation/query/field-get-query.d.ts

@@ -5,7 +5,7 @@ import type { CollectionResourceInfo } from '../resource/collection-resource-inf
 import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
 import type { CollectionGetQuery } from './collection-get-query.js';
 import type { SingletonGetQuery } from './singleton-get-query.js';
-export declare type FieldGetQueryOptions = {
+export type FieldGetQueryOptions = {
     pick?: string[];
     omit?: string[];
     include?: string[];

package/typings/common/schema/implementation/query/index.d.ts

@@ -20,8 +20,8 @@ export * from './singleton-get-query.js';
 export * from './collection-search-query.js';
 export * from './collection-update-many-query.js';
 export * from './collection-update-query.js';
-export declare type CollectionQuery = CollectionCountQuery | CollectionCreateQuery | CollectionDeleteManyQuery | CollectionDeleteQuery | CollectionGetQuery | CollectionSearchQuery | CollectionUpdateManyQuery | CollectionUpdateQuery;
-export declare type FieldQuery = FieldGetQuery;
-export declare type SingletonQuery = SingletonGetQuery;
-export declare type OpraQuery = CollectionQuery | SingletonQuery | FieldQuery;
+export type CollectionQuery = CollectionCountQuery | CollectionCreateQuery | CollectionDeleteManyQuery | CollectionDeleteQuery | CollectionGetQuery | CollectionSearchQuery | CollectionUpdateManyQuery | CollectionUpdateQuery;
+export type FieldQuery = FieldGetQuery;
+export type SingletonQuery = SingletonGetQuery;
+export type OpraQuery = CollectionQuery | SingletonQuery | FieldQuery;
 export declare function isChildFieldQuery(query: any): query is IChildFieldQuery;

package/typings/common/schema/implementation/query/singleton-get-query.d.ts

@@ -1,7 +1,7 @@
 import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
 import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
 import type { FieldGetQuery } from './field-get-query.js';
-export declare type SingletonGetQueryOptions = {
+export type SingletonGetQueryOptions = {
     pick?: string[];
     omit?: string[];
     include?: string[];

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

@@ -6,6 +6,7 @@ export declare class CollectionResourceInfo extends ResourceInfo {
     readonly metadata: OpraSchema.CollectionResource;
     readonly dataType: ComplexType;
     constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.CollectionResource);
+    get instance(): {} | undefined;
     get keyFields(): string[];
     get create(): OpraSchema.CreateMethodResolver | undefined;
     get count(): OpraSchema.MethodResolver | undefined;
@@ -15,5 +16,6 @@ export declare class CollectionResourceInfo extends ResourceInfo {
     get update(): OpraSchema.UpdateMethodResolver | undefined;
     get updateMany(): OpraSchema.UpdateManyMethodResolver | undefined;
     get search(): OpraSchema.SearchMethodResolver | undefined;
+    getHandler(method: string): Function;
     getSchema(jsonOnly?: boolean): OpraSchema.CollectionResource;
 }

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

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

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

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

@@ -1,14 +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>[] : {
+export type PartialInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
+export type PartialOutput<T> = DeepNullablePartial<T>;
+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 & {
+export type Thunk<T> = T | (() => T);
+export type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export type TypeThunk<T = any> = Thunk<Type<T>>;
+export type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
+export type Named<T> = T & {
     name: string;
 };
 export {};

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

@@ -1,5 +1,5 @@
 declare const nodeInspectCustom: unique symbol;
-export declare type OpraURLPathComponentInit = {
+export type OpraURLPathComponentInit = {
     resource: string;
     key?: any;
     typeCast?: string;

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

@@ -1,30 +1,36 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
+import type { OpraURL } from './opra-url.js';
 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);
+declare const kEntries: unique symbol;
+declare const kOptions: unique symbol;
+export interface OpraURLPathOptions {
+    onChange?: () => void;
+}
+export declare class OpraURLPath {
+    protected static kEntries: symbol;
+    protected static kOptions: symbol;
+    protected [kEntries]: OpraURLPathComponent[];
+    protected [kOptions]: OpraURLPathOptions;
+    constructor(init?: string | OpraURLPath | URL | OpraURLPathComponentInit | OpraURLPathComponentInit[], options?: OpraURLPathOptions);
     get size(): number;
-    add(component: OpraURLPathComponent | {
-        resource: string;
-        key?: any;
-        typeCast?: string;
-    }): void;
-    add(name: string, key?: any, typeCast?: string): void;
+    changed(): void;
     clear(): void;
     get(index: number): OpraURLPathComponent;
-    join(pathString: string): this;
+    join(...source: (string | OpraURLPath | URL | OpraURL | OpraURLPathComponentInit)[]): this;
     entries(): IterableIterator<[OpraURLPathComponent, number]>;
-    values(): IterableIterator<OpraURLPathComponent>;
-    forEach(callback: (name: string, key: any, _this: this) => void): void;
+    forEach(callback: (component: OpraURLPathComponent, _this: this) => void): void;
     getResource(index: number): string | undefined;
     getKey(index: number): any;
+    pop(): OpraURLPathComponent | undefined;
+    shift(): OpraURLPathComponent | undefined;
+    slice(start: number, end?: number): OpraURLPath;
+    splice(start: number, deleteCount: number, join?: string | OpraURLPath | URL | OpraURL | OpraURLPathComponentInit | OpraURLPathComponentInit[]): void;
+    unshift(join: string | OpraURLPath | URL | OpraURL | OpraURLPathComponentInit | OpraURLPathComponentInit[]): void;
     toString(): string;
-    [Symbol.iterator](): IterableIterator<[OpraURLPathComponent, number]>;
+    values(): IterableIterator<OpraURLPathComponent>;
+    protected _join(target: OpraURLPathComponent[], source: string | OpraURLPath | URL | OpraURL | OpraURLPathComponentInit | OpraURLPathComponentInit[]): void;
     [nodeInspectCustom](): OpraURLPathComponent[];
-    protected _add(component: any, key?: any, typeCast?: string): void;
-    protected _parse(v: string): void;
+    [Symbol.iterator](): IterableIterator<[OpraURLPathComponent, number]>;
+    get [Symbol.toStringTag](): string;
 }
 export {};

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

@@ -1,44 +1,5 @@
-/// <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]>;
+import { HttpParams, HttpParamsInit, HttpParamsOptions } from '../http/http-params.js';
+export declare class OpraURLSearchParams extends HttpParams {
+    constructor(init?: HttpParamsInit, options?: HttpParamsOptions);
     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

@@ -1,42 +1,52 @@
+import type { HttpParamDefinition } from '../http/http-params.js';
 import { OpraURLPath } from './opra-url-path.js';
+import { OpraURLPathComponentInit } from './opra-url-path-component.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;
+declare const kContext: unique symbol;
+declare const kPath: unique symbol;
+declare const kSearchParams: unique symbol;
 export declare class OpraURL {
-    protected [CONTEXT_KEY]: {
+    protected static kContext: symbol;
+    protected static kPath: symbol;
+    protected static kSearchParams: symbol;
+    protected [kContext]: {
         protocol: string;
         username: string;
-        password: string;
+        pathname: string;
+        prefix: string;
         hostname: string;
-        pathPrefix: string;
-        port: number | null;
+        port: string;
         hash: string;
-        pathname: string;
+        password: string;
         search: string;
+        address: string;
         needUpdate: boolean;
     };
-    protected [PATH_KEY]: OpraURLPath;
-    protected [SEARCHPARAMS_KEY]: OpraURLSearchParams;
-    constructor(input?: string, pathPrefix?: string);
+    protected [kPath]: OpraURLPath;
+    protected [kSearchParams]: OpraURLSearchParams;
+    constructor(input?: string | URL | OpraURL, base?: string | URL | OpraURL);
+    constructor(input?: string | URL | OpraURL, options?: {
+        base?: string | URL | OpraURL;
+        params?: Record<string, HttpParamDefinition>;
+    });
     get address(): string;
+    get host(): string;
+    set host(v: string);
+    get hostname(): string;
+    set hostname(v: string);
     get href(): string;
+    get password(): string;
+    set password(v: string);
+    get port(): string;
+    set port(value: string);
+    get prefix(): string;
+    set prefix(value: 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);
@@ -45,18 +55,18 @@ export declare class OpraURL {
     set hash(v: string);
     get search(): string;
     set search(v: string);
-    addPath(name: string, key?: any): this;
-    addSearchParam(name: string, value?: any): this;
+    parse(input: string): void;
+    join(...source: (string | OpraURLPath | URL | OpraURL | OpraURLPathComponentInit)[]): this;
+    addParam(name: string, value?: any): this;
+    setParam(name: string, value?: any): this;
     setHost(v: string): this;
     setHostname(v: string): this;
     setProtocol(v: string): this;
-    setPort(v: number | null): this;
+    setPort(v: string | 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;
@@ -72,8 +82,8 @@ export declare class OpraURL {
         searchParams: OpraURLSearchParams;
         hash: string;
     };
-    protected _invalidate(): void;
     protected _update(): void;
-    protected _setPathname(v: string, inclSvcRoot?: boolean): void;
+    protected _setPathname(v: string, trimPrefix?: boolean): void;
+    protected _changed(): void;
 }
 export {};

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

@@ -1,26 +1,43 @@
-import { Type } from 'ts-gems';
-import { OpraDocument } from '../common';
+import { Observable, Subscriber } from 'rxjs';
+import { StrictOmit, Type } from 'ts-gems';
+import { HttpHeaders, HttpHeadersInit, HttpParams, HttpParamsInit, HttpRequest, HttpResponse, HttpResponseInit, OpraDocument } from '../common';
 import { HttpCollectionService } from './http-collection-service.js';
-import { HttpRequest } from './http-request.js';
-import { HttpResponse } from './http-response.js';
 import { HttpSingletonService } from './http-singleton-service.js';
-import { HttpRequestDefaults, OpraHttpClientOptions, RawHttpRequest } from './http-types.js';
-import { BatchRequest } from './requests/batch-request.js';
-export declare class OpraHttpClient {
+import { HttpEvent, HttpRequestDefaults, ObserveType } from './http-types.js';
+export interface OpraHttpClientOptions {
+    /**
+     //    * Opra Service Metadata Document
+     //    */
+    document?: OpraDocument;
+    /**
+     *
+     */
+    defaults?: StrictOmit<HttpRequestDefaults, 'headers' | 'params'> & {
+        headers?: HttpHeadersInit;
+        params?: HttpParamsInit;
+    };
+}
+export declare abstract class OpraHttpClientBase<TResponseExt = never> {
     protected _serviceUrl: string;
     protected _metadata?: OpraDocument;
-    defaults: HttpRequestDefaults;
+    defaults: StrictOmit<HttpRequestDefaults, 'headers' | 'params'> & {
+        headers: HttpHeaders;
+        params: HttpParams;
+    };
     constructor(serviceUrl: string, options?: OpraHttpClientOptions);
     get serviceUrl(): string;
     get initialized(): boolean;
     get metadata(): OpraDocument;
     init(forceRefresh?: boolean): Promise<void>;
-    batch(requests: HttpRequest[]): BatchRequest;
-    collection<T = any>(name: string | Type<T>): HttpCollectionService<T>;
-    singleton<T = any>(name: string | Type<T>): HttpSingletonService<T>;
+    collection<TType = any>(name: string | Type<TType>): HttpCollectionService<TType, TResponseExt>;
+    singleton<TType = any>(name: string | Type<TType>): HttpSingletonService<TType, TResponseExt>;
     protected _resolveMetadata(): Promise<void>;
-    protected _handleRequest<TResponse extends HttpResponse = HttpResponse>(req: RawHttpRequest): Promise<TResponse>;
-    protected _fetch<TResponse extends HttpResponse = HttpResponse>(url: string, req: RequestInit): Promise<TResponse>;
+    protected _sendRequest<TBody>(observe: ObserveType, request: HttpRequest): Observable<HttpResponse<TBody> | TBody | HttpEvent>;
+    protected _fetch(url: string, init?: RequestInit): Promise<Response>;
+    protected _createResponse(init?: HttpResponseInit): HttpResponse;
+    protected _handleResponse(observe: ObserveType, subscriber: Subscriber<any>, request: HttpRequest, fetchResponse: Response): void;
     protected _assertMetadata(): void;
     static create<T extends OpraHttpClient>(this: Type<T>, serviceUrl: string, options?: OpraHttpClientOptions): Promise<T>;
 }
+export declare class OpraHttpClient extends OpraHttpClientBase {
+}