@opra/common 0.33.13 → 1.0.0-alpha.10

package/types/document/common/document-init-context.d.ts

@@ -0,0 +1,17 @@
+import { OpraDocumentError } from './opra-document-error.js';
+export declare namespace DocumentInitContext {
+    interface Options {
+        maxErrors?: number;
+    }
+}
+export declare class DocumentInitContext {
+    path: string;
+    error: OpraDocumentError;
+    maxErrors: number;
+    showErrorDetails: boolean;
+    constructor(options?: DocumentInitContext.Options);
+    addError(error: Error | OpraDocumentError.ErrorDetail | string): void;
+    enter(path: string, fn: () => any): any;
+    enterAsync(path: string, fn: () => any): Promise<any>;
+    extend<T>(args: T): this & T;
+}

package/types/document/common/document-node.d.ts

@@ -0,0 +1,65 @@
+import { Type } from 'ts-gems';
+import type { ApiDocument } from '../api-document.js';
+import { kDataTypeMap } from '../constants.js';
+import type { ComplexType } from '../data-type/complex-type';
+import type { DataType } from '../data-type/data-type';
+import type { EnumType } from '../data-type/enum-type';
+import type { MappedType } from '../data-type/mapped-type';
+import type { MixinType } from '../data-type/mixin-type';
+import type { SimpleType } from '../data-type/simple-type';
+import type { DataTypeMap } from './data-type-map.js';
+import type { DocumentElement } from './document-element';
+/**
+ * @class DocumentNode
+ */
+export declare class DocumentNode {
+    protected [kDataTypeMap]?: DataTypeMap;
+    protected _document?: ApiDocument;
+    readonly parent?: DocumentNode;
+    readonly element: DocumentElement;
+    constructor(element: DocumentElement, parent?: DocumentNode);
+    getDocument(): ApiDocument;
+    hasDataType(nameOrCtor: string | Type | Function | object | any[]): boolean;
+    findDataType(nameOrCtor: string | Type | Function | object | any[]): DataType | undefined;
+    /**
+     * Returns DataType instance by name or Constructor. Returns undefined if not found
+     * @param nameOrCtor
+     */
+    getDataType(nameOrCtor: string | Type | Function | object | any[]): DataType;
+    getDataTypeNameWithNs(dataType: DataType): string | undefined;
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a ComplexType
+     * @param nameOrCtor
+     */
+    getComplexType(nameOrCtor: string | Type | Function): ComplexType;
+    /**
+     * Returns SimpleType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a SimpleType
+     * @param nameOrCtor
+     */
+    getSimpleType(nameOrCtor: string | Type): SimpleType;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a EnumType
+     * @param nameOrCtor
+     */
+    getEnumType(nameOrCtor: string | object | any[]): EnumType;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MappedType
+     * @param nameOrCtor
+     */
+    getMappedType(nameOrCtor: string | object | any[]): MappedType;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MixinType
+     * @param nameOrCtor
+     */
+    getMixinType(nameOrCtor: string | object | any[]): MixinType;
+}

package/types/document/common/opra-document-error.d.ts

@@ -0,0 +1,12 @@
+import { OpraException } from '../../exception/opra-exception.js';
+export declare namespace OpraDocumentError {
+    interface ErrorDetail {
+        message: string;
+        path: string;
+    }
+}
+export declare class OpraDocumentError extends OpraException {
+    details: OpraDocumentError.ErrorDetail[];
+    constructor();
+    add(detail: OpraDocumentError.ErrorDetail): this;
+}

package/types/document/common/value.d.ts

@@ -0,0 +1,48 @@
+import { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
+import type { OpraSchema } from '../../schema/index.js';
+import { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { DocumentElement } from './document-element.js';
+/**
+ * @namespace Value
+ */
+export declare namespace Value {
+    interface Metadata extends StrictOmit<OpraSchema.Value, 'type'> {
+        type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }
+    interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
+        type?: string | TypeThunkAsync | object;
+    }
+    interface InitArguments extends Combine<{
+        type?: DataType;
+    }, Metadata> {
+    }
+}
+/**
+ * Type definition for Value
+ * @class Value
+ */
+interface ValueStatic {
+    new (owner: DocumentElement, args: Value.InitArguments): Value;
+    prototype: Value;
+}
+/**
+ * Type definition of Value prototype
+ * @interface Value
+ */
+export interface Value extends ValueClass {
+}
+export declare const Value: ValueStatic;
+/**
+ * @class Value
+ */
+declare class ValueClass extends DocumentElement {
+    readonly owner: DocumentElement;
+    readonly name: string | RegExp;
+    type?: DataType;
+    description?: string;
+    examples?: any[] | Record<string, any>;
+    isArray?: boolean;
+    toJSON(): OpraSchema.Value;
+}
+export {};

package/types/document/constants.d.ts

@@ -1,6 +1,12 @@
 export declare const DATATYPE_METADATA: unique symbol;
-export declare const RESOURCE_METADATA: unique symbol;
+export declare const HTTP_CONTROLLER_METADATA: unique symbol;
+export declare const DECODER: unique symbol;
+export declare const ENCODER: unique symbol;
 export declare const DECORATOR: unique symbol;
+export declare const BUILTIN: unique symbol;
 export declare const NAMESPACE_PATTERN: RegExp;
-export declare const TYPENAME_PATTERN: RegExp;
-export declare const SORT_FIELD_PATTERN: RegExp;
+export declare const CLASS_NAME_PATTERN: RegExp;
+export declare const EXTRACT_TYPENAME_PATTERN: RegExp;
+export declare const kDataTypeMap: unique symbol;
+export declare const kCtorMap: unique symbol;
+export declare const kTypeNSMap: unique symbol;

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

@@ -0,0 +1,67 @@
+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 readonly?: boolean;
+    readonly writeonly?: boolean;
+    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 | string | Type | object): boolean;
+    toJSON(): OpraSchema.ComplexType;
 }
+export {};

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

@@ -1,57 +1,62 @@
-import { RequiredSome, StrictOmit, Type } from 'ts-gems';
-import { OnFailFunction, Validator } from 'valgen';
+import { StrictOmit, Type } 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 | '*';
+        ignoreReadonlyFields?: boolean;
+        ignoreWriteonlyFields?: boolean;
     }
 }
+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 | string | Type | object): boolean;
+    toJSON(): OpraSchema.DataType;
+    toString(): string;
+    [nodeInspectCustom](): string;
+}
+export {};

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

@@ -1,34 +1,70 @@
 import 'reflect-metadata';
-import { StrictOmit } from 'ts-gems';
+import { Combine, Type } 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 | string | Type | object): 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;
+}