@opra/common 0.33.13 → 1.0.0-alpha.1

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

@@ -0,0 +1,65 @@
+import { Combine, TypeThunkAsync } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { ApiFieldDecorator } from '../decorators/api-field-decorator.js';
+import type { ComplexType } from './complex-type.js';
+import type { DataType } from './data-type.js';
+import type { EnumType } from './enum-type.js';
+import type { MappedType } from './mapped-type.js';
+import type { MixinType } from './mixin-type.js';
+/**
+ * @namespace ApiField
+ */
+export declare namespace ApiField {
+    interface Metadata extends Combine<{
+        type?: string | OpraSchema.DataType | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }, OpraSchema.Field> {
+    }
+    interface Options extends Partial<Metadata> {
+    }
+    interface InitArguments extends Combine<{
+        name: string;
+        origin?: ComplexType | MappedType | MixinType;
+        type?: DataType;
+    }, Metadata> {
+    }
+}
+/**
+ * Type definition of ComplexType constructor type
+ * @type ApiFieldConstructor
+ */
+export interface ApiFieldConstructor extends ApiFieldDecorator {
+    prototype: ApiField;
+    new (owner: ComplexType | MappedType | MixinType, args: ApiField.InitArguments): ApiField;
+}
+/**
+ * @class ApiField
+ */
+export interface ApiField extends ApiFieldClass {
+}
+/**
+ * @constructor ApiField
+ * @decorator ApiField
+ */
+export declare const ApiField: ApiFieldConstructor;
+/**
+ *
+ * @class ApiField
+ */
+declare class ApiFieldClass extends DocumentElement {
+    readonly owner: ComplexType | MappedType | MixinType;
+    readonly origin?: ComplexType | MappedType | MixinType;
+    readonly name: string;
+    readonly type: DataType;
+    readonly description?: string;
+    readonly isArray?: boolean;
+    readonly default?: any;
+    readonly fixed?: any;
+    readonly required?: boolean;
+    readonly exclusive?: boolean;
+    readonly translatable?: boolean;
+    readonly deprecated?: boolean | string;
+    readonly examples?: any[] | Record<string, any>;
+    toJSON(): OpraSchema.Field;
+}
+export {};

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

