@opra/client 0.13.0 → 0.15.0

package/typings/common/document/data-type/mapped-type.d.ts

@@ -0,0 +1,53 @@
+import { Class, StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { ComplexType } from './complex-type.js';
+import { DataType } from './data-type.js';
+/**
+ * @namespace MappedType
+ */
+export declare namespace MappedType {
+    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.MappedType, 'pick' | 'omit'> {
+        type: ComplexType;
+    }
+    interface OwnProperties extends DataType.OwnProperties, Pick<OpraSchema.MappedType, 'pick' | 'omit'> {
+        type: ComplexType;
+    }
+    interface Options<T, K = keyof T> {
+        pick?: readonly K[];
+        omit?: readonly K[];
+    }
+    interface Metadata extends StrictOmit<OpraSchema.MappedType, 'type'> {
+        type: Type;
+    }
+}
+/**
+ * Type definition of MappedType prototype
+ * @type MappedType
+ */
+export interface MappedType extends StrictOmit<DataType, 'own' | 'exportSchema'>, Pick<ComplexType, 'additionalFields' | 'fields'>, MappedType.OwnProperties {
+    readonly own: MappedType.OwnProperties;
+    readonly type: ComplexType;
+    exportSchema(): OpraSchema.MappedType;
+}
+/**
+ * Type definition of MappedType constructor type
+ * @type MappedTypeConstructor
+ */
+export interface MappedTypeConstructor {
+    prototype: MappedType;
+    new (document: ApiDocument, init: MappedType.InitArguments): MappedType;
+    <T extends any[], I1, S1, PickKey extends keyof I1, OmitKey extends keyof I1>(source: Class<T, I1, S1>, options: {
+        pickKeys?: readonly PickKey[];
+        omitKeys?: readonly OmitKey[];
+    }): Class<T, Omit<Pick<I1, PickKey>, OmitKey>>;
+    _applyMixin(target: Type, source: Type, options: MappedType.Options<any> & {
+        isInheritedPredicate: (fieldName: string) => boolean;
+    }): void;
+}
+/**
+ * @class MappedType
+ */
+export declare const MappedType: MappedTypeConstructor;
+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/document/data-type/simple-type.d.ts

@@ -0,0 +1,33 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { DataType } from './data-type.js';
+export declare namespace SimpleType {
+    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.SimpleType, 'ctor' | 'pattern' | 'codec'> {
+        base?: SimpleType;
+    }
+    interface OwnProperties extends DataType.OwnProperties, Readonly<Pick<OpraSchema.SimpleType, 'ctor' | 'pattern' | 'codec'>> {
+    }
+    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'pattern'> {
+    }
+    interface Metadata extends OpraSchema.SimpleType {
+        name: string;
+    }
+}
+export interface SimpleType extends StrictOmit<DataType, 'own' | 'exportSchema'>, SimpleType.OwnProperties {
+    readonly ctor: Type;
+    readonly base?: SimpleType;
+    readonly own: SimpleType.OwnProperties;
+    exportSchema(): OpraSchema.SimpleType;
+    decode(value: any): any;
+    encode(value: any): any;
+}
+export interface SimpleTypeConstructor {
+    new (document: ApiDocument, init?: SimpleType.InitArguments): SimpleType;
+    (init?: SimpleType.DecoratorOptions): ClassDecorator;
+    prototype: SimpleType;
+}
+/**
+ * @class SimpleType
+ */
+export declare const SimpleType: SimpleTypeConstructor;

package/typings/common/document/data-type/union-type.d.ts

@@ -0,0 +1,42 @@
+import { Class, StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { ComplexType } from './complex-type.js';
+import { DataType } from './data-type.js';
+import { MappedType } from './mapped-type.js';
+/**
+ * @namespace UnionType
+ */
+export declare namespace UnionType {
+    interface InitArguments extends DataType.InitArguments {
+        types: (ComplexType | UnionType | MappedType)[];
+    }
+    interface OwnProperties extends DataType.OwnProperties {
+        types: (ComplexType | UnionType | MappedType)[];
+    }
+    interface Metadata extends StrictOmit<OpraSchema.UnionType, 'types'> {
+        types: Type[];
+    }
+}
+/**
+ * Type definition of UnionType prototype
+ * @type UnionType
+ */
+export interface UnionType extends StrictOmit<DataType, 'own' | 'exportSchema'>, Pick<ComplexType, 'additionalFields' | 'fields'>, UnionType.OwnProperties {
+    readonly own: UnionType.OwnProperties;
+    exportSchema(): OpraSchema.UnionType;
+}
+/**
+ * Type definition of UnionType constructor type
+ * @type UnionTypeConstructor
+ */
+export interface UnionTypeConstructor {
+    prototype: UnionType;
+    new (document: ApiDocument, init: UnionType.InitArguments): UnionType;
+    <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>;
+    _applyMixin(target: Type, ...sources: [Type]): void;
+}
+/**
+ * @class UnionType
+ */
+export declare const UnionType: UnionTypeConstructor;

package/typings/common/document/factory/add-references.d.ts

@@ -0,0 +1,4 @@
+import type { OpraSchema } from '../../schema/index.js';
+import { ApiDocument } from '../api-document.js';
+import type { DocumentFactory } from './factory.js';
+export declare function addReferences(this: DocumentFactory, references: Record<string, string | OpraSchema.ApiDocument | ApiDocument>): Promise<void>;

package/typings/common/document/factory/create-document.d.ts

@@ -0,0 +1,12 @@
+import { ApiDocument } from '../api-document.js';
+import type { DocumentFactory } from './factory.js';
+export declare function createDocument(this: DocumentFactory, init: DocumentFactory.InitArguments, options?: {
+    noBuiltinTypes?: boolean;
+}): Promise<ApiDocument>;
+/**
+ *
+ * @param url
+ * @protected
+ */
+export declare function createDocumentFromUrl(this: DocumentFactory, url: string): Promise<ApiDocument>;
+export declare function createBuiltinTypeDocument(this: DocumentFactory): Promise<ApiDocument>;

package/typings/common/document/factory/factory.d.ts

@@ -0,0 +1,61 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { ThunkAsync } from '../../types.js';
+import { ApiDocument } from '../api-document.js';
+import { addReferences } from './add-references.js';
+import { createBuiltinTypeDocument, createDocument, createDocumentFromUrl } from './create-document.js';
+import { extractCollectionSchema, extractSingletonSchema, importResourceClass } from './import-resource-class.js';
+import { extractComplexTypeSchema, extractEnumTypeSchema, extractFieldSchema, extractMappedTypeSchema, extractSimpleTypeSchema, extractUnionTypeSchema, importTypeClass } from './import-type-class.js';
+import { createCollection, createSingleton, processResourceQueue } from './process-resources.js';
+import { addDataType, createDataTypeInstance, processTypes } from './process-types.js';
+/**
+ * @namespace DocumentFactory
+ */
+export declare namespace DocumentFactory {
+    type InitArguments = StrictOmit<OpraSchema.ApiDocument, 'references' | 'types' | 'resources'> & {
+        references?: Record<string, string | OpraSchema.ApiDocument | ApiDocument>;
+        resources?: ThunkAsync<Type | object>[] | Record<OpraSchema.Resource.Name, OpraSchema.Resource>;
+        types?: ThunkAsync<Type | OpraSchema.EnumThunk>[] | Record<string, OpraSchema.DataType>;
+    };
+}
+/**
+ * @class DocumentFactory
+ */
+export declare class DocumentFactory {
+    protected document: ApiDocument;
+    protected typeQueue: ResponsiveMap<OpraSchema.DataType>;
+    protected resourceQueue: ResponsiveMap<OpraSchema.Resource>;
+    protected circularRefs: ResponsiveMap<any>;
+    protected curPath: string[];
+    protected cache: Map<any, any>;
+    protected createDocument: typeof createDocument;
+    protected createDocumentFromUrl: typeof createDocumentFromUrl;
+    protected createBuiltinTypeDocument: typeof createBuiltinTypeDocument;
+    protected addReferences: typeof addReferences;
+    protected importTypeClass: typeof importTypeClass;
+    protected extractSimpleTypeSchema: typeof extractSimpleTypeSchema;
+    protected extractComplexTypeSchema: typeof extractComplexTypeSchema;
+    protected extractMappedTypeSchema: typeof extractMappedTypeSchema;
+    protected extractUnionTypeSchema: typeof extractUnionTypeSchema;
+    protected extractEnumTypeSchema: typeof extractEnumTypeSchema;
+    protected extractFieldSchema: typeof extractFieldSchema;
+    protected processTypes: typeof processTypes;
+    protected createDataTypeInstance: typeof createDataTypeInstance;
+    protected addDataType: typeof addDataType;
+    protected importResourceClass: typeof importResourceClass;
+    protected extractSingletonSchema: typeof extractSingletonSchema;
+    protected extractCollectionSchema: typeof extractCollectionSchema;
+    protected processResourceQueue: typeof processResourceQueue;
+    protected createCollection: typeof createCollection;
+    protected createSingleton: typeof createSingleton;
+    /**
+     * Creates ApiDocument instance from given schema object
+     * @param init
+     */
+    static createDocument(init: DocumentFactory.InitArguments): Promise<ApiDocument>;
+    /**
+     * Downloads schema from the given URL and creates the document instance   * @param url
+     */
+    static createDocumentFromUrl(url: string): Promise<ApiDocument>;
+}

package/typings/common/document/factory/import-resource-class.d.ts

@@ -0,0 +1,9 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ThunkAsync } from '../../types.js';
+import type { Collection } from '../resource/collection.js';
+import type { Singleton } from '../resource/singleton.js';
+import type { DocumentFactory } from './factory.js';
+export declare function importResourceClass(this: DocumentFactory, thunk: ThunkAsync<Type | object>): Promise<void>;
+export declare function extractSingletonSchema(this: DocumentFactory, target: OpraSchema.Singleton, ctor: Type, metadata: Singleton.Metadata, controller: object | Type): Promise<void>;
+export declare function extractCollectionSchema(this: DocumentFactory, target: OpraSchema.Collection, ctor: Type, metadata: Collection.Metadata, controller: object | Type): Promise<void>;

package/typings/common/document/factory/import-type-class.d.ts

@@ -0,0 +1,17 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ThunkAsync } from '../../types.js';
+import type { ApiField } from '../data-type/api-field.js';
+import type { ComplexType } from '../data-type/complex-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import type { MappedType } from '../data-type/mapped-type.js';
+import type { SimpleType } from '../data-type/simple-type.js';
+import type { UnionType } from '../data-type/union-type.js';
+import type { DocumentFactory } from './factory.js';
+export declare function importTypeClass(this: DocumentFactory, typeThunk: ThunkAsync<Type | OpraSchema.EnumThunk>): Promise<string | OpraSchema.DataType>;
+export declare function extractSimpleTypeSchema(this: DocumentFactory, target: OpraSchema.SimpleType, ctor: Type, metadata: SimpleType.Metadata): Promise<void>;
+export declare function extractComplexTypeSchema(this: DocumentFactory, target: OpraSchema.ComplexType, ctor: Type, metadata: ComplexType.Metadata): Promise<void>;
+export declare function extractMappedTypeSchema(this: DocumentFactory, target: OpraSchema.MappedType, ctor: Type, metadata: MappedType.Metadata): Promise<void>;
+export declare function extractUnionTypeSchema(this: DocumentFactory, target: OpraSchema.UnionType, ctor: Type, metadata: UnionType.Metadata): Promise<void>;
+export declare function extractEnumTypeSchema(this: DocumentFactory, target: OpraSchema.EnumType, enumObject: any, metadata: EnumType.Metadata): Promise<void>;
+export declare function extractFieldSchema(this: DocumentFactory, target: OpraSchema.Field, ctor: Type, metadata: ApiField.Metadata, name: string): Promise<void>;

