@opra/common 0.24.2 → 0.25.1

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

@@ -0,0 +1,17 @@
+import * as vg from 'valgen';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { DataType } from './data-type.js';
+import type { EnumType } from './enum-type.js';
+export declare class EnumTypeClass extends DataType {
+    readonly kind = "EnumType";
+    readonly base?: EnumType;
+    readonly values: Record<string, string | number>;
+    readonly meanings: Record<string, string>;
+    readonly ownValues: Record<string, string | number>;
+    readonly ownMeanings: Record<string, string>;
+    readonly decode: vg.Validator<any, any>;
+    readonly encode: vg.Validator<any, any>;
+    constructor(document: ApiDocument, init: EnumType.InitArguments);
+    exportSchema(): OpraSchema.EnumType;
+}

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

@@ -1,8 +1,18 @@
 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';
+import { EnumTypeClass } from './enum-type-class.js';
+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 declare namespace EnumType {
     interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.EnumType, 'base' | 'values' | 'meanings'> {
         base?: EnumType;
@@ -16,26 +26,3 @@ export declare namespace EnumType {
         name: string;
     }
 }
-declare class EnumTypeClass extends DataType {
-    readonly kind = "EnumType";
-    readonly base?: EnumType;
-    readonly values: Record<string, string | number>;
-    readonly meanings: Record<string, string>;
-    readonly ownValues: Record<string, string | number>;
-    readonly ownMeanings: Record<string, string>;
-    readonly decode: vg.Validator<any, any>;
-    readonly encode: vg.Validator<any, any>;
-    constructor(document: ApiDocument, init: EnumType.InitArguments);
-    exportSchema(): OpraSchema.EnumType;
-}
-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/field-class.d.ts

@@ -0,0 +1,20 @@
+import type { OpraSchema } from '../../schema/index.js';
+import type { ComplexType } from './complex-type.js';
+import type { DataType } from './data-type.js';
+import type { ApiField } from './field.js';
+export declare class FieldClass {
+    readonly owner: ComplexType;
+    readonly origin?: ComplexType;
+    readonly type: DataType;
+    readonly name: string;
+    description?: string;
+    isArray?: boolean;
+    default?: any;
+    fixed?: string | number;
+    required?: boolean;
+    exclusive?: boolean;
+    deprecated?: boolean | string;
+    examples?: any[] | Record<string, any>;
+    constructor(owner: ComplexType, init: ApiField.InitArguments);
+    exportSchema(): OpraSchema.Field;
+}

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

@@ -0,0 +1,5 @@
+import type { ApiField } from './field.js';
+export interface FieldDecorator {
+    (options?: ApiField.DecoratorOptions): PropertyDecorator;
+}
+export declare function FieldDecorator(options?: ApiField.DecoratorOptions): PropertyDecorator;

package/types/document/data-type/{api-field.d.ts → field.d.ts}

@@ -3,6 +3,26 @@ import { OpraSchema } from '../../schema/index.js';
 import { TypeThunkAsync } from '../../types.js';
 import type { ComplexType } from './complex-type.js';
 import { DataType } from './data-type.js';
+import { FieldClass } from './field-class.js';
+import { FieldDecorator } from './field-decorator.js';
+/**
+ * Type definition of ComplexType constructor type
+ * @type FieldConstructor
+ */
+export interface FieldConstructor extends FieldDecorator {
+    prototype: FieldClass;
+    new (owner: ComplexType, init: ApiField.InitArguments): FieldClass;
+}
+export interface ApiField extends FieldClass {
+}
+/**
+ * @class ApiField
+ * @decorator ApiField
+ */
+export declare const ApiField: FieldConstructor;
+/**
+ * @namespace ApiField
+ */
 export declare namespace ApiField {
     interface InitArguments extends StrictOmit<OpraSchema.Field, 'type'> {
         name: string;
@@ -19,23 +39,3 @@ export declare namespace ApiField {
         designType?: Type;
     }
 }
-export interface ApiField extends StrictOmit<OpraSchema.Field, 'type'> {
-    readonly owner: ComplexType;
-    readonly origin?: ComplexType;
-    readonly type: DataType;
-    readonly name: string;
-    exportSchema(): OpraSchema.Field;
-}
-/**
- * Type definition of ComplexType constructor type
- * @type ApiFieldConstructor
- */
-export interface ApiFieldConstructor {
-    new (owner: ComplexType, init: ApiField.InitArguments): ApiField;
-    (options?: ApiField.DecoratorOptions): PropertyDecorator;
-    prototype: ApiField;
-}
-/**
- * @class ComplexType
- */
-export declare const ApiField: ApiFieldConstructor;

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

@@ -0,0 +1,21 @@
+import * as vg from 'valgen';
+import { ResponsiveMap } from '../../helpers/index.js';
+import type { Field } from '../../schema/data-type/field.interface.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import type { ComplexType } from './complex-type.js';
+import { DataType } from './data-type.js';
+import type { ApiField } from './field.js';
+import type { MappedType } from './mapped-type.js';
+export declare class MappedTypeClass extends DataType {
+    readonly kind = "MappedType";
+    readonly own: MappedType.OwnProperties;
+    readonly type: ComplexType;
+    readonly additionalFields?: boolean | vg.Validator | 'error';
+    readonly fields: ResponsiveMap<ApiField>;
+    readonly omit?: Field.Name[];
+    readonly pick?: Field.Name[];
+    constructor(document: ApiDocument, init: MappedType.InitArguments);
+    exportSchema(): OpraSchema.MappedType;
+}
+export declare function getIsInheritedPredicateFn(pick?: Field.Name[], omit?: Field.Name[]): (propertyName: string) => boolean;

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

@@ -1,47 +1,18 @@
 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';
+import { MappedTypeClass } from './mapped-type-class.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'> {
-    }
-    interface Options<T, K = keyof T> {
-        pick?: readonly K[];
-        omit?: readonly K[];
-    }
-    interface Metadata extends StrictOmit<OpraSchema.MappedType, 'type'> {
-        type: Type;
-    }
-}
-declare class MappedTypeClass extends DataType {
-    readonly kind = "MappedType";
-    readonly own: MappedType.OwnProperties;
-    readonly type: ComplexType;
-    readonly additionalFields?: boolean | vg.Validator | 'error';
-    readonly fields: ResponsiveMap<ApiField>;
-    readonly omit?: Field.Name[];
-    readonly pick?: Field.Name[];
-    constructor(document: ApiDocument, init: MappedType.InitArguments);
-    exportSchema(): OpraSchema.MappedType;
-}
+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'>;
 /**
- * Type definition of MappedType prototype
- * @type MappedType
+ *
  */
-export interface MappedType extends MappedTypeClass {
-}
+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'>;
 /**
  * Type definition of MappedType constructor type
  * @type MappedTypeConstructor
@@ -62,11 +33,25 @@ export interface MappedTypeConstructor {
  */
 export declare const MappedType: MappedTypeConstructor;
 /**
- *
+ * Type definition of MappedType prototype
+ * @type MappedType
  */
-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 interface MappedType extends MappedTypeClass {
+}
 /**
- *
+ * @namespace MappedType
  */
-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 {};
+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'> {
+    }
+    interface Options<T, K = keyof T> {
+        pick?: readonly K[];
+        omit?: readonly K[];
+    }
+    interface Metadata extends StrictOmit<OpraSchema.MappedType, 'type'> {
+        type: Type;
+    }
+}

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

