@opra/common 0.33.13 → 1.0.0-alpha.10

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

@@ -0,0 +1,9 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class DateType {
+    constructor(attributes?: Partial<DateType>);
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+    minValue?: string;
+    maxValue?: string;
+}

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

@@ -0,0 +1,16 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class EmailType {
+    constructor(attributes?: Partial<EmailType>);
+    allowDisplayName?: boolean;
+    requireDisplayName?: boolean;
+    utf8LocalPart?: boolean;
+    ignoreMaxLength?: boolean;
+    allowIpDomain?: boolean;
+    domainSpecificValidation?: boolean;
+    hostBlacklist?: string[];
+    hostWhitelist?: string[];
+    blacklistedChars?: string;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

package/types/document/data-type/extended-types/field-path.type.d.ts

@@ -0,0 +1,15 @@
+import { Type } from 'ts-gems';
+import { Validator } from 'valgen';
+import { DocumentElement } from '../../common/document-element.js';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class FieldPathType {
+    constructor(attributes?: Partial<FieldPathType>);
+    dataType?: Type | string;
+    allowSigns?: 'first' | 'each';
+    [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
+    [ENCODER](properties: Partial<this>, element: DocumentElement): Validator;
+    toJSON(properties: Partial<FieldPathType>, element: DocumentElement): {
+        dataType: string | import("../../../schema/data-type/complex-type.interface.js").ComplexType;
+        allowSigns: "first" | "each" | undefined;
+    };
+}

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

@@ -0,0 +1,16 @@
+import { Type } from 'ts-gems';
+import { Validator } from 'valgen';
+import { FilterRules } from '../../../filter/filter-rules.js';
+import type { DocumentElement } from '../../common/document-element.js';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class FilterType {
+    constructor(attributes?: Partial<FilterType>);
+    dataType?: Type | string;
+    rules?: Record<string, FilterRules.Rule>;
+    protected [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
+    protected [ENCODER](): Validator;
+    toJSON(properties: Partial<FilterType>, element: DocumentElement): {
+        dataType: string | import("../../../schema/data-type/complex-type.interface.js").ComplexType;
+        rules: Record<string, FilterRules.Rule> | undefined;
+    };
+}

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

@@ -0,0 +1,13 @@
+export * from './base64.type.js';
+export * from './date.type.js';
+export * from './date-string.type.js';
+export * from './date-time.type.js';
+export * from './date-time-string.type.js';
+export * from './email.type.js';
+export * from './field-path.type.js';
+export * from './filter.type.js';
+export * from './object-id.type.js';
+export * from './operation-result.type.js';
+export * from './time.type.js';
+export * from './url.type.js';
+export * from './uuid.type.js';

package/types/document/data-type/extended-types/object-id.type.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class ObjectIdType {
+    constructor(attributes?: Partial<ObjectIdType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

package/types/document/{resource/types → data-type/extended-types}/operation-result.type.d.ts

@@ -1,14 +1,15 @@
-import { DeepPartial } from 'ts-gems';
+import { DeepPartial, Type } from 'ts-gems';
 import { ErrorIssue } from '../../../exception/index.js';
 export declare class OperationResult<TPayload = any> {
     constructor(init?: DeepPartial<OperationResult>);
-    context?: string;
-    contextUrl?: string;
-    type?: string;
-    typeUrl?: string;
     affected?: number;
-    count?: number;
     totalMatches?: number;
+    context?: string;
+    type?: string;
+    message?: string;
     payload?: TPayload;
     errors?: ErrorIssue[];
 }
+export declare namespace OperationResult {
+    function forPayload(type: Type): Type<OperationResult>;
+}

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

@@ -0,0 +1,9 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class TimeType {
+    constructor(attributes?: Partial<TimeType>);
+    minValue?: string;
+    maxValue?: string;
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

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

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class UrlType {
+    constructor(attributes?: Partial<UrlType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

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

@@ -0,0 +1,8 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class UuidType {
+    constructor(attributes?: Partial<UuidType>);
+    version?: 1 | 2 | 3 | 4 | 5;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

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

@@ -1,62 +1,73 @@
 import 'reflect-metadata';
-import { Class, StrictOmit, Type } from 'ts-gems';
+import { Combine, Type } from 'ts-gems';
+import type { Field } from '../../schema/data-type/field.interface';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from './complex-type.js';
-import { MappedTypeClass } from './mapped-type-class.js';
+import { DocumentElement } from '../common/document-element.js';
+import type { ComplexType } from './complex-type.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+import { DataType } from './data-type.js';
+import type { MixinType } from './mixin-type';
 /**
- *
- */
-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'>;
-/**
- *
+ * @namespace MappedType
  */
-export declare function PartialType<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 declare namespace MappedType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.MappedType.Kind;
+        base: Type | string;
+    }, DataType.Metadata, Pick<ComplexType.Metadata, 'additionalFields'>, OpraSchema.MappedType> {
+    }
+    interface Options<T, K = keyof T> {
+        pick?: readonly K[];
+        omit?: readonly K[];
+        partial?: readonly K[] | boolean;
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.MappedType.Kind;
+        base: ComplexType | MappedType | MixinType;
+        ctor?: Type;
+    }, DataType.InitArguments, MappedType.Metadata> {
+    }
+}
 /**
- * Type definition of MappedType constructor type
- * @type MappedTypeConstructor
+ * Type definition of class constructor for MappedType
  */
-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, PartialKey extends keyof I1>(resource: Class<T, I1, S1>, options: {
-        pickKeys?: readonly PickKey[];
-        omitKeys?: readonly OmitKey[];
-        partialKeys?: readonly PartialKey[];
-    }): Class<T, Omit<Pick<I1, PickKey>, OmitKey>>;
+export interface MappedTypeStatic {
+    /**
+     * Class constructor of MappedType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args: MappedType.InitArguments): MappedType;
     _applyMixin(targetType: Type, sourceType: Type, options: MappedType.Options<any> & {
         isInheritedPredicate: (fieldName: string) => boolean;
     }): void;
+    prototype: MappedType;
 }
-/**
- * @class MappedType
- */
-export declare const MappedType: MappedTypeConstructor;
 /**
  * Type definition of MappedType prototype
- * @type MappedType
+ * @interface MappedType
  */
 export interface MappedType extends MappedTypeClass {
 }
 /**
- * @namespace MappedType
+ * MappedType constructor
  */
-export declare namespace MappedType {
-    interface InitArguments extends ComplexType.InitArguments, Pick<OpraSchema.MappedType, 'pick' | 'omit' | 'partial'> {
-    }
-    interface Metadata extends StrictOmit<ComplexType.Metadata, 'kind' | 'base' | 'name'>, Pick<OpraSchema.MappedType, 'pick' | 'omit' | 'partial'> {
-        kind: OpraSchema.MappedType.Kind;
-        base: Type;
-    }
-    interface OwnProperties extends ComplexType.OwnProperties, Pick<OpraSchema.MappedType, 'pick' | 'omit' | 'partial'> {
-    }
-    interface Options<T, K = keyof T> {
-        pick?: readonly K[];
-        omit?: readonly K[];
-        partial?: readonly K[] | boolean;
-    }
+export declare const MappedType: MappedTypeStatic;
+/**
+ *
+ * @class MappedType
+ */
+declare class MappedTypeClass extends ComplexTypeBase {
+    readonly kind: OpraSchema.MappedType.Kind;
+    readonly base: ComplexType | MappedType | MixinType;
+    readonly ctor?: Type;
+    readonly omit?: Field.Name[];
+    readonly pick?: Field.Name[];
+    readonly partial?: Field.Name[] | boolean;
+    readonly required?: Field.Name[] | boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
+    toJSON(): OpraSchema.MappedType;
 }
+export {};

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

@@ -1,43 +1,82 @@
 import 'reflect-metadata';
-import { Class, StrictOmit, Type } from 'ts-gems';
+import { Class, Combine, Type } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from './complex-type.js';
-import { MappedType } from './mapped-type.js';
-import { MixinTypeClass } from './mixin-type-class.js';
+import type { DocumentElement } from '../common/document-element.js';
+import type { ComplexType } from './complex-type.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+import { DataType } from './data-type.js';
+import type { MappedType } from './mapped-type.js';
 /**
- * Type definition of MixinType constructor type
- * @type MixinTypeConstructor
+ * @namespace MixinType
  */
-export interface MixinTypeConstructor {
+export declare namespace MixinType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.MixinType.Kind;
+        name?: string;
+        types: Type[];
+    }, DataType.Metadata, Pick<ComplexType.Metadata, 'additionalFields'>, OpraSchema.MixinType> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.MixinType.Kind;
+        types: (ComplexType | MappedType | MixinType)[];
+        ctor?: Type;
+    }, DataType.InitArguments, MixinType.Metadata> {
+    }
+}
+/**
+ * Type definition for MixinType
+ * @class MixinType
+ */
+export interface MixinTypeStatic {
+    /**
+     * Class constructor of MixinType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args: MixinType.InitArguments): MixinType;
+    /**
+     * Create a new mixin type from given two types
+     * @param c1
+     * @param c2
+     * @param options
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, options?: DataType.Options): Class<any[], I1 & I2, S1 & S2>;
+    /**
+     * Helper method that mixes given types
+     * @param c1
+     * @param c2
+     * @param c3
+     * @param options
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, options?: DataType.Options): Class<any[], I1 & I2 & I3, S1 & S2 & S3>;
+    /**
+     * Helper method that mixes given types
+     * @param c1
+     * @param c2
+     * @param c3
+     * @param c4
+     * @param options
+     */ <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>, options?: DataType.Options): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;
     prototype: MixinType;
-    new (document: ApiDocument, init: MixinType.InitArguments): MixinType;
-    <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;
-    _applyMixin(target: Type, ...sources: [Type]): void;
 }
 /**
  * Type definition of MixinType prototype
- * @type MixinType
+ * @interface
  */
 export interface MixinType extends MixinTypeClass {
 }
 /**
  * @class MixinType
  */
-export declare const MixinType: MixinTypeConstructor;
+export declare const MixinType: MixinTypeStatic;
 /**
- * @namespace MixinType
+ *
+ * @class MixinType
  */
-export declare namespace MixinType {
-    interface InitArguments extends ComplexType.InitArguments {
-        types: (ComplexType | MixinType | MappedType)[];
-    }
-    interface Metadata extends StrictOmit<ComplexType.Metadata, 'kind' | 'base' | 'name'> {
-        kind: OpraSchema.MixinType.Kind;
-        base?: Type;
-        types: Type[];
-    }
-    interface OwnProperties extends ComplexType.OwnProperties {
-        types: (ComplexType | MixinType | MappedType)[];
-    }
+declare class MixinTypeClass extends ComplexTypeBase {
+    readonly kind: OpraSchema.MixinType.Kind;
+    readonly types: (ComplexType | MixinType | MappedType)[];
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
+    toJSON(): OpraSchema.MixinType;
 }
+export {};

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

@@ -0,0 +1,15 @@
+import { Class, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that omits given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function OmitType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that omits given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */ export declare function OmitType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys: readonly K[], options?: DataType.Options): Class<Args, Omit<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

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

@@ -0,0 +1,28 @@
+import { Class, PartialSome, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that marks given or all fields as optional
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PartialType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that marks given or all fields as optional
+ * @param baseType
+ * @param options
+ */
+export declare function PartialType(baseType: string | Type, options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that marks given fields as optional
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PartialType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys: readonly K[], options?: DataType.Options): Class<Args, PartialSome<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;
+/**
+ * Create a new MappedType that marks all fields as optional
+ * @param baseType
+ * @param options
+ */
+export declare function PartialType<Args extends any[], Instance, Static>(baseType: Class<Args, Instance, Static>, options?: DataType.Options): Class<Args, Partial<Instance>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

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

@@ -0,0 +1,16 @@
+import { Class, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that picks given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PickType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that picks given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PickType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys: readonly K[], options?: DataType.Options): Class<Args, Pick<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

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

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class AnyType {
+    constructor(properties?: Partial<AnyType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

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

@@ -0,0 +1,8 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { NumberType } from './number.type.js';
+export declare class BigintType extends NumberType {
+    constructor(attributes?: Partial<BigintType>);
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

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

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class BooleanType {
+    constructor(properties?: Partial<BooleanType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

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

@@ -0,0 +1,8 @@
+export * from './any.type.js';
+export * from './bigint.type.js';
+export * from './boolean.type.js';
+export * from './integer.type.js';
+export * from './null.type.js';
+export * from './number.type.js';
+export * from './object.type.js';
+export * from './string.type.js';

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

@@ -0,0 +1,8 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { NumberType } from './number.type.js';
+export declare class IntegerType extends NumberType {
+    constructor(properties?: Partial<IntegerType>);
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

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

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class NullType {
+    constructor(properties?: Partial<NullType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

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

@@ -0,0 +1,9 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class NumberType {
+    constructor(properties?: Partial<NumberType>);
+    minValue?: number;
+    maxValue?: number;
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

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

@@ -0,0 +1,3 @@
+export declare class ObjectType {
+    constructor(properties?: Partial<ObjectType>);
+}

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

@@ -0,0 +1,11 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class StringType {
+    constructor(properties?: Partial<StringType>);
+    pattern?: string | RegExp;
+    patternName?: string;
+    minLength?: number;
+    maxLength?: number;
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

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

@@ -0,0 +1,22 @@
+import { Class, RequiredSome, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that marks given or all fields as required
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function RequiredType(baseType: string | Type, keys?: string[] | true, options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that marks given fields as baseType
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function RequiredType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys?: readonly K[], options?: DataType.Options): Class<Args, RequiredSome<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;
+/**
+ * Create a new MappedType that marks all fields as baseType
+ * @param baseType
+ * @param options
+ */
+export declare function RequiredType<Args extends any[], Instance, Static>(baseType: Class<Args, Instance, Static>, options?: DataType.Options): Class<Args, Required<Instance>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

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

@@ -1,36 +1,77 @@
 import 'reflect-metadata';
+import { Combine, Type } from 'ts-gems';
 import { Validator } from 'valgen';
-import type { ApiDocument } from '../api-document.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { DocumentElement } from '../common/document-element';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { AttributeDecoratorFactory, SimpleTypeDecoratorFactory } from '../decorators/simple-type.decorator.js';
 import { DataType } from './data-type.js';
-import { SimpleTypeClass } from './simple-type-class.js';
-export interface SimpleTypeConstructor {
-    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;
 /**
  * @namespace SimpleType
  */
 export declare namespace SimpleType {
-    interface InitArguments extends DataType.InitArguments {
-        base?: SimpleType;
-        decoder?: Validator;
-        encoder?: Validator;
+    interface Metadata extends Combine<{
+        kind: OpraSchema.SimpleType.Kind;
+    }, DataType.Metadata, OpraSchema.SimpleType> {
     }
-    interface DecoratorOptions extends DataType.DecoratorOptions {
-        decoder?: Validator;
-        encoder?: Validator;
+    interface Options extends Combine<Pick<OpraSchema.SimpleType, 'nameMappings'>, DataType.Options> {
     }
-    interface Metadata extends DataType.Metadata {
-        decoder?: Validator;
-        encoder?: Validator;
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.SimpleType.Kind;
+        base?: SimpleType;
+        ctor?: Type;
+        properties?: object;
+        generateDecoder?: SimpleType.ValidatorGenerator;
+        generateEncoder?: SimpleType.ValidatorGenerator;
+    }, DataType.InitArguments, SimpleType.Metadata> {
     }
-    interface OwnProperties extends DataType.OwnProperties {
+    interface Attribute extends OpraSchema.Attribute {
     }
+    type ValidatorGenerator = (properties: Record<string, any>, element: DocumentElement) => Validator;
+}
+/**
+ * Type definition for MixinType
+ * @class SimpleType
+ */
+export interface SimpleTypeStatic extends SimpleTypeDecoratorFactory {
+    /**
+     * Class constructor of SimpleType
+     *
+     * @param owner
+     * @param initArgs
+     * @param context
+     * @constructor
+     */
+    new (owner: DocumentElement, initArgs: SimpleType.InitArguments, context?: DocumentInitContext): SimpleType;
+    prototype: SimpleType;
+    Attribute: AttributeDecoratorFactory;
+}
+/**
+ * Type definition of SimpleType prototype
+ * @interface SimpleType
+ */
+export interface SimpleType extends SimpleTypeClass {
+}
+/**
+ * SimpleType constructor
+ */
+export declare const SimpleType: SimpleTypeStatic;
+/**
+ *
+ * @class SimpleType
+ */
+declare abstract class SimpleTypeClass extends DataType {
+    readonly kind: OpraSchema.SimpleType.Kind;
+    readonly base?: SimpleType;
+    readonly attributes: Record<string, SimpleType.Attribute>;
+    readonly nameMappings: Record<string, string>;
+    readonly ownAttributes: Record<string, SimpleType.Attribute>;
+    readonly ownNameMappings: Record<string, string>;
+    protected _generateDecoder?: SimpleType.ValidatorGenerator;
+    protected _generateEncoder?: SimpleType.ValidatorGenerator;
+    properties?: any;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
+    generateCodec<T extends Record<string, any> | object = object>(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions | null, properties?: Partial<T>): Validator;
+    toJSON(): OpraSchema.SimpleType;
 }
+export {};

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

@@ -0,0 +1,3 @@
+import { Type } from 'ts-gems';
+import type { DataType } from '../data-type';
+export declare function createMappedClass(source: string | Type, config: any, options?: DataType.Options): any;

package/types/document/data-type/utils/get-is-inherited-predicate-fn.d.ts

@@ -0,0 +1 @@
+export declare function getIsInheritedPredicateFn(pick?: string[], omit?: string[]): (propertyName: string) => boolean;