@@ -0,0 +1,80 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { IsObject, Validator } from 'valgen';
+import { FieldsProjection, ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { DocumentElement } from '../common/document-element.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import type { ApiField } from './api-field';
+import type { ComplexType } from './complex-type';
+import { DataType } from './data-type.js';
+import Field = OpraSchema.Field;
+export declare const FIELD_PATH_PATTERN: RegExp;
+/**
+ * Type definition of class constructor for ComplexTypeBase
+ * @class ComplexTypeBase
+ */
+interface ComplexTypeBaseStatic {
+    /**
+     * Class constructor of MappedType
+     *
+     * @param owner
+     * @param initArgs
+     * @param context
+     * @constructor
+     */
+    new (owner: DocumentElement, initArgs: DataType.InitArguments, context?: DocumentInitContext): ComplexTypeBase;
+    prototype: ComplexTypeBase;
+}
+/**
+ * Type definition of ComplexTypeBase prototype
+ * @interface ComplexTypeBase
+ */
+export interface ComplexTypeBase extends ComplexTypeBaseClass {
+}
+/**
+ *
+ * @constructor
+ */
+export declare const ComplexTypeBase: ComplexTypeBaseStatic;
+/**
+ *
+ */
+declare abstract class ComplexTypeBaseClass extends DataType {
+    readonly ctor?: Type;
+    readonly fields: ResponsiveMap<ApiField>;
+    readonly additionalFields?: boolean | DataType | ['error'] | ['error', string];
+    readonly keyField?: Field.Name;
+    /**
+     *
+     */
+    findField(nameOrPath: string): ApiField | undefined;
+    /**
+     *
+     */
+    getField(nameOrPath: string): ApiField;
+    /**
+     *
+     */
+    parseFieldPath(fieldPath: string, options?: {
+        allowSigns?: 'first' | 'each';
+    }): ComplexType.ParsedFieldPath[];
+    /**
+     *
+     */
+    normalizeFieldPath(fieldPath: string, options?: {
+        allowSigns?: 'first' | 'each';
+    }): string;
+    /**
+     *
+     */
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
+    protected _generateSchema(codec: 'encode' | 'decode', context: StrictOmit<DataType.GenerateCodecOptions, 'projection'> & {
+        currentPath: string;
+        projection?: FieldsProjection | '*';
+    }): IsObject.Schema;
+    protected _generateFieldCodec(codec: 'encode' | 'decode', field: ApiField, context: StrictOmit<DataType.GenerateCodecOptions, 'projection'> & {
+        currentPath: string;
+        projection?: FieldsProjection;
+    }): Validator;
+}
+export {};

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

@@ -1,51 +1,77 @@
 import 'reflect-metadata';
-import { StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
+import { Combine, Type, TypeThunkAsync } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
-import type { TypeThunkAsync } from '../../types.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexTypeClass } from './complex-type-class.js';
+import type { DocumentElement } from '../common/document-element.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { ApiField } from './api-field.js';
+import { ComplexTypeBase } from './complex-type-base.js';
 import { DataType } from './data-type.js';
-import { ApiField } from './field.js';
 import type { MappedType } from './mapped-type.js';
 import type { MixinType } from './mixin-type.js';
 /**
- * Callable class pattern for ComplexType
+ * @namespace ComplexType
+ */
+export declare namespace ComplexType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.ComplexType.Kind;
+        fields?: Record<string, ApiField.Metadata>;
+        additionalFields?: boolean | string | TypeThunkAsync | ['error'] | ['error', string];
+    }, DataType.Metadata, OpraSchema.ComplexType> {
+    }
+    interface Options extends Combine<Pick<Metadata, 'additionalFields' | 'keyField'>, DataType.Options, Pick<OpraSchema.ComplexType, 'abstract'>> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.ComplexType.Kind;
+        base?: ComplexType | MappedType | MixinType;
+        fields?: Record<string, ApiField.InitArguments | ApiField>;
+        additionalFields?: boolean | DataType | ['error'] | ['error', string];
+    }, DataType.InitArguments, ComplexType.Metadata> {
+    }
+    interface ParsedFieldPath {
+        fieldName: string;
+        dataType: DataType;
+        field?: ApiField;
+        additionalField?: boolean;
+        sign?: '+' | '-';
+    }
+}
+/**
+ * Type definition for MixinType
+ * @class ComplexType
  */
