typia 5.0.0-dev.20230829-5 → 5.0.0-dev.20230830

package/lib/programmers/internal/random_custom.js

@@ -11,7 +11,13 @@ var random_custom = function (accessor) {
     return function (type) {
         return function (tags) {
             return function (expression) {
-                return ExpressionFactory_1.ExpressionFactory.coalesce(typescript_1.default.factory.createCallChain(typescript_1.default.factory.createPropertyAccessChain(accessor("customs"), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), typescript_1.default.factory.createIdentifier(type)), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), undefined, [LiteralFactory_1.LiteralFactory.generate(tags)]))(expression);
+                return ExpressionFactory_1.ExpressionFactory.coalesce(typescript_1.default.factory.createCallChain(typescript_1.default.factory.createPropertyAccessChain(accessor("customs"), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), typescript_1.default.factory.createIdentifier(type)), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), undefined, [
+                    LiteralFactory_1.LiteralFactory.generate(tags.map(function (t) { return ({
+                        name: t.name,
+                        kind: t.kind,
+                        value: t.value,
+                    }); })),
+                ]))(expression);
             };
         };
     };

package/lib/programmers/internal/random_custom.js.map

@@ -1 +1 @@
-{"version":3,"file":"random_custom.js","sourceRoot":"","sources":["../../../src/programmers/internal/random_custom.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA4B;AAE5B,uEAAsE;AACtE,iEAAgE;AASzD,IAAM,aAAa,GACtB,UAAC,QAAyC;IAC1C,OAAA,UAAC,IAAwB;QACzB,OAAA,UAAC,IAAwB;YACzB,OAAA,UAAC,UAAyB;gBACtB,OAAA,qCAAiB,CAAC,QAAQ,CACtB,oBAAE,CAAC,OAAO,CAAC,eAAe,CACtB,oBAAE,CAAC,OAAO,CAAC,yBAAyB,CAChC,QAAQ,CAAC,SAAS,CAAC,EACnB,oBAAE,CAAC,OAAO,CAAC,WAAW,CAAC,oBAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EACtD,oBAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,CACpC,EACD,oBAAE,CAAC,OAAO,CAAC,WAAW,CAAC,oBAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EACtD,SAAS,EACT,CAAC,+BAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAClC,CACJ,CAAC,UAAU,CAAC;YAXb,CAWa;QAZjB,CAYiB;IAbjB,CAaiB;AAdjB,CAciB,CAAC;AAhBT,QAAA,aAAa,iBAgBJ"}
+{"version":3,"file":"random_custom.js","sourceRoot":"","sources":["../../../src/programmers/internal/random_custom.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA4B;AAE5B,uEAAsE;AACtE,iEAAgE;AASzD,IAAM,aAAa,GACtB,UAAC,QAAyC;IAC1C,OAAA,UAAC,IAAwB;QACzB,OAAA,UAAC,IAAwB;YACzB,OAAA,UAAC,UAAyB;gBACtB,OAAA,qCAAiB,CAAC,QAAQ,CACtB,oBAAE,CAAC,OAAO,CAAC,eAAe,CACtB,oBAAE,CAAC,OAAO,CAAC,yBAAyB,CAChC,QAAQ,CAAC,SAAS,CAAC,EACnB,oBAAE,CAAC,OAAO,CAAC,WAAW,CAAC,oBAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EACtD,oBAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,CACpC,EACD,oBAAE,CAAC,OAAO,CAAC,WAAW,CAAC,oBAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EACtD,SAAS,EACT;oBACI,+BAAc,CAAC,QAAQ,CACnB,IAAI,CAAC,GAAG,CAAC,UAAC,CAAC,IAAK,OAAA,CAAC;wBACb,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;wBACZ,KAAK,EAAE,CAAC,CAAC,KAAK;qBACjB,CAAC,EAJc,CAId,CAAC,CACN;iBACJ,CACJ,CACJ,CAAC,UAAU,CAAC;YAnBb,CAmBa;QApBjB,CAoBiB;IArBjB,CAqBiB;AAtBjB,CAsBiB,CAAC;AAxBT,QAAA,aAAa,iBAwBJ"}

package/lib/protobuf.d.ts

@@ -51,17 +51,17 @@ export declare function message<T>(): string;
  * For reference, as Protocol Buffer handles binary data directly, there's no way
  * when `input` binary data was not encoded from the `T` typed value. In that case,
  * unexpected behavior or internal error would be occured. Therefore, I recommend you
- * to encode binary data of Protocol Buffer from type safe encode function like below.
+ * to encode binary data of Protocol Buffer from type safe encode functions like below.
  * Use {@link encode} function only when you can ensure it.
  *
  *  - {@link assertEncode}
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * Also, `typia` is providing a type safe decoder like {@link assertDecode}, but it
- * is just for additional validation like whether a string value meets constant
- * restriction, or a numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
+ * Also, `typia` is providing type safe decoders like {@link assertDecode}, but it
+ * is just for additional type validation like `number & Minimum<7>` or
+ * `string & Format<"uuid">` cases, that are represented by
+ * [custom tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
  * you've to ensure the type safety when using decoder functions.
  *
  * @tempate Expected type of decoded value
@@ -80,17 +80,17 @@ export declare function decode(input: Uint8Array): never;
  * For reference, as Protocol Buffer handles binary data directly, there's no way
  * when `input` binary data was not encoded from the `T` typed value. In that case,
  * unexpected behavior or internal error would be occured. Therefore, I recommend you
- * to encode binary data of Protocol Buffer from type safe encode function like below.
+ * to encode binary data of Protocol Buffer from type safe encode functions like below.
  * Use {@link encode} function only when you can ensure it.
  *
  *  - {@link assertEncode}
  *  - {@link isEncode}
  *  - {@link validateEncode}
  *
- * Also, `typia` is providing a type safe decoder like {@link assertDecode}, but it
- * is just for additional validation like whether a string value meets constant
- * restriction, or a numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
+ * Also, `typia` is providing type safe decoders like {@link assertDecode}, but it
+ * is just for additional type validation like `number & Minimum<7>` or
+ * `string & Format<"uuid">` cases, that are represented by
+ * [custom tags](https://typia.io/docs/validators/tags). Thus, I repeat that,
  * you've to ensure the type safety when using decoder functions.
  *
  * @tempate Expected type of decoded value
@@ -112,10 +112,10 @@ export declare function decode<T>(input: Uint8Array): Resolved<T>;
  * {@link TypeGuardError} instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type assertion like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.assertDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -140,10 +140,10 @@ export declare function assertDecode(input: Uint8Array): never;
  * {@link TypeGuardError} instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type assertion like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.assertDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -170,10 +170,10 @@ export declare function assertDecode<T>(input: Uint8Array): Resolved<T>;
  * `null` value instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type checking like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.isDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -198,10 +198,10 @@ export declare function isDecode(input: Uint8Array): never;
  * `null` value instead.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type checking like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.isDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -229,10 +229,10 @@ export declare function isDecode<T>(input: Uint8Array): Resolved<T> | null;
  * {@link IValidation.IFailure} value instead with detailed error reasons.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type validation like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.validateDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *
@@ -258,10 +258,10 @@ export declare function validateDecode(input: Uint8Array): never;
  * {@link IValidation.IFailure} value instead with detailed error reasons.
  *
  * However, note that, this validation is not always safe. It just performs additional
- * type checking like whether a string value meets constant restriction, or a
- * numeric value is keepking its range limit, represented by
- * [comment tags](https://typia.io/docs/validators/tags). Therefore, when using
- * decode functions, you have to ensure the type safety by yourself.
+ * type validation like `number & Minimum<7>` or `string & Format<"uuid">` cases,
+ * that are represented by [custom tags](https://typia.io/docs/validators/tags).
+ * Therefore, when using `typia.protobuf.validateDecode<T>()` function, you have to
+ * ensure the type safety by yourself.
  *
  * In such type safety reason, I recommend you to use type safe encode functions.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "5.0.0-dev.20230829-5",
+  "version": "5.0.0-dev.20230830",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/factories/MetadataFactory.ts

@@ -1,214 +1,214 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
-import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
-import { explore_metadata } from "./internal/metadata/explore_metadata";
-import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
-import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
-
-import { ValidationPipe } from "../typings/ValidationPipe";
-
-import { MetadataCollection } from "./MetadataCollection";
-
-export namespace MetadataFactory {
-    export type Validator = (meta: Metadata, explore: IExplore) => string[];
-
-    export interface IOptions {
-        escape: boolean;
-        constant: boolean;
-        absorb: boolean;
-        validate?: Validator;
-        onError?: (node: ts.Node | undefined, message: string) => void;
-    }
-
-    export interface IExplore {
-        top: boolean;
-        object: MetadataObject | null;
-        property: string | object | null;
-        nested: null | MetadataAlias | MetadataArrayType | MetadataTupleType;
-        escaped: boolean;
-        aliased: boolean;
-    }
-
-    export interface IError {
-        name: string;
-        explore: IExplore;
-        messages: string[];
-    }
-
-    export const analyze =
-        (checker: ts.TypeChecker) =>
-        (options: IOptions) =>
-        (collection: MetadataCollection) =>
-        (type: ts.Type | null): ValidationPipe<Metadata, IError> => {
-            const errors: IError[] = [];
-            const meta: Metadata = explore_metadata(checker)(options)(
-                collection,
-            )(errors)(type, {
-                top: true,
-                object: null,
-                property: null,
-                nested: null,
-                escaped: false,
-                aliased: false,
-            });
-            iterate_metadata_collection(errors)(collection);
-            iterate_metadata_sort(collection)(meta);
-
-            if (options.validate)
-                errors.push(...validate(options)(options.validate)(meta));
-            return errors.length
-                ? {
-                      success: false,
-                      errors,
-                  }
-                : {
-                      success: true,
-                      data: meta,
-                  };
-        };
-
-    /**
-     * @internal
-     */
-    export const soleLiteral = (value: string): Metadata => {
-        const meta: Metadata = Metadata.initialize();
-        meta.constants.push({
-            values: [value],
-            type: "string",
-        });
-        return meta;
-    };
-
-    const validate =
-        (options: IOptions) =>
-        (functor: Validator) =>
-        (meta: Metadata): IError[] => {
-            const visitor: IValidationVisitor = {
-                functor,
-                errors: [],
-                objects: new Set(),
-                arrays: new Set(),
-                tuples: new Set(),
-                aliases: new Set(),
-            };
-            validateMeta(options)(visitor)(meta, {
-                object: null,
-                property: null,
-                nested: null,
-                top: true,
-                aliased: false,
-                escaped: false,
-            });
-            return visitor.errors;
-        };
-
-    const validateMeta =
-        (options: IOptions) =>
-        (visitor: IValidationVisitor) =>
-        (meta: Metadata, explore: IExplore) => {
-            const result: Set<string> = new Set(visitor.functor(meta, explore));
-            if (result.size)
-                visitor.errors.push({
-                    name: meta.getName(),
-                    explore: { ...explore },
-                    messages: [...result],
-                });
-
-            for (const alias of meta.aliases)
-                validateAlias(options)(visitor)(alias, explore);
-            for (const array of meta.arrays)
-                validateArray(options)(visitor)(array.type, explore);
-            for (const tuple of meta.tuples)
-                validateTuple(options)(visitor)(tuple.type, explore);
-            for (const obj of meta.objects)
-                validateObject(options)(visitor)(obj);
-            for (const set of meta.sets)
-                validateMeta(options)(visitor)(set, explore);
-            for (const map of meta.maps) {
-                validateMeta(options)(visitor)(map.key, explore);
-                validateMeta(options)(visitor)(map.value, explore);
-            }
-
-            if (options.escape === true && meta.escaped !== null)
-                validateMeta(options)(visitor)(meta.escaped.returns, {
-                    ...explore,
-                    escaped: true,
-                });
-        };
-
-    const validateAlias =
-        (options: IOptions) =>
-        (visitor: IValidationVisitor) =>
-        (alias: MetadataAlias, explore: IExplore) => {
-            if (visitor.aliases.has(alias)) return;
-            visitor.aliases.add(alias);
-
-            validateMeta(options)(visitor)(alias.value, {
-                ...explore,
-                nested: alias,
-                aliased: true,
-            });
-        };
-
-    const validateArray =
-        (options: IOptions) =>
-        (visitor: IValidationVisitor) =>
-        (array: MetadataArrayType, explore: IExplore) => {
-            if (visitor.arrays.has(array)) return;
-            visitor.arrays.add(array);
-
-            validateMeta(options)(visitor)(array.value, {
-                ...explore,
-                nested: array,
-                top: false,
-            });
-        };
-
-    const validateTuple =
-        (options: IOptions) =>
-        (visitor: IValidationVisitor) =>
-        (tuple: MetadataTupleType, explore: IExplore) => {
-            if (visitor.tuples.has(tuple)) return;
-            visitor.tuples.add(tuple);
-
-            for (const elem of tuple.elements)
-                validateMeta(options)(visitor)(elem, {
-                    ...explore,
-                    nested: tuple,
-                    top: false,
-                });
-        };
-
-    const validateObject =
-        (options: IOptions) =>
-        (visitor: IValidationVisitor) =>
-        (object: MetadataObject) => {
-            if (visitor.objects.has(object)) return;
-            visitor.objects.add(object);
-
-            for (const property of object.properties)
-                validateMeta(options)(visitor)(property.value, {
-                    object,
-                    property: property.key.isSoleLiteral()
-                        ? property.key.getSoleLiteral()!
-                        : {},
-                    nested: null,
-                    top: false,
-                    aliased: false,
-                    escaped: false,
-                });
-        };
-
-    interface IValidationVisitor {
-        functor: Validator;
-        errors: IError[];
-        objects: Set<MetadataObject>;
-        arrays: Set<MetadataArrayType>;
-        tuples: Set<MetadataTupleType>;
-        aliases: Set<MetadataAlias>;
-    }
-}
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataAlias } from "../schemas/metadata/MetadataAlias";
+import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
+import { explore_metadata } from "./internal/metadata/explore_metadata";
+import { iterate_metadata_collection } from "./internal/metadata/iterate_metadata_collection";
+import { iterate_metadata_sort } from "./internal/metadata/iterate_metadata_sort";
+
+import { ValidationPipe } from "../typings/ValidationPipe";
+
+import { MetadataCollection } from "./MetadataCollection";
+
+export namespace MetadataFactory {
+    export type Validator = (meta: Metadata, explore: IExplore) => string[];
+
+    export interface IOptions {
+        escape: boolean;
+        constant: boolean;
+        absorb: boolean;
+        validate?: Validator;
+        onError?: (node: ts.Node | undefined, message: string) => void;
+    }
+
+    export interface IExplore {
+        top: boolean;
+        object: MetadataObject | null;
+        property: string | object | null;
+        nested: null | MetadataAlias | MetadataArrayType | MetadataTupleType;
+        escaped: boolean;
+        aliased: boolean;
+    }
+
+    export interface IError {
+        name: string;
+        explore: IExplore;
+        messages: string[];
+    }
+
+    export const analyze =
+        (checker: ts.TypeChecker) =>
+        (options: IOptions) =>
+        (collection: MetadataCollection) =>
+        (type: ts.Type | null): ValidationPipe<Metadata, IError> => {
+            const errors: IError[] = [];
+            const meta: Metadata = explore_metadata(checker)(options)(
+                collection,
+            )(errors)(type, {
+                top: true,
+                object: null,
+                property: null,
+                nested: null,
+                escaped: false,
+                aliased: false,
+            });
+            iterate_metadata_collection(errors)(collection);
+            iterate_metadata_sort(collection)(meta);
+
+            if (options.validate)
+                errors.push(...validate(options)(options.validate)(meta));
+            return errors.length
+                ? {
+                      success: false,
+                      errors,
+                  }
+                : {
+                      success: true,
+                      data: meta,
+                  };
+        };
+
+    /**
+     * @internal
+     */
+    export const soleLiteral = (value: string): Metadata => {
+        const meta: Metadata = Metadata.initialize();
+        meta.constants.push({
+            values: [value],
+            type: "string",
+        });
+        return meta;
+    };
+
+    const validate =
+        (options: IOptions) =>
+        (functor: Validator) =>
+        (meta: Metadata): IError[] => {
+            const visitor: IValidationVisitor = {
+                functor,
+                errors: [],
+                objects: new Set(),
+                arrays: new Set(),
+                tuples: new Set(),
+                aliases: new Set(),
+            };
+            validateMeta(options)(visitor)(meta, {
+                object: null,
+                property: null,
+                nested: null,
+                top: true,
+                aliased: false,
+                escaped: false,
+            });
+            return visitor.errors;
+        };
+
+    const validateMeta =
+        (options: IOptions) =>
+        (visitor: IValidationVisitor) =>
+        (meta: Metadata, explore: IExplore) => {
+            const result: Set<string> = new Set(visitor.functor(meta, explore));
+            if (result.size)
+                visitor.errors.push({
+                    name: meta.getName(),
+                    explore: { ...explore },
+                    messages: [...result],
+                });
+
+            for (const alias of meta.aliases)
+                validateAlias(options)(visitor)(alias, explore);
+            for (const array of meta.arrays)
+                validateArray(options)(visitor)(array.type, explore);
+            for (const tuple of meta.tuples)
+                validateTuple(options)(visitor)(tuple.type, explore);
+            for (const obj of meta.objects)
+                validateObject(options)(visitor)(obj);
+            for (const set of meta.sets)
+                validateMeta(options)(visitor)(set, explore);
+            for (const map of meta.maps) {
+                validateMeta(options)(visitor)(map.key, explore);
+                validateMeta(options)(visitor)(map.value, explore);
+            }
+
+            if (options.escape === true && meta.escaped !== null)
+                validateMeta(options)(visitor)(meta.escaped.returns, {
+                    ...explore,
+                    escaped: true,
+                });
+        };
+
+    const validateAlias =
+        (options: IOptions) =>
+        (visitor: IValidationVisitor) =>
+        (alias: MetadataAlias, explore: IExplore) => {
+            if (visitor.aliases.has(alias)) return;
+            visitor.aliases.add(alias);
+
+            validateMeta(options)(visitor)(alias.value, {
+                ...explore,
+                nested: alias,
+                aliased: true,
+            });
+        };
+
+    const validateArray =
+        (options: IOptions) =>
+        (visitor: IValidationVisitor) =>
+        (array: MetadataArrayType, explore: IExplore) => {
+            if (visitor.arrays.has(array)) return;
+            visitor.arrays.add(array);
+
+            validateMeta(options)(visitor)(array.value, {
+                ...explore,
+                nested: array,
+                top: false,
+            });
+        };
+
+    const validateTuple =
+        (options: IOptions) =>
+        (visitor: IValidationVisitor) =>
+        (tuple: MetadataTupleType, explore: IExplore) => {
+            if (visitor.tuples.has(tuple)) return;
+            visitor.tuples.add(tuple);
+
+            for (const elem of tuple.elements)
+                validateMeta(options)(visitor)(elem, {
+                    ...explore,
+                    nested: tuple,
+                    top: false,
+                });
+        };
+
+    const validateObject =
+        (options: IOptions) =>
+        (visitor: IValidationVisitor) =>
+        (object: MetadataObject) => {
+            if (visitor.objects.has(object)) return;
+            visitor.objects.add(object);
+
+            for (const property of object.properties)
+                validateMeta(options)(visitor)(property.value, {
+                    object,
+                    property: property.key.isSoleLiteral()
+                        ? property.key.getSoleLiteral()!
+                        : {},
+                    nested: null,
+                    top: false,
+                    aliased: false,
+                    escaped: false,
+                });
+        };
+
+    interface IValidationVisitor {
+        functor: Validator;
+        errors: IError[];
+        objects: Set<MetadataObject>;
+        arrays: Set<MetadataArrayType>;
+        tuples: Set<MetadataTupleType>;
+        aliases: Set<MetadataAlias>;
+    }
+}