package/typings/common/document/factory/index.d.ts

@@ -0,0 +1 @@
+export * from './factory.js';

package/typings/common/document/factory/process-resources.d.ts

@@ -0,0 +1,7 @@
+import { OpraSchema } from '../../schema/index.js';
+import { Collection } from '../resource/collection.js';
+import { Singleton } from '../resource/singleton.js';
+import type { DocumentFactory } from './factory.js';
+export declare function processResourceQueue(this: DocumentFactory): Promise<void>;
+export declare function createCollection(this: DocumentFactory, name: string, schema: OpraSchema.Collection): Promise<Collection>;
+export declare function createSingleton(this: DocumentFactory, name: string, schema: OpraSchema.Singleton): Promise<Singleton>;

package/typings/common/document/factory/process-types.d.ts

@@ -0,0 +1,6 @@
+import { OpraSchema } from '../../schema/index.js';
+import { DataType } from '../data-type/data-type.js';
+import type { DocumentFactory } from './factory.js';
+export declare function processTypes(this: DocumentFactory): Promise<void>;
+export declare function createDataTypeInstance(this: DocumentFactory, kind: OpraSchema.DataType.Kind, name?: string): DataType;
+export declare function addDataType(this: DocumentFactory, schemaOrName: OpraSchema.DataType | string): DataType;

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

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+export * from './constants.js';
+export * from './api-document.js';
+export * from './factory/index.js';
+export * from './data-type/data-type.js';
+export * from './data-type/complex-type.js';
+export * from './data-type/api-field.js';
+export * from './data-type/enum-type.js';
+export * from './data-type/mapped-type.js';
+export * from './data-type/simple-type.js';
+export * from './data-type/union-type.js';
+export * from './resource/resource.js';
+export * from './resource/collection.js';
+export * from './resource/singleton.js';

