@opra/common 0.18.4 → 0.20.0

package/types/document/data-type/complex-type.d.ts

@@ -1,10 +1,12 @@
+import 'reflect-metadata';
 import { StrictOmit, Type } from 'ts-gems';
+import * as vg from 'valgen';
 import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { ApiField } from './api-field.js';
 import { DataType } from './data-type.js';
-import type { UnionType } from './union-type';
+import type { UnionType } from './union-type.js';
 /**
  * @namespace ComplexType
  */
@@ -12,10 +14,10 @@ export declare namespace ComplexType {
     interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.ComplexType, 'ctor' | 'abstract' | 'additionalFields'> {
         base?: ComplexType | UnionType;
     }
-    interface OwnProperties extends DataType.OwnProperties, Readonly<Pick<OpraSchema.ComplexType, 'ctor' | 'abstract' | 'additionalFields'>> {
-        readonly fields: ResponsiveMap<ApiField>;
+    interface OwnProperties extends Readonly<StrictOmit<OpraSchema.ComplexType, 'fields'>> {
+        fields: ResponsiveMap<ApiField>;
     }
-    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'base' | 'additionalFields' | 'abstract'> {
+    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'additionalFields' | 'abstract'> {
     }
     interface Metadata extends StrictOmit<OpraSchema.ComplexType, 'fields'> {
         name: string;
@@ -23,34 +25,46 @@ export declare namespace ComplexType {
     }
 }
 /**
- * Type definition of ComplexType prototype
- * @type ComplexType
+ * @class ComplexType
  */
-export interface ComplexType extends StrictOmit<DataType, 'own' | 'exportSchema'>, ComplexType.OwnProperties {
+declare class ComplexTypeClass extends DataType {
+    readonly kind = "ComplexType";
     readonly ctor: Type;
     readonly base?: ComplexType | UnionType;
     readonly own: ComplexType.OwnProperties;
+    readonly fields: ResponsiveMap<ApiField>;
     readonly abstract?: boolean;
-    readonly additionalFields?: boolean;
-    exportSchema(): OpraSchema.ComplexType;
+    readonly additionalFields?: boolean | vg.Validator<any, any> | 'ignore';
+    protected _decoder?: vg.Validator<any, any>;
+    protected _encoder?: vg.Validator<any, any>;
+    constructor(document: ApiDocument, init: ComplexType.InitArguments);
     addField(init: ApiField.InitArguments): ApiField;
-    iteratePath(path: string, silent?: boolean): IterableIterator<[string, ApiField | undefined, string]>;
-    getField(nameOrPath: string): ApiField;
     findField(nameOrPath: string): ApiField | undefined;
-    normalizeFieldPath(fields: string): string;
-    normalizeFieldPath(fields: string[]): string[];
-    normalizeFieldPath(fields: string | string[]): string | string[];
+    getField(nameOrPath: string): ApiField;
+    iteratePath(path: string, silent?: boolean): IterableIterator<[string, ApiField | undefined, string]>;
+    normalizeFieldPath(fieldPath: string): string;
+    normalizeFieldPath(fieldPaths: string[]): string[];
+    exportSchema(): OpraSchema.ComplexType;
+    isTypeOf(t: Type | Function): boolean;
+    extendsFrom(t: string | Type | DataType): boolean;
+    decode(v: object): any;
+    encode(v: any): any;
+    validate(v: any): any;
+    protected _getDecoder(): vg.Validator<any, any>;
+    protected _getEncoder(): vg.Validator<any, any>;
 }
 /**
- * Type definition of ComplexType constructor type
- * @type ComplexTypeConstructor
+ * Callable class pattern for ComplexType
  */
 export interface ComplexTypeConstructor {
     new (document: ApiDocument, init: ComplexType.InitArguments): ComplexType;
     (options?: ComplexType.DecoratorOptions): ClassDecorator;
     prototype: ComplexType;
 }
+export interface ComplexType extends ComplexTypeClass {
+}
 /**
  * @class ComplexType
  */
 export declare const ComplexType: ComplexTypeConstructor;
+export {};

package/types/document/data-type/data-type.d.ts

@@ -1,33 +1,37 @@
-import { Type } from 'ts-gems';
+import { RequiredSome, Type } from 'ts-gems';
+import * as vg from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { nodeInspectCustom } from '../utils/inspect.util.js';
 export declare namespace DataType {
-    interface InitArguments extends Partial<Pick<OpraSchema.DataTypeBase, 'description'>> {
+    interface InitArguments {
         name?: string;
-    }
-    interface OwnProperties {
         description?: string;
     }
-    interface DecoratorOptions extends Pick<InitArguments, 'name' | 'description'> {
+    interface DecoratorOptions extends InitArguments {
+    }
+    interface Metadata extends RequiredSome<DecoratorOptions, 'name'> {
+        kind: OpraSchema.DataType.Kind;
+    }
+    interface OwnProperties {
     }
 }
-export interface DataType extends DataType.OwnProperties {
+export declare abstract class DataType {
     readonly document: ApiDocument;
     readonly kind: OpraSchema.DataType.Kind;
     readonly name?: string;
+    readonly base?: DataType;
     readonly own: DataType.OwnProperties;
+    readonly description?: string;
     readonly isAnonymous: boolean;
-    coerce(value: any): any;
-    validate(v: any): void;
-    extendsFrom(t: string | Type | DataType): boolean;
+    protected constructor(document: ApiDocument, init?: DataType.InitArguments);
+    decode(v: any): any;
+    encode(v: any): any;
+    validate(v: any): any;
+    protected abstract _getDecoder(): vg.Validator<any, any>;
+    protected abstract _getEncoder(): vg.Validator<any, any>;
     exportSchema(): OpraSchema.DataType;
+    extendsFrom(type: string | Type | DataType): any;
     toString(): string;
     [nodeInspectCustom](): string;
 }
-export interface DataTypeConstructor {
-    new (document: ApiDocument, init?: DataType.InitArguments): DataType;
-    (...args: any[]): void;
-    prototype: DataType;
-}
-export declare const DataType: DataTypeConstructor;

package/types/document/data-type/enum-type.d.ts

@@ -1,4 +1,5 @@
-import { StrictOmit } from 'ts-gems';
+import 'reflect-metadata';
+import * as vg from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { DataType } from './data-type.js';
@@ -6,8 +7,6 @@ export declare namespace EnumType {
     interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.EnumType, 'base' | 'values' | 'meanings'> {
         base?: EnumType;
     }
-    interface OwnProperties extends DataType.OwnProperties, Required<Readonly<Pick<OpraSchema.EnumType, 'values' | 'meanings'>>> {
-    }
     interface Options<T, Keys extends (string | number | symbol) = T extends readonly any[] ? T[number] : keyof T> extends DataType.DecoratorOptions {
         name?: string;
         base?: OpraSchema.EnumObject;
@@ -17,16 +16,28 @@ export declare namespace EnumType {
         name: string;
     }
 }
-export interface EnumType extends StrictOmit<DataType, 'own' | 'exportSchema'>, EnumType.OwnProperties {
+declare class EnumTypeClass extends DataType {
+    readonly kind = "EnumType";
     readonly base?: EnumType;
-    readonly own: EnumType.OwnProperties;
+    readonly values: Record<string, string | number>;
+    readonly meanings: Record<string, string>;
+    readonly ownValues: Record<string, string | number>;
+    readonly ownMeanings: Record<string, string>;
+    protected _decoder?: vg.Validator<any, any>;
+    protected _encoder?: vg.Validator<any, any>;
+    constructor(document: ApiDocument, init: EnumType.InitArguments);
     exportSchema(): OpraSchema.EnumType;
+    protected _getDecoder(): vg.Validator<any, any>;
+    protected _getEncoder(): vg.Validator<any, any>;
 }
 export interface EnumTypeConstructor {
     new (document: ApiDocument, init?: EnumType.InitArguments): EnumType;
     <T extends OpraSchema.EnumObject | readonly (string | number)[]>(target: T, options?: EnumType.Options<T>): T;
 }
+export interface EnumType extends EnumTypeClass {
+}
 /**
  * @class EnumType
  */
 export declare const EnumType: EnumTypeConstructor;
+export {};

package/types/document/data-type/mapped-type.d.ts

@@ -1,6 +1,11 @@
+import 'reflect-metadata';
 import { Class, StrictOmit, Type } from 'ts-gems';
+import * as vg from 'valgen';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { Field } from '../../schema/data-type/field.interface.js';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
+import { ApiField } from './api-field.js';
 import { ComplexType } from './complex-type.js';
 import { DataType } from './data-type.js';
 /**
@@ -11,7 +16,6 @@ export declare namespace MappedType {
         type: ComplexType;
     }
     interface OwnProperties extends DataType.OwnProperties, Pick<OpraSchema.MappedType, 'pick' | 'omit'> {
-        type: ComplexType;
     }
     interface Options<T, K = keyof T> {
         pick?: readonly K[];
@@ -21,14 +25,26 @@ export declare namespace MappedType {
         type: Type;
     }
 }
+declare class MappedTypeClass extends DataType {
+    readonly kind = "MappedType";
+    readonly own: MappedType.OwnProperties;
+    readonly type: ComplexType;
+    readonly additionalFields?: boolean | vg.Validator<any, any> | 'ignore';
+    readonly fields: ResponsiveMap<ApiField>;
+    readonly omit?: Field.Name[];
+    readonly pick?: Field.Name[];
+    protected _decoder: vg.Validator<any, any>;
+    protected _encoder: vg.Validator<any, any>;
+    constructor(document: ApiDocument, init: MappedType.InitArguments);
+    exportSchema(): OpraSchema.MappedType;
+    protected _getDecoder(): vg.Validator<any, any>;
+    protected _getEncoder(): vg.Validator<any, any>;
+}
 /**
  * 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;
+export interface MappedType extends MappedTypeClass {
 }
 /**
  * Type definition of MappedType constructor type
@@ -49,5 +65,12 @@ export interface MappedTypeConstructor {
  * @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'>;
+export {};

package/types/document/data-type/simple-type.d.ts

@@ -1,33 +1,48 @@
-import { StrictOmit, Type } from 'ts-gems';
+import 'reflect-metadata';
+import * as vg from 'valgen';
 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'> {
+    interface InitArguments extends DataType.InitArguments {
         base?: SimpleType;
+        decoder?: vg.Validator<any, any>;
+        encoder?: vg.Validator<any, any>;
     }
-    interface OwnProperties extends DataType.OwnProperties, Readonly<Pick<OpraSchema.SimpleType, 'ctor' | 'pattern' | 'codec'>> {
+    interface DecoratorOptions extends DataType.DecoratorOptions {
+        decoder?: vg.Validator<any, any>;
+        encoder?: vg.Validator<any, any>;
     }
-    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'pattern'> {
+    interface Metadata extends DataType.Metadata {
+        decoder?: vg.Validator<any, any>;
+        encoder?: vg.Validator<any, any>;
     }
-    interface Metadata extends OpraSchema.SimpleType {
-        name: string;
+    interface OwnProperties extends DataType.OwnProperties {
     }
 }
-export interface SimpleType extends StrictOmit<DataType, 'own' | 'exportSchema'>, SimpleType.OwnProperties {
-    readonly ctor: Type;
+/**
+ * @class SimpleType
+ */
+declare class SimpleTypeClass extends DataType {
+    readonly kind = "SimpleType";
     readonly base?: SimpleType;
+    protected _decoder: vg.Validator<any, any>;
+    protected _encoder: vg.Validator<any, any>;
     readonly own: SimpleType.OwnProperties;
+    constructor(document: ApiDocument, init: SimpleType.InitArguments);
+    protected _getDecoder(): vg.Validator<any, any>;
+    protected _getEncoder(): vg.Validator<any, any>;
     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;
+    new (document: ApiDocument, init: SimpleType.InitArguments): SimpleType;
+    (options?: SimpleType.DecoratorOptions): (target: any) => any;
     prototype: SimpleType;
 }
+export interface SimpleType extends SimpleTypeClass {
+}
 /**
  * @class SimpleType
  */
 export declare const SimpleType: SimpleTypeConstructor;
+export {};

package/types/document/data-type/union-type.d.ts

@@ -1,6 +1,10 @@
+import 'reflect-metadata';
 import { Class, StrictOmit, Type } from 'ts-gems';
+import * as vg from 'valgen';
+import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
+import { ApiField } from './api-field.js';
 import { ComplexType } from './complex-type.js';
 import { DataType } from './data-type.js';
 import { MappedType } from './mapped-type.js';
@@ -18,13 +22,18 @@ export declare namespace UnionType {
         types: Type[];
     }
 }
-/**
- * Type definition of UnionType prototype
- * @type UnionType
- */
-export interface UnionType extends StrictOmit<DataType, 'own' | 'exportSchema'>, Pick<ComplexType, 'additionalFields' | 'fields'>, UnionType.OwnProperties {
+declare class UnionTypeClass extends DataType {
+    readonly kind = "UnionType";
     readonly own: UnionType.OwnProperties;
+    readonly types: (ComplexType | UnionType | MappedType)[];
+    readonly additionalFields?: boolean;
+    readonly fields: ResponsiveMap<ApiField>;
+    protected _decoder: vg.Validator<any, any>;
+    protected _encoder: vg.Validator<any, any>;
+    constructor(document: ApiDocument, init: UnionType.InitArguments);
     exportSchema(): OpraSchema.UnionType;
+    protected _getDecoder(): vg.Validator<any, any>;
+    protected _getEncoder(): vg.Validator<any, any>;
 }
 /**
  * Type definition of UnionType constructor type
@@ -36,7 +45,14 @@ export interface UnionTypeConstructor {
     <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;
 }
+/**
+ * Type definition of UnionType prototype
+ * @type UnionType
+ */
+export interface UnionType extends UnionTypeClass {
+}
 /**
  * @class UnionType
  */
 export declare const UnionType: UnionTypeConstructor;
+export {};

package/types/document/factory/factory.d.ts

@@ -13,16 +13,17 @@ import { addDataType, createDataTypeInstance, processTypes } from './process-typ
  * @namespace DocumentFactory
  */
 export declare namespace DocumentFactory {
-    type InitArguments = StrictOmit<OpraSchema.ApiDocument, 'references' | 'types' | 'resources'> & {
+    interface InitArguments extends 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 {
+    static designTypeMap: Map<Function | Type<any>, string>;
     protected document: ApiDocument;
     protected typeQueue: ResponsiveMap<OpraSchema.DataType>;
     protected resourceQueue: ResponsiveMap<OpraSchema.Resource>;

package/types/document/resource/collection.d.ts

@@ -37,19 +37,18 @@ export declare namespace Collection {
     export type UpdateManyOperationOptions = StrictOmit<OpraSchema.Collection.UpdateManyOperation, 'handler'>;
     export {};
 }
-export interface Collection extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
+declare class CollectionClass extends Resource {
     readonly type: ComplexType;
+    readonly kind = "Collection";
     readonly operations: Collection.Operations;
     readonly controller?: object;
     readonly primaryKey: string[];
-    exportSchema(): OpraSchema.Collection;
-    parseKeyValue(value: any): any;
-    normalizeFieldPath(fields: string): string;
-    normalizeFieldPath(fields: string[]): string[];
-    normalizeFieldPath(fields: string | string[]): string | string[];
-    normalizeSortFields(fields: string | string[]): string[];
-    normalizeFilter(ast: string | OpraFilter.Expression): OpraFilter.Expression | undefined;
-    _construct(init: Collection.InitArguments): void;
+    constructor(document: ApiDocument, init: Collection.InitArguments);
+    exportSchema(this: Collection): OpraSchema.Collection;
+    parseKeyValue(this: Collection, value: any): any | undefined;
+    normalizeFieldPath(this: Collection, path: string | string[]): string | string[];
+    normalizeSortFields(this: Collection, fields: string | string[]): string | string[];
+    normalizeFilter(filter: string | OpraFilter.Expression): OpraFilter.Expression | undefined;
 }
 export interface CollectionConstructor {
     prototype: Collection;
@@ -63,7 +62,10 @@ export interface CollectionConstructor {
     DeleteMany: (options?: Collection.DeleteManyOperationOptions) => PropertyDecorator;
     UpdateMany: (options?: Collection.UpdateManyOperationOptions) => PropertyDecorator;
 }
+export interface Collection extends CollectionClass {
+}
 /**
  *
  */
 export declare const Collection: CollectionConstructor;
+export {};

package/types/document/resource/resource.d.ts

@@ -10,20 +10,14 @@ export declare namespace Resource {
     interface DecoratorOptions extends Partial<Pick<InitArguments, 'name' | 'description'>> {
     }
 }
-export interface Resource {
+export declare abstract class Resource {
     readonly document: ApiDocument;
-    readonly kind: OpraSchema.Resource.Kind;
+    abstract readonly kind: OpraSchema.Resource.Kind;
     readonly name: string;
     readonly description?: string;
     readonly controller?: object | Type;
+    protected constructor(document: ApiDocument, init: Resource.InitArguments);
     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/types/document/resource/singleton.d.ts

@@ -29,15 +29,14 @@ export declare namespace Singleton {
     export type UpdateOperationOptions = StrictOmit<OpraSchema.Singleton.UpdateOperation, 'handler'>;
     export {};
 }
-export interface Singleton extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
+declare class SingletonClass extends Resource {
     readonly type: ComplexType;
+    readonly kind = "Singleton";
     readonly operations: Singleton.Operations;
     readonly controller?: object | Type;
+    constructor(document: ApiDocument, init: Singleton.InitArguments);
     exportSchema(): OpraSchema.Singleton;
-    normalizeFieldPath(fields: string): string;
-    normalizeFieldPath(fields: string[]): string[];
-    normalizeFieldPath(fields: string | string[]): string | string[];
-    _construct(init: Singleton.InitArguments): void;
+    normalizeFieldPath(this: Singleton, path: string | []): string | string[];
 }
 export interface SingletonConstructor {
     prototype: Singleton;
@@ -48,4 +47,7 @@ export interface SingletonConstructor {
     Get: (options?: Singleton.GetOperationOptions) => PropertyDecorator;
     Update: (options?: Singleton.UpdateOperationOptions) => PropertyDecorator;
 }
+export interface Singleton extends SingletonClass {
+}
 export declare const Singleton: SingletonConstructor;
+export {};

package/types/exception/common-errors/validation.error.d.ts

@@ -0,0 +1,4 @@
+import { OpraException } from '../opra-exception.js';
+export declare class ValidationError extends OpraException {
+    status: number;
+}

package/types/exception/error-issue.d.ts

@@ -1,4 +1,4 @@
-import { IssueSeverity } from './enums/issue-severity.enum.js';
+import { IssueSeverity } from './issue-severity.enum.js';
 export interface ErrorIssue {
     message: string;
     severity: IssueSeverity.Type;

package/types/exception/index.d.ts

@@ -1,7 +1,7 @@
 export * from './opra-exception.js';
 export * from './error-issue.js';
 export * from './wrap-exception.js';
-export * from './enums/issue-severity.enum.js';
+export * from './issue-severity.enum.js';
 export * from './http-errors/bad-request.error.js';
 export * from './http-errors/failed-dependency.error.js';
 export * from './http-errors/forbidden.error.js';
@@ -13,3 +13,4 @@ export * from './http-errors/unauthorized.error.js';
 export * from './http-errors/unprocessable-entity.error.js';
 export * from './resource-errors/resource-conflict.error.js';
 export * from './resource-errors/resource-not-found.error.js';
+export * from './common-errors/validation.error.js';

package/types/exception/opra-exception.d.ts

@@ -6,10 +6,12 @@ export declare class OpraException extends Error {
     protected _issue: ErrorIssue;
     status: number;
     cause?: Error;
-    constructor(issue?: string | Partial<ErrorIssue>, cause?: Error);
+    constructor();
+    constructor(issue: string | Partial<ErrorIssue> | Error);
+    constructor(issue: string | Partial<ErrorIssue>, cause?: Error);
     get issue(): ErrorIssue;
     setIssue(issue: Partial<ErrorIssue>): void;
     setStatus(status: number): this;
     protected _initName(): void;
-    protected _init(issue: Error | Partial<ErrorIssue> | string): void;
+    protected _init(issue: any): void;
 }

package/types/filter/errors.d.ts

@@ -3,6 +3,9 @@ import { Recognizer } from '@browsery/antlr4/typings/Recognizer';
 export declare class SyntaxError extends TypeError {
 }
 export declare class ValidationError extends TypeError {
+    constructor(message?: string | {
+        message?: string;
+    });
 }
 export declare class FilterParseError extends Error {
     recognizer: Recognizer<any>;

package/types/http/index.d.ts

@@ -1,9 +1,8 @@
 export * from './http-headers.js';
 export * from './http-params.js';
-export * from './http-response-message.js';
-export * from './http-request-message.js';
 export * from './enums/http-headers-codes.enum.js';
 export * from './enums/http-status-codes.enum.js';
+export * from './enums/http-status-messages.js';
 export * from './interfaces/client-http-headers.interface.js';
 export * from './interfaces/server-http-headers.interface.js';
 export * from './codecs/date-codec.js';

package/types/schema/data-type/enum-type.interface.d.ts

@@ -1,15 +1,15 @@
 import type { DataType, DataTypeBase } from './data-type.interface.js';
 export interface EnumType extends DataTypeBase {
     base?: DataType.Name | EnumType;
-    values: Record<EnumType.key, EnumType.value>;
-    meanings?: Record<EnumType.key, string>;
+    values: Record<EnumType.Key, EnumType.Value>;
+    meanings?: Record<EnumType.Key, string>;
 }
-export type EnumObject = Record<EnumType.key, EnumType.value>;
+export type EnumObject = Record<EnumType.Key, EnumType.Value>;
 export type EnumArray = readonly (string | number)[];
 export type EnumThunk = EnumObject | EnumArray;
 export declare namespace EnumType {
     const Kind = "EnumType";
     type Kind = typeof Kind;
-    type value = string | number;
-    type key = string;
+    type Value = string | number;
+    type Key = string;
 }

package/types/schema/data-type/simple-type.interface.d.ts

@@ -1,18 +1,12 @@
-import { Type } from 'ts-gems';
-import type { DataType, DataTypeBase } from './data-type.interface.js';
+import * as vg from 'valgen';
+import type { DataTypeBase } from './data-type.interface.js';
+import { DataType } from './data-type.interface.js';
 export interface SimpleType extends DataTypeBase {
-    ctor?: Type;
     base?: DataType.Name | SimpleType;
-    pattern?: string | RegExp;
-    codec?: SimpleType.Codec;
+    decoder?: vg.Validator<any, any>;
+    encoder?: vg.Validator<any, any>;
 }
 export declare namespace SimpleType {
     const Kind = "SimpleType";
     type Kind = 'SimpleType';
-    interface Codec {
-        decode?: (v: any) => any;
-        encode?: (v: any) => any;
-        coerce?: (v: any) => any;
-        validate?: (v: any) => void;
-    }
 }

package/types/schema/index.d.ts

@@ -1,51 +1,2 @@
-import { SpecVersion as _SpecVersion } from './constants.js';
-import { ComplexType as _ComplexType } from './data-type/complex-type.interface.js';
-import { DataType as _DataType, DataTypeBase as _DataTypeBase } from './data-type/data-type.interface.js';
-import { EnumArray as _EnumArray, EnumObject as _EnumObject, EnumThunk as _EnumThunk, EnumType as _EnumType } from './data-type/enum-type.interface.js';
-import { Field as _Field } from './data-type/field.interface.js';
-import { MappedType as _MappedType } from './data-type/mapped-type.interface.js';
-import { SimpleType as _SimpleType } from './data-type/simple-type.interface.js';
-import { UnionType as _UnionType } from './data-type/union-type.interface.js';
-import { ApiDocument as _ApiDocument, ContactPerson as _ContactPerson, DocumentInfo as _DocumentInfo, LicenseInfo as _LicenseInfo, ServerInfo as _ServerInfo } from './document.interface.js';
-import { Collection as _Collection } from './resource/collection.interface.js';
-import { Container as _Container } from './resource/container.interface.js';
-import { Endpoint as _Endpoint } from './resource/endpoint.interface.js';
-import { Resource as _Resource, ResourceBase as _ResourceBase } from './resource/resource.interface.js';
-import { Singleton as _Singleton } from './resource/singleton.interface.js';
-import { isCollection as _isCollection, isComplexType as _isComplexType, isContainer as _isContainer, isDataType as _isDataType, isEnumType as _isEnumType, isMappedType as _isMappedType, isResource as _isResource, isSimpleType as _isSimpleType, isSingleton as _isSingleton, isUnionType as _isUnionType } from './type-guards.js';
-export declare namespace OpraSchema {
-    const SpecVersion = "1.0";
-    type SpecVersion = _SpecVersion;
-    type EnumObject = _EnumObject;
-    type EnumArray = _EnumArray;
-    type EnumThunk = _EnumThunk;
-    type ApiDocument = _ApiDocument;
-    type ContactPerson = _ContactPerson;
-    type ServerInfo = _ServerInfo;
-    type LicenseInfo = _LicenseInfo;
-    type DocumentInfo = _DocumentInfo;
-    type DataTypeBase = _DataTypeBase;
-    type ResourceBase = _ResourceBase;
-    export import DataType = _DataType;
-    export import ComplexType = _ComplexType;
-    export import Field = _Field;
-    export import EnumType = _EnumType;
-    export import MappedType = _MappedType;
-    export import SimpleType = _SimpleType;
-    export import UnionType = _UnionType;
-    export import Resource = _Resource;
-    export import Collection = _Collection;
-    export import Container = _Container;
-    export import Singleton = _Singleton;
-    export import Endpoint = _Endpoint;
-    const isDataType: typeof _isDataType;
-    const isComplexType: typeof _isComplexType;
-    const isEnumType: typeof _isEnumType;
-    const isMappedType: typeof _isMappedType;
-    const isSimpleType: typeof _isSimpleType;
-    const isUnionType: typeof _isUnionType;
-    const isResource: typeof _isResource;
-    const isCollection: typeof _isCollection;
-    const isContainer: typeof _isContainer;
-    const isSingleton: typeof _isSingleton;
-}
+import * as OpraSchema from './opra-schema.ns.js';
+export { OpraSchema };