-export interface ComplexTypeConstructor {
-    new (document: ApiDocument, init: ComplexType.InitArguments): ComplexType;
-    (options?: ComplexType.DecoratorOptions): ClassDecorator;
+export interface ComplexTypeStatic {
+    /**
+     * Class constructor of ComplexType
+     *
+     * @param owner
+     * @param args
+     * @param context
+     * @constructor
+     */
+    new (owner: DocumentElement, args?: ComplexType.InitArguments, context?: DocumentInitContext): ComplexType;
+    (options?: ComplexType.Options): ClassDecorator;
     prototype: ComplexType;
+    extend<T extends Type>(typeClass: T, fields: Record<string, ApiField.Options>): T;
 }
+/**
+ * Type definition of ComplexType prototype
+ * @interface ComplexType
+ */
 export interface ComplexType extends ComplexTypeClass {
 }
 /**
- * @class ComplexType
- * @decorator ComplexType
+ * ComplexType constructor
  */
-export declare const ComplexType: ComplexTypeConstructor;
+export declare const ComplexType: ComplexTypeStatic;
 /**
- * @namespace ComplexType
+ *
+ * @class ComplexType
  */
-export declare namespace ComplexType {
-    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.ComplexType, 'ctor' | 'abstract'> {
-        base?: ComplexType | MappedType | MixinType;
-        fields?: Record<string, ApiField.InitArguments>;
-        additionalFields?: boolean | DataType | 'error';
-        embedded?: boolean;
-    }
-    interface OwnProperties extends DataType.OwnProperties {
-        ctor?: Type;
-        additionalFields?: boolean | DataType | 'error';
-        fields: ResponsiveMap<ApiField>;
-        embedded?: boolean;
-    }
-    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'abstract'> {
-        embedded?: boolean;
-        additionalFields?: boolean | 'error' | string | TypeThunkAsync;
-    }
-    interface Metadata extends StrictOmit<OpraSchema.ComplexType, 'fields'> {
-        name: string;
-        fields?: Record<string, ApiField.Metadata>;
-    }
+declare abstract class ComplexTypeClass extends ComplexTypeBase {
+    readonly kind: OpraSchema.ComplexType.Kind;
+    readonly base?: ComplexType | MappedType | MixinType;
+    readonly ctor?: Type;
+    extendsFrom(baseType: DataType): boolean;
+    toJSON(): OpraSchema.ComplexType;
 }
+export {};

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

@@ -1,57 +1,60 @@
-import { RequiredSome, StrictOmit, Type } from 'ts-gems';
-import { OnFailFunction, Validator } from 'valgen';
+import { StrictOmit } from 'ts-gems';
+import { ValidationOptions, Validator } from 'valgen';
+import { FieldsProjection } from '../../helpers/index.js';
+import type { DataTypeBase } from '../../schema/data-type/data-type.interface.js';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
 import { nodeInspectCustom } from '../utils/inspect.util.js';
-import { ApiField } from './field.js';
 /**
- * @class DataType
- * @abstract
+ * @namespace DataType
  */
-export declare abstract class DataType {
-    readonly document: ApiDocument;
-    readonly kind: OpraSchema.DataType.Kind;
-    readonly name?: string;
-    readonly base?: DataType;
-    readonly own: DataType.OwnProperties;
-    description?: string;
-    isEmbedded?: boolean;
-    protected constructor(document: ApiDocument, init?: DataType.InitArguments);
-    abstract generateCodec(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): Validator;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.DataType;
-    extendsFrom(type: string | Type | DataType): any;
-    toString(): string;
-    [nodeInspectCustom](): string;
-}
 export declare namespace DataType {
-    interface InitArguments {
+    interface Metadata extends DataTypeBase {
         name?: string;
-        description?: string;
-        example?: string | string[];
     }
-    interface DecoratorOptions extends InitArguments {
+    interface Options extends Partial<StrictOmit<Metadata, 'kind' | 'examples'>> {
+        embedded?: boolean;
     }
-    interface Metadata extends RequiredSome<DecoratorOptions, 'name'> {
-        kind: OpraSchema.DataType.Kind;
+    interface InitArguments extends DataType.Metadata {
     }
-    interface OwnProperties {
-    }
-    type GenerateCodecField = StrictOmit<ApiField.InitArguments, 'type' | 'name'> & {
-        type?: DataType | string;
-    };
-    type OverrideFieldsConfig = GenerateCodecField & {
-        overrideFields?: Record<string, OverrideFieldsConfig>;
-    };
-    interface GenerateCodecOptions {
-        caseSensitive?: boolean;
-        pick?: string[] | readonly string[];
-        omit?: string[] | readonly string[];
-        partial?: boolean;
-        operation?: 'read' | 'write';
-        overwriteFields?: Record<string, OverrideFieldsConfig>;
-        designType?: Type;
-        onFail?: OnFailFunction;
+    interface GenerateCodecOptions extends ValidationOptions {
+        documentElement?: DocumentElement;
+        caseInSensitive?: boolean;
+        partial?: boolean | 'deep';
+        projection?: string[] | FieldsProjection | '*';
     }
 }
+interface DataTypeStatic {
+    new (owner: DocumentElement, args?: DataType.InitArguments, context?: DocumentInitContext): DataType;
+    prototype: DataType;
+}
+/**
+ * Type definition of DataType prototype
+ * @interface DataType
+ */
+export interface DataType extends DataTypeClass {
+}
+/**
+ * DataType constructor
+ */
+export declare const DataType: DataTypeStatic;
+/**
+ *
+ * @class DataType
+ */
+declare abstract class DataTypeClass extends DocumentElement {
+    readonly kind: OpraSchema.DataType.Kind;
+    readonly owner: DocumentElement;
+    readonly name?: string;
+    readonly description?: string;
+    readonly abstract?: boolean;
+    readonly examples?: OpraSchema.DataTypeExample[];
+    abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
+    get embedded(): any;
+    abstract extendsFrom(baseType: DataType): boolean;
+    toJSON(): OpraSchema.DataType;
+    toString(): string;
+    [nodeInspectCustom](): string;
+}
+export {};

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { OpraSchema } from '../../../schema/index.js';
+import type { SimpleType } from '../simple-type.js';
+export interface SimpleTypeDecorator extends ClassDecorator {
+    Example(value: any, description?: string): SimpleTypeDecorator;
+}
+export interface SimpleTypeDecoratorFactory {
+    /**
+     * Class decorator method for SimpleType
+     * @param options
+     */
+    (options?: SimpleType.Options): SimpleTypeDecorator;
+}
+export declare function SimpleTypeDecoratorFactory(options?: SimpleType.Options): SimpleTypeDecorator;
+export interface AttributeDecorator extends PropertyDecorator {
+    Example(options?: Partial<OpraSchema.Attribute>): SimpleTypeDecorator;
+}
+export interface AttributeDecoratorFactory {
+    (options?: Partial<OpraSchema.Attribute>): PropertyDecorator;
+}
+export declare function AttributeDecoratorFactory(options?: Partial<OpraSchema.Attribute>): PropertyDecorator;

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

@@ -1,34 +1,70 @@
 import 'reflect-metadata';
-import { StrictOmit } from 'ts-gems';
+import { Combine } from 'ts-gems';
+import { Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
+import type { DocumentElement } from '../common/document-element.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 EnumType.EnumObject | EnumType.EnumArray>(target: T, options: EnumType.Options<T>): EnumType.Metadata;
-}
-export interface EnumType extends EnumTypeClass {
-}
 /**
- * @class EnumType
+ * @namespace EnumType
  */
-export declare const EnumType: EnumTypeConstructor;
 export declare namespace EnumType {
-    type EnumObject = Record<string, OpraSchema.EnumType.Value>;
+    type EnumObject = Record<string, string | number>;
     type EnumArray = readonly string[];
-    interface Metadata extends StrictOmit<OpraSchema.EnumType, 'base'> {
-        name?: string;
-        base?: EnumObject | string;
-    }
-    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.EnumType, 'base'> {
-        enumObject?: object;
-        base?: EnumType;
-        values: Record<OpraSchema.EnumType.Value, OpraSchema.EnumType.ValueInfo>;
-    }
-    interface Options<T, Keys extends (string | number | symbol) = T extends readonly any[] ? T[number] : keyof T> extends DataType.DecoratorOptions {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.EnumType.Kind;
+        base?: EnumObject | EnumArray | string;
         name: string;
-        base?: EnumObject;
+    }, DataType.Metadata, OpraSchema.EnumType> {
+    }
+    interface Options<T, Keys extends string | number | symbol = T extends readonly any[] ? T[number] : keyof T> extends Combine<{
+        base?: EnumObject | EnumArray | string;
         meanings?: Record<Keys, string>;
+    }, DataType.Options> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.EnumType.Kind;
+        base?: EnumType;
+        instance?: object;
+    }, DataType.InitArguments, EnumType.Metadata> {
     }
 }
+/**
+ * Mixin type definition of class constructor and helper method for EnumType
+ */
+export interface EnumTypeStatic {
+    /**
+     * Class constructor of EnumType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args?: EnumType.InitArguments): EnumType;
+    <T extends EnumType.EnumObject, B extends EnumType.EnumObject>(enumSource: T, base: B, options: EnumType.Options<T>): B & T;
+    <T extends EnumType.EnumArray, B extends EnumType.EnumArray>(enumSource: T, base: B, options: EnumType.Options<T>): B & T;
+    <T extends EnumType.EnumObject | EnumType.EnumArray>(target: T, options: EnumType.Options<T>): T;
+}
+/**
+ * Type definition of EnumType prototype
+ * @interface EnumType
+ */
+export interface EnumType extends EnumTypeClass {
+}
+/**
+ * @class EnumType
+ */
+export declare const EnumType: EnumTypeStatic;
+/**
+ * @class EnumType
+ */
+declare class EnumTypeClass extends DataType {
+    readonly kind: OpraSchema.EnumType.Kind;
+    readonly base?: EnumType;
+    readonly instance?: object;
+    readonly attributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
+    readonly ownAttributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
+    extendsFrom(baseType: DataType): boolean;
+    generateCodec(): Validator;
+    toJSON(): OpraSchema.EnumType;
+}
+export {};

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

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

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

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

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

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

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

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

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;
+}