package/typings/common/document/resource/collection.d.ts

@@ -0,0 +1,67 @@
+import { StrictOmit } from 'ts-gems';
+import { Expression } from '../../filter/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { TypeThunkAsync } from '../../types.js';
+import type { ApiDocument } from '../api-document.js';
+import type { ComplexType } from '../data-type/complex-type.js';
+import { Resource } from './resource.js';
+export declare namespace Collection {
+    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Collection, 'primaryKey'> {
+        type: ComplexType;
+        operations: Operations;
+    }
+    export interface DecoratorOptions extends Resource.DecoratorOptions, Partial<Pick<OpraSchema.Collection, 'primaryKey'>> {
+    }
+    export interface Metadata extends StrictOmit<OpraSchema.Collection, 'type'> {
+        name: string;
+        type: TypeThunkAsync | string;
+    }
+    interface Operation {
+        handlerName?: string;
+    }
+    export interface Operations {
+        create?: OpraSchema.Collection.CreateOperation & Operation;
+        delete?: OpraSchema.Collection.DeleteOperation & Operation;
+        deleteMany?: OpraSchema.Collection.DeleteManyOperation & Operation;
+        get?: OpraSchema.Collection.GetOperation & Operation;
+        update?: OpraSchema.Collection.UpdateOperation & Operation;
+        updateMany?: OpraSchema.Collection.UpdateManyOperation & Operation;
+        search?: OpraSchema.Collection.SearchOperation & Operation;
+    }
+    export type CreateOperationOptions = StrictOmit<OpraSchema.Collection.CreateOperation, 'handler'>;
+    export type DeleteOperationOptions = StrictOmit<OpraSchema.Collection.DeleteOperation, 'handler'>;
+    export type DeleteManyOperationOptions = StrictOmit<OpraSchema.Collection.DeleteManyOperation, 'handler'>;
+    export type GetOperationOptions = StrictOmit<OpraSchema.Collection.GetOperation, 'handler'>;
+    export type UpdateOperationOptions = StrictOmit<OpraSchema.Collection.UpdateOperation, 'handler'>;
+    export type UpdateManyOperationOptions = StrictOmit<OpraSchema.Collection.UpdateManyOperation, 'handler'>;
+    export type SearchOperationOptions = StrictOmit<OpraSchema.Collection.SearchOperation, 'handler'>;
+    export {};
+}
+export interface Collection extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
+    readonly type: ComplexType;
+    readonly operations: Collection.Operations;
+    readonly controller?: object;
+    readonly primaryKey: string[];
+    exportSchema(): OpraSchema.Collection;
+    parseKeyValue(value: any): any;
+    normalizeFieldNames(fields: string[]): string[] | undefined;
+    normalizeSortFields(fields: string[]): string[] | undefined;
+    normalizeFilterFields(ast: Expression): Expression;
+    _construct(init: Collection.InitArguments): void;
+}
+export interface CollectionConstructor {
+    prototype: Collection;
+    new (document: ApiDocument, init: Collection.InitArguments): Collection;
+    (type: TypeThunkAsync | string, options?: Collection.DecoratorOptions): ClassDecorator;
+    CreateOperation: (options?: Collection.CreateOperationOptions) => PropertyDecorator;
+    GetOperation: (options?: Collection.GetOperationOptions) => PropertyDecorator;
+    DeleteOperation: (options?: Collection.DeleteOperationOptions) => PropertyDecorator;
+    UpdateOperation: (options?: Collection.UpdateOperationOptions) => PropertyDecorator;
+    SearchOperation: (options?: Collection.SearchOperationOptions) => PropertyDecorator;
+    UpdateManyOperation: (options?: Collection.UpdateManyOperationOptions) => PropertyDecorator;
+    DeleteManyOperation: (options?: Collection.DeleteManyOperationOptions) => PropertyDecorator;
+}
+/**
+ *
+ */
+export declare const Collection: CollectionConstructor;