@@ -0,0 +1,17 @@
+import * as vg from 'valgen';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { DataType } from './data-type.js';
+import type { SimpleType } from './simple-type.js';
+/**
+ * @class SimpleType
+ */
+export declare class SimpleTypeClass extends DataType {
+    readonly kind = "SimpleType";
+    readonly base?: SimpleType;
+    readonly own: SimpleType.OwnProperties;
+    readonly decode: vg.Validator<any, any>;
+    readonly encode: vg.Validator<any, any>;
+    constructor(document: ApiDocument, init: SimpleType.InitArguments);
+    exportSchema(): OpraSchema.SimpleType;
+}

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

@@ -1,37 +1,8 @@
 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 {
-        base?: SimpleType;
-        decoder?: vg.Validator<any, any>;
-        encoder?: vg.Validator<any, any>;
-    }
-    interface DecoratorOptions extends DataType.DecoratorOptions {
-        decoder?: vg.Validator<any, any>;
-        encoder?: vg.Validator<any, any>;
-    }
-    interface Metadata extends DataType.Metadata {
-        decoder?: vg.Validator<any, any>;
-        encoder?: vg.Validator<any, any>;
-    }
-    interface OwnProperties extends DataType.OwnProperties {
-    }
-}
-/**
- * @class SimpleType
- */
-declare class SimpleTypeClass extends DataType {
-    readonly kind = "SimpleType";
-    readonly base?: SimpleType;
-    readonly own: SimpleType.OwnProperties;
-    readonly decode: vg.Validator<any, any>;
-    readonly encode: vg.Validator<any, any>;
-    constructor(document: ApiDocument, init: SimpleType.InitArguments);
-    exportSchema(): OpraSchema.SimpleType;
-}
+import { SimpleTypeClass } from './simple-type-class.js';
 export interface SimpleTypeConstructor {
     new (document: ApiDocument, init: SimpleType.InitArguments): SimpleType;
     (options?: SimpleType.DecoratorOptions): (target: any) => any;
@@ -43,4 +14,23 @@ export interface SimpleType extends SimpleTypeClass {
  * @class SimpleType
  */
 export declare const SimpleType: SimpleTypeConstructor;
-export {};
+/**
+ * @namespace SimpleType
+ */
+export declare namespace SimpleType {
+    interface InitArguments extends DataType.InitArguments {
+        base?: SimpleType;
+        decoder?: vg.Validator;
+        encoder?: vg.Validator;
+    }
+    interface DecoratorOptions extends DataType.DecoratorOptions {
+        decoder?: vg.Validator;
+        encoder?: vg.Validator;
+    }
+    interface Metadata extends DataType.Metadata {
+        decoder?: vg.Validator;
+        encoder?: vg.Validator;
+    }
+    interface OwnProperties extends DataType.OwnProperties {
+    }
+}

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

@@ -0,0 +1,18 @@
+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 { ComplexType } from './complex-type.js';
+import { DataType } from './data-type.js';
+import type { ApiField } from './field.js';
+import { MappedType } from './mapped-type.js';
+import type { UnionType } from './union-type.js';
+export declare class UnionTypeClass extends DataType {
+    readonly kind = "UnionType";
+    readonly own: UnionType.OwnProperties;
+    readonly types: (ComplexType | UnionType | MappedType)[];
+    readonly additionalFields?: boolean | vg.Validator | 'error';
+    readonly fields: ResponsiveMap<ApiField>;
+    constructor(document: ApiDocument, init: UnionType.InitArguments);
+    exportSchema(): OpraSchema.UnionType;
+}

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

@@ -1,36 +1,11 @@
 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';
-/**
- * @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[];
-    }
-}
-declare class UnionTypeClass extends DataType {
-    readonly kind = "UnionType";
-    readonly own: UnionType.OwnProperties;
-    readonly types: (ComplexType | UnionType | MappedType)[];
-    readonly additionalFields?: boolean | vg.Validator | 'error';
-    readonly fields: ResponsiveMap<ApiField>;
-    constructor(document: ApiDocument, init: UnionType.InitArguments);
-    exportSchema(): OpraSchema.UnionType;
-}
+import { UnionTypeClass } from './union-type-class.js';
 /**
  * Type definition of UnionType constructor type
  * @type UnionTypeConstructor
@@ -51,4 +26,17 @@ export interface UnionType extends UnionTypeClass {
  * @class UnionType
  */
 export declare const UnionType: UnionTypeConstructor;
-export {};
+/**
+ * @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[];
+    }
+}

package/types/document/{resource → decorators}/collection-decorator.d.ts

@@ -1,21 +1,10 @@
 import { StrictOmit, Type } from 'ts-gems';
-import type { Collection } from './collection.js';
-import { Resource } from './resource.js';
-import { ResourceDecorator } from './resource-decorator.js';
+import type { Collection } from '../resource/collection';
+import { Resource } from '../resource/resource.js';
+import { ResourceDecorator } from './resource.decorator.js';
 type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
 declare const operationProperties: readonly ["create", "delete", "deleteMany", "get", "findMany", "update", "updateMany"];
 type OperationProperties = typeof operationProperties[number];
-export interface CollectionDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    <T>(type: Type<T> | string, options?: Collection.DecoratorOptions<T>): ClassDecorator;
-    Action: (options?: Resource.ActionOptions) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void);
-    Create: (options?: Collection.CreateEndpointOptions) => ((target: Object, propertyKey: 'create') => void);
-    Delete: (options?: Collection.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
-    DeleteMany: (options?: Collection.DeleteManyEndpointOptions) => ((target: Object, propertyKey: 'deleteMany') => void);
-    Get: (options?: Collection.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
-    FindMany: (options?: Collection.FindManyEndpointOptions) => ((target: Object, propertyKey: 'findMany') => void);
-    Update: (options?: Collection.UpdateEndpointOptions) => ((target: Object, propertyKey: 'update') => void);
-    UpdateMany: (options?: Collection.UpdateManyEndpointOptions) => ((target: Object, propertyKey: 'updateMany') => void);
-}
 export declare function CollectionDecorator(type: Type | string, options?: Collection.DecoratorOptions): ClassDecorator;
 export declare namespace CollectionDecorator {
     var Create: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
@@ -27,4 +16,15 @@ export declare namespace CollectionDecorator {
     var UpdateMany: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
     var Action: (options: any) => PropertyDecorator;
 }
+export interface CollectionDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
+    <T>(type: Type<T> | string, options?: Collection.DecoratorOptions<T>): ClassDecorator;
+    Action: (options?: Resource.ActionOptions) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void);
+    Create: (options?: Collection.CreateEndpointOptions) => ((target: Object, propertyKey: 'create') => void);
+    Delete: (options?: Collection.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
+    DeleteMany: (options?: Collection.DeleteManyEndpointOptions) => ((target: Object, propertyKey: 'deleteMany') => void);
+    Get: (options?: Collection.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
+    FindMany: (options?: Collection.FindManyEndpointOptions) => ((target: Object, propertyKey: 'findMany') => void);
+    Update: (options?: Collection.UpdateEndpointOptions) => ((target: Object, propertyKey: 'update') => void);
+    UpdateMany: (options?: Collection.UpdateManyEndpointOptions) => ((target: Object, propertyKey: 'updateMany') => void);
+}
 export {};

package/types/document/decorators/complex-type.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { ComplexType } from '../data-type/complex-type.js';
+export declare function ComplexTypeDecorator(options?: ComplexType.DecoratorOptions): (target: Function) => void;

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

@@ -0,0 +1,9 @@
+import { OpraSchema } from '../../schema/index.js';
+import type { Resource } from '../resource/resource';
+export interface ResourceDecorator {
+    Action: (options?: Resource.ActionOptions) => PropertyDecorator;
+}
+export declare function ResourceDecorator<O extends Resource.DecoratorOptions>(kind: OpraSchema.Resource.Kind, options?: O): ClassDecorator;
+export declare namespace ResourceDecorator {
+    var Action: (options: any) => PropertyDecorator;
+}

package/types/document/decorators/simple-type.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { SimpleType } from '../data-type/simple-type';
+export declare function SimpleTypeDecorator(options?: SimpleType.DecoratorOptions): (target: Function) => void;

package/types/document/{resource/singleton-decorator.d.ts → decorators/singleton.decorator.d.ts}

@@ -1,19 +1,11 @@
 import { StrictOmit } from 'ts-gems';
 import { TypeThunkAsync } from '../../types.js';
-import { Resource } from './resource.js';
-import { ResourceDecorator } from './resource-decorator.js';
-import type { Singleton } from './singleton.js';
+import { Resource } from '../resource/resource.js';
+import type { Singleton } from '../resource/singleton.js';
+import { ResourceDecorator } from './resource.decorator.js';
 type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
 declare const operationProperties: readonly ["create", "delete", "get", "update"];
 type OperationProperties = typeof operationProperties[number];
-export interface SingletonDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-    Action: (options?: Resource.ActionOptions) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void);
-    Create: (options?: Singleton.CreateEndpointOptions) => ((target: Object, propertyKey: 'create') => void);
-    Delete: (options?: Singleton.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
-    Get: (options?: Singleton.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
-    Update: (options?: Singleton.UpdateEndpointOptions) => ((target: Object, propertyKey: 'update') => void);
-}
 export declare function SingletonDecorator(type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
 export declare namespace SingletonDecorator {
     var Create: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
@@ -22,4 +14,12 @@ export declare namespace SingletonDecorator {
     var Update: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
     var Action: (options: any) => PropertyDecorator;
 }
+export interface SingletonDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
+    (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
+    Action: (options?: Resource.ActionOptions) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void);
+    Create: (options?: Singleton.CreateEndpointOptions) => ((target: Object, propertyKey: 'create') => void);
+    Delete: (options?: Singleton.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
+    Get: (options?: Singleton.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
+    Update: (options?: Singleton.UpdateEndpointOptions) => ((target: Object, propertyKey: 'update') => void);
+}
 export {};

package/types/document/{resource/storage-decorator.d.ts → decorators/storage.decorator.d.ts}

@@ -1,17 +1,10 @@
 import { StrictOmit } from 'ts-gems';
-import { Resource } from './resource.js';
-import { ResourceDecorator } from './resource-decorator.js';
-import type { Storage } from './storage.js';
+import { Resource } from '../resource/resource.js';
+import type { Storage } from '../resource/storage.js';
+import { ResourceDecorator } from './resource.decorator.js';
 type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
 declare const operationProperties: readonly ["delete", "get", "post"];
 type OperationProperties = typeof operationProperties[number];
-export interface StorageDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    (options?: Storage.DecoratorOptions): ClassDecorator;
-    Action: (options?: Resource.ActionOptions) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void);
-    Delete: (options?: Storage.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
-    Get: (options?: Storage.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
-    Post: (options?: Storage.PostEndpointOptions) => ((target: Object, propertyKey: 'post') => void);
-}
 export declare function StorageDecorator(options?: Storage.DecoratorOptions): ClassDecorator;
 export declare namespace StorageDecorator {
     var Delete: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
@@ -19,4 +12,11 @@ export declare namespace StorageDecorator {
     var Post: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
     var Action: (options: any) => PropertyDecorator;
 }
+export interface StorageDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
+    (options?: Storage.DecoratorOptions): ClassDecorator;
+    Action: (options?: Resource.ActionOptions) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void);
+    Delete: (options?: Storage.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
+    Get: (options?: Storage.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
+    Post: (options?: Storage.PostEndpointOptions) => ((target: Object, propertyKey: 'post') => void);
+}
 export {};

package/types/document/factory/import-type-class.d.ts

@@ -1,9 +1,9 @@
 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 { ApiField } from '../data-type/field.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';

package/types/document/index.d.ts

@@ -4,7 +4,7 @@ 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/field.js';
 export * from './data-type/enum-type.js';
 export * from './data-type/mapped-type.js';
 export * from './data-type/simple-type.js';

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

@@ -3,9 +3,23 @@ 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 { CollectionDecorator } from '../decorators/collection-decorator.js';
 import { CollectionClass } from './collection-class.js';
-import { CollectionDecorator } from './collection-decorator.js';
-import { Resource } from './resource.js';
+import type { Resource } from './resource.js';
+export interface CollectionConstructor extends CollectionDecorator {
+    prototype: CollectionClass;
+    new (document: ApiDocument, init: Collection.InitArguments): CollectionClass;
+}
+export interface Collection extends CollectionClass {
+}
+/**
+ * @class Collection
+ * @decorator Collection
+ */
+export declare const Collection: CollectionConstructor;
+/**
+ * @namespace Collection
+ */
 export declare namespace Collection {
     interface InitArguments extends Resource.InitArguments, StrictOmit<OpraSchema.Collection, 'kind' | 'type'> {
         type: ComplexType;
@@ -38,13 +52,3 @@ export declare namespace Collection {
     type UpdateEndpointOptions = OpraSchema.Collection.UpdateEndpoint;
     type UpdateManyEndpointOptions = OpraSchema.Collection.UpdateManyEndpoint;
 }
-export interface CollectionConstructor extends CollectionDecorator {
-    prototype: Collection;
-    new (document: ApiDocument, init: Collection.InitArguments): Collection;
-}
-export interface Collection extends CollectionClass {
-}
-/**
- *
- */
-export declare const Collection: CollectionConstructor;

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

@@ -0,0 +1,29 @@
+import { StrictOmit } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataType } from '../data-type/data-type.js';
+export declare class Endpoint {
+    readonly name: string;
+    description?: string;
+    parameters: ResponsiveMap<Endpoint.Parameter>;
+    constructor(init: Endpoint.InitArguments);
+    exportSchema(): OpraSchema.Endpoint;
+}
+export declare namespace Endpoint {
+    interface InitArguments extends OpraSchema.Endpoint {
+        name: string;
+    }
+    class Parameter implements StrictOmit<OpraSchema.Endpoint.Parameter, 'type'> {
+        readonly name: string;
+        readonly type: string | DataType;
+        description?: string;
+        isArray?: boolean;
+        default?: any;
+        required?: boolean;
+        deprecated?: boolean | string;
+        constructor(init: OpraSchema.Endpoint.Parameter);
+        exportSchema(): OpraSchema.Endpoint.Parameter;
+    }
+    namespace Parameter {
+    }
+}