package/typings/common/document/resource/resource.d.ts

@@ -0,0 +1,29 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { nodeInspectCustom } from '../utils/inspect.util.js';
+export declare namespace Resource {
+    interface InitArguments extends StrictOmit<OpraSchema.ResourceBase, 'kind'> {
+        name: string;
+        controller?: object | Type;
+    }
+    interface DecoratorOptions extends Partial<Pick<InitArguments, 'name' | 'description'>> {
+    }
+}
+export interface Resource {
+    readonly document: ApiDocument;
+    readonly kind: OpraSchema.Resource.Kind;
+    readonly name: string;
+    readonly description?: string;
+    readonly controller?: object | Type;
+    exportSchema(): OpraSchema.ResourceBase;
+    toString(): string;
+    [nodeInspectCustom](): string;
+    _construct(init: Resource.InitArguments): void;
+}
+export interface ResourceConstructor {
+    readonly prototype: Resource;
+    new (document: ApiDocument, init: Resource.InitArguments): Resource;
+    (...args: any[]): void;
+}
+export declare const Resource: ResourceConstructor;

package/typings/common/document/resource/singleton.d.ts

@@ -0,0 +1,49 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { TypeThunkAsync } from '../../types.js';
+import type { ApiDocument } from '../api-document.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import { Resource } from './resource.js';
+export declare namespace Singleton {
+    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Singleton, 'operations'> {
+        type: ComplexType;
+    }
+    export interface DecoratorOptions extends Resource.DecoratorOptions {
+    }
+    export interface Metadata extends StrictOmit<OpraSchema.Singleton, 'type'> {
+        name: string;
+        type: TypeThunkAsync | string;
+    }
+    interface Operation {
+        handlerName?: string;
+    }
+    export interface Operations {
+        create?: OpraSchema.Singleton.CreateOperation & Operation;
+        delete?: OpraSchema.Singleton.DeleteOperation & Operation;
+        get?: OpraSchema.Singleton.GetOperation & Operation;
+        update?: OpraSchema.Singleton.UpdateOperation & Operation;
+    }
+    export type CreateOperationOptions = StrictOmit<OpraSchema.Singleton.CreateOperation, 'handler'>;
+    export type DeleteOperationOptions = StrictOmit<OpraSchema.Singleton.DeleteOperation, 'handler'>;
+    export type GetOperationOptions = StrictOmit<OpraSchema.Singleton.GetOperation, 'handler'>;
+    export type UpdateOperationOptions = StrictOmit<OpraSchema.Singleton.UpdateOperation, 'handler'>;
+    export {};
+}
+export interface Singleton extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
+    readonly type: ComplexType;
+    readonly operations: Singleton.Operations;
+    readonly controller?: object | Type;
+    exportSchema(): OpraSchema.Singleton;
+    normalizeFieldNames(fields: string[]): string[] | undefined;
+    _construct(init: Singleton.InitArguments): void;
+}
+export interface SingletonConstructor {
+    prototype: Singleton;
+    new (document: ApiDocument, init: Singleton.InitArguments): Singleton;
+    (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
+    CreateOperation: (options?: Singleton.CreateOperationOptions) => PropertyDecorator;
+    GetOperation: (options?: Singleton.GetOperationOptions) => PropertyDecorator;
+    DeleteOperation: (options?: Singleton.DeleteOperationOptions) => PropertyDecorator;
+    UpdateOperation: (options?: Singleton.UpdateOperationOptions) => PropertyDecorator;
+}
+export declare const Singleton: SingletonConstructor;

package/typings/common/exception/resource-errors/resource-not-found.error.d.ts

@@ -1,4 +1,8 @@
 import { OpraException } from '../opra-exception.js';
+/**
+ * The server cannot find the requested resource.
+ * This can also mean that the endpoint is valid but the resource itself does not exist.
+ */
 export declare class ResourceNotFoundError extends OpraException {
     constructor(resource: string, keyValue?: any, cause?: Error);
 }

package/typings/common/helpers/function-utils.d.ts

@@ -0,0 +1,4 @@
+import { Type } from 'ts-gems';
+import { ThunkAsync } from '../types.js';
+export declare function resolveThunk(thunk: ThunkAsync<any>): Promise<any>;
+export declare function resolveClass(thunk: ThunkAsync<Type>): Promise<Type>;

package/typings/common/helpers/get-stack-filename.d.ts

@@ -0,0 +1 @@
+export declare function getStackFileName(position?: number): string;

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

@@ -1 +1,8 @@
+export * from './function-utils.js';
+export * from './get-stack-filename.js';
+export * from './is-url.js';
+export * from './mixin-utils.js';
+export * from './object-utils.js';
+export * from './path-to-object-tree.js';
 export * from './responsive-map.js';
+export * from './type-guards.js';

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

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

package/typings/common/{schema/utils/clone-object.util.d.ts → helpers/object-utils.d.ts}

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

package/typings/common/helpers/path-to-object-tree.d.ts

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

package/typings/common/helpers/responsive-map.d.ts

@@ -2,7 +2,7 @@ export interface ResponsiveMapOptions {
     wellKnownKeys?: string[];
     caseSensitive?: boolean;
 }
-export type ResponsiveMapInit<K, V> = ResponsiveMap<K, V> | Map<K, V> | Record<any, V>;
+export type ResponsiveMapInit<V> = ResponsiveMap<V> | Map<string, V> | Record<any, V>;
 declare const kKeyMap: unique symbol;
 declare const kKeyOrder: unique symbol;
 declare const kWellKnownKeys: unique symbol;
@@ -10,23 +10,25 @@ declare const kOptions: unique symbol;
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */
-export declare class ResponsiveMap<K, V> extends Map<K, V> {
+export declare class ResponsiveMap<V> extends Map<string, V> {
     private [kKeyMap];
     private [kKeyOrder];
     private [kWellKnownKeys];
     private [kOptions];
-    constructor(init?: ResponsiveMapInit<K, V>, options?: ResponsiveMapOptions);
+    constructor(init?: ResponsiveMapInit<V> | null, options?: ResponsiveMapOptions);
     clear(): void;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    keys(): IterableIterator<K>;
+    get(key: string): V | undefined;
+    has(key: string): boolean;
+    set(key: string, value: V): this;
+    setAll(source: ResponsiveMapInit<V>): this;
+    keys(): IterableIterator<string>;
     values(): IterableIterator<V>;
-    entries(): IterableIterator<[K, V]>;
-    delete(key: K): boolean;
-    sort(compareFn?: (a: K, b: K) => number): this;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    protected _getOriginalKey(key: K): K;
-    protected _getStoringKey(key: K): K;
+    entries(): IterableIterator<[string, V]>;
+    delete(key: string): boolean;
+    sort(compareFn?: (a: string, b: string) => number): this;
+    getProxy(handler?: ProxyHandler<Record<string, V>>): Record<string, V>;
+    [Symbol.iterator](): IterableIterator<[string, V]>;
+    protected _getOriginalKey(key: string): string;
+    protected _getStoringKey(key: string): string;
 }
 export {};

package/typings/common/{utils → helpers}/type-guards.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" />
 /// <reference lib="dom" />
 import { Readable } from 'stream';
-export declare function typeGuards(stream: any): boolean;
+import { Type } from 'ts-gems';
+export declare function isConstructor(fn: any): fn is Type;
+export declare function isStream(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;

package/typings/common/http/codecs/boolean-codec.d.ts

@@ -0,0 +1,5 @@
+import type { HttpParams } from '../http-params.js';
+export declare class BooleanCodec implements HttpParams.Codec {
+    decode(value: string): boolean;
+    encode(value: any): string;
+}

package/typings/common/http/{param-codec → codecs}/date-codec.d.ts

@@ -1,11 +1,11 @@
-import { HttpParamCodec } from '../http-param-codec.js';
+import type { HttpParams } from '../http-params.js';
 export interface DateCodecOptions {
     time?: boolean;
     timeZone?: boolean;
     min?: string;
     max?: string;
 }
-export declare class DateCodec extends HttpParamCodec {
+export declare class DateCodec implements HttpParams.Codec {
     time: boolean;
     timeZone: boolean;
     min?: string;

package/typings/common/http/{param-codec → codecs}/filter-codec.d.ts

@@ -1,6 +1,6 @@
 import { Ast, Expression } from '../../filter/ast/index.js';
-import { HttpParamCodec } from '../http-param-codec.js';
-export declare class FilterCodec extends HttpParamCodec {
+import type { HttpParams } from '../http-params.js';
+export declare class FilterCodec implements HttpParams.Codec {
     decode(value: string | Expression): object;
     encode(value: Ast): string;
 }

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

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

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

@@ -0,0 +1,14 @@
+import type { HttpParams } from '../http-params.js';
+export declare namespace NumberCodec {
+    interface Options {
+        max?: number;
+        min?: number;
+    }
+}
+export declare class NumberCodec implements HttpParams.Codec {
+    max?: number;
+    min?: number;
+    constructor(options?: NumberCodec.Options);
+    decode(value: string): number;
+    encode(value: any): string;
+}

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

@@ -0,0 +1,16 @@
+import type { HttpParams } from '../http-params.js';
+export declare namespace StringCodec {
+    interface Options {
+        maxLength?: number;
+        minLength?: number;
+        enum?: string[];
+    }
+}
+export declare class StringCodec implements HttpParams.Codec {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+    constructor(options?: StringCodec.Options);
+    decode(value: string): string;
+    encode(value: any): string;
+}