typia 4.1.3-dev.20230704 → 4.1.4-dev.20230705

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "4.1.3-dev.20230704",
+  "version": "4.1.4-dev.20230705",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -1,137 +1,137 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { CommentFactory } from "../../CommentFactory";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_object =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (parent: ts.Type, nullable: boolean): MetadataObject => {
-        // EMPLACE OBJECT
-        const [obj, newbie] = collection.emplace(checker, parent);
-        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
-
-        if (newbie === false) return obj;
-
-        // PREPARE ASSETS
-        const isClass: boolean = parent.isClass();
-        const pred: (node: ts.Declaration) => boolean = isClass
-            ? (node) => {
-                  const kind: ts.SyntaxKind | undefined = node
-                      .getChildren()[0]
-                      ?.getChildren()[0]?.kind;
-                  return (
-                      kind !== ts.SyntaxKind.PrivateKeyword &&
-                      kind !== ts.SyntaxKind.ProtectedKeyword &&
-                      (ts.isParameter(node) || isProperty(node))
-                  );
-              }
-            : (node) => isProperty(node);
-
-        const insert =
-            (key: Metadata) =>
-            (value: Metadata) =>
-            (
-                symbol: ts.Symbol | undefined,
-                filter?: (doc: ts.JSDocTagInfo) => boolean,
-            ): MetadataProperty => {
-                // COMMENTS AND TAGS
-                const description: string | null = symbol
-                    ? CommentFactory.description(symbol) ?? null
-                    : null;
-                const jsDocTags: ts.JSDocTagInfo[] = (
-                    symbol?.getJsDocTags() ?? []
-                ).filter(filter ?? (() => true));
-
-                // THE PROPERTY
-                const property = MetadataProperty.create({
-                    key,
-                    value,
-                    description,
-                    jsDocTags,
-                    tags: [],
-                });
-                obj.properties.push(property);
-                return property;
-            };
-
-        //----
-        // REGULAR PROPERTIES
-        //----
-        for (const prop of parent.getApparentProperties()) {
-            // CHECK INTERNAL TAG
-            if (
-                (prop.getJsDocTags(checker) ?? []).find(
-                    (tag) => tag.name === "internal",
-                ) !== undefined
-            )
-                continue;
-
-            // CHECK NODE IS A FORMAL PROPERTY
-            const [node, type] = (() => {
-                const node = (prop.getDeclarations() ?? [])[0] as
-                    | ts.PropertyDeclaration
-                    | undefined;
-                const type: ts.Type | undefined = node
-                    ? checker.getTypeOfSymbolAtLocation(prop, node)
-                    : "getTypeOfPropertyOfType" in checker
-                    ? (checker as any).getTypeOfPropertyOfType(
-                          parent,
-                          prop.name,
-                      )
-                    : undefined;
-                return [node, type];
-            })();
-            if ((node && pred(node) === false) || type === undefined) continue;
-
-            // GET EXACT TYPE
-            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
-            const value: Metadata = explore_metadata(checker)(options)(
-                collection,
-            )(type, false);
-
-            // OPTIONAL, BUT CAN BE RQUIRED BY `Required<T>` TYPE
-            if (node?.questionToken && (value.required === false || value.any))
-                Writable(value).optional = true;
-            insert(key)(value)(prop);
-        }
-
-        //----
-        // DYNAMIC PROPERTIES
-        //----
-        for (const index of checker.getIndexInfosOfType(parent)) {
-            // GET EXACT TYPE
-            const analyzer = (type: ts.Type) =>
-                explore_metadata(checker)(options)(collection)(type, false);
-            const key: Metadata = analyzer(index.keyType);
-            const value: Metadata = analyzer(index.type);
-
-            // INSERT WITH REQUIRED CONFIGURATION
-            insert(key)(value)(
-                index.declaration?.parent
-                    ? checker.getSymbolAtLocation(index.declaration.parent)
-                    : undefined,
-                (doc) => doc.name !== "default",
-            );
-        }
-
-        return obj;
-    };
-
-const isProperty = (node: ts.Declaration) =>
-    ts.isPropertyDeclaration(node) ||
-    ts.isPropertyAssignment(node) ||
-    ts.isPropertySignature(node) ||
-    ts.isTypeLiteralNode(node);
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_object =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (parent: ts.Type, nullable: boolean): MetadataObject => {
+        // EMPLACE OBJECT
+        const [obj, newbie] = collection.emplace(checker, parent);
+        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
+
+        if (newbie === false) return obj;
+
+        // PREPARE ASSETS
+        const isClass: boolean = parent.isClass();
+        const pred: (node: ts.Declaration) => boolean = isClass
+            ? (node) => {
+                  const kind: ts.SyntaxKind | undefined = node
+                      .getChildren()[0]
+                      ?.getChildren()[0]?.kind;
+                  return (
+                      kind !== ts.SyntaxKind.PrivateKeyword &&
+                      kind !== ts.SyntaxKind.ProtectedKeyword &&
+                      (ts.isParameter(node) || isProperty(node))
+                  );
+              }
+            : (node) => isProperty(node);
+
+        const insert =
+            (key: Metadata) =>
+            (value: Metadata) =>
+            (
+                symbol: ts.Symbol | undefined,
+                filter?: (doc: ts.JSDocTagInfo) => boolean,
+            ): MetadataProperty => {
+                // COMMENTS AND TAGS
+                const description: string | null = symbol
+                    ? CommentFactory.description(symbol) ?? null
+                    : null;
+                const jsDocTags: ts.JSDocTagInfo[] = (
+                    symbol?.getJsDocTags() ?? []
+                ).filter(filter ?? (() => true));
+
+                // THE PROPERTY
+                const property = MetadataProperty.create({
+                    key,
+                    value,
+                    description,
+                    jsDocTags,
+                    tags: [],
+                });
+                obj.properties.push(property);
+                return property;
+            };
+
+        //----
+        // REGULAR PROPERTIES
+        //----
+        for (const prop of parent.getApparentProperties()) {
+            // CHECK INTERNAL TAG
+            if (
+                (prop.getJsDocTags(checker) ?? []).find(
+                    (tag) => tag.name === "internal",
+                ) !== undefined
+            )
+                continue;
+
+            // CHECK NODE IS A FORMAL PROPERTY
+            const [node, type] = (() => {
+                const node = (prop.getDeclarations() ?? [])[0] as
+                    | ts.PropertyDeclaration
+                    | undefined;
+                const type: ts.Type | undefined = node
+                    ? checker.getTypeOfSymbolAtLocation(prop, node)
+                    : "getTypeOfPropertyOfType" in checker
+                    ? (checker as any).getTypeOfPropertyOfType(
+                          parent,
+                          prop.name,
+                      )
+                    : undefined;
+                return [node, type];
+            })();
+            if ((node && pred(node) === false) || type === undefined) continue;
+
+            // GET EXACT TYPE
+            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
+            const value: Metadata = explore_metadata(checker)(options)(
+                collection,
+            )(type, false);
+
+            // OPTIONAL, BUT CAN BE RQUIRED BY `Required<T>` TYPE
+            if (node?.questionToken && (value.required === false || value.any))
+                Writable(value).optional = true;
+            insert(key)(value)(prop);
+        }
+
+        //----
+        // DYNAMIC PROPERTIES
+        //----
+        for (const index of checker.getIndexInfosOfType(parent)) {
+            // GET EXACT TYPE
+            const analyzer = (type: ts.Type) =>
+                explore_metadata(checker)(options)(collection)(type, false);
+            const key: Metadata = analyzer(index.keyType);
+            const value: Metadata = analyzer(index.type);
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            insert(key)(value)(
+                index.declaration?.parent
+                    ? checker.getSymbolAtLocation(index.declaration.parent)
+                    : undefined,
+                (doc) => doc.name !== "default",
+            );
+        }
+
+        return obj;
+    };
+
+const isProperty = (node: ts.Declaration) =>
+    ts.isPropertyDeclaration(node) ||
+    ts.isPropertyAssignment(node) ||
+    ts.isPropertySignature(node) ||
+    ts.isTypeLiteralNode(node);

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -1,133 +1,133 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataArray } from "../../../metadata/MetadataArray";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataTuple } from "../../../metadata/MetadataTuple";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { iterate_metadata_tag } from "./iterate_metadata_tag";
-
-export const iterate_metadata_collection = (
-    collection: MetadataCollection,
-): void => {
-    for (const array of collection.arrays())
-        if (array.recursive === null)
-            collection.setArrayRecursive(
-                array,
-                isArrayRecursive(new Set())(array)(array.value),
-            );
-    for (const tuple of collection.tuples())
-        if (tuple.recursive === null) {
-            const visited: Set<Metadata> = new Set();
-            collection.setTupleRecursive(
-                tuple,
-                tuple.elements.some(isTupleRecursive(visited)(tuple)),
-            );
-        }
-    for (const obj of collection.objects()) {
-        iterate_metadata_tag(obj);
-        if (obj.recursive === null) {
-            const visited: Set<Metadata> = new Set();
-            collection.setObjectRecursive(
-                obj,
-                obj.properties.some((p) =>
-                    isObjectRecursive(visited)(obj)(p.value),
-                ),
-            );
-        }
-    }
-};
-
-const isArrayRecursive =
-    (visited: Set<Metadata>) =>
-    (array: MetadataArray) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-        visited.add(meta);
-
-        return (
-            meta.arrays.some(
-                (a) => a === array || isArrayRecursive(visited)(array)(a.value),
-            ) ||
-            meta.aliases.some((d) =>
-                isArrayRecursive(visited)(array)(d.value),
-            ) ||
-            meta.tuples.some(
-                (t) =>
-                    !t.recursive &&
-                    t.elements.some((e) => isArrayRecursive(visited)(array)(e)),
-            ) ||
-            meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
-            meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
-            (meta.resolved !== null &&
-                isArrayRecursive(visited)(array)(meta.resolved.returns)) ||
-            (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
-        );
-    };
-
-const isTupleRecursive =
-    (visited: Set<Metadata>) =>
-    (tuple: MetadataTuple) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-        visited.add(meta);
-
-        return (
-            meta.tuples.some(
-                (t) =>
-                    t === tuple ||
-                    t.elements.some((e) => isTupleRecursive(visited)(tuple)(e)),
-            ) ||
-            meta.arrays.some(
-                (a) =>
-                    !a.recursive && isTupleRecursive(visited)(tuple)(a.value),
-            ) ||
-            meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
-            meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
-            meta.aliases.some((d) =>
-                isTupleRecursive(visited)(tuple)(d.value),
-            ) ||
-            (meta.resolved !== null &&
-                isTupleRecursive(visited)(tuple)(meta.resolved.returns)) ||
-            (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
-        );
-    };
-
-const isObjectRecursive =
-    (visited: Set<Metadata>) =>
-    (obj: MetadataObject) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-
-        visited.add(meta);
-        return (
-            meta.objects.some(
-                (o) =>
-                    obj === o ||
-                    o.properties.some((prop) =>
-                        isObjectRecursive(visited)(obj)(prop.value),
-                    ),
-            ) ||
-            meta.aliases.some((alias) =>
-                isObjectRecursive(visited)(obj)(alias.value),
-            ) ||
-            meta.arrays.some(
-                (array) =>
-                    !array.recursive &&
-                    isObjectRecursive(visited)(obj)(array.value),
-            ) ||
-            meta.tuples.some(
-                (tuple) =>
-                    !tuple.recursive &&
-                    tuple.elements.some((elem) =>
-                        isObjectRecursive(visited)(obj)(elem),
-                    ),
-            ) ||
-            meta.maps.some((map) =>
-                isObjectRecursive(visited)(obj)(map.value),
-            ) ||
-            meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
-            (meta.resolved !== null &&
-                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
-            (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
-        );
-    };
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataArray } from "../../../metadata/MetadataArray";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataTuple } from "../../../metadata/MetadataTuple";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { iterate_metadata_tag } from "./iterate_metadata_tag";
+
+export const iterate_metadata_collection = (
+    collection: MetadataCollection,
+): void => {
+    for (const array of collection.arrays())
+        if (array.recursive === null)
+            collection.setArrayRecursive(
+                array,
+                isArrayRecursive(new Set())(array)(array.value),
+            );
+    for (const tuple of collection.tuples())
+        if (tuple.recursive === null) {
+            const visited: Set<Metadata> = new Set();
+            collection.setTupleRecursive(
+                tuple,
+                tuple.elements.some(isTupleRecursive(visited)(tuple)),
+            );
+        }
+    for (const obj of collection.objects()) {
+        iterate_metadata_tag(obj);
+        if (obj.recursive === null) {
+            const visited: Set<Metadata> = new Set();
+            collection.setObjectRecursive(
+                obj,
+                obj.properties.some((p) =>
+                    isObjectRecursive(visited)(obj)(p.value),
+                ),
+            );
+        }
+    }
+};
+
+const isArrayRecursive =
+    (visited: Set<Metadata>) =>
+    (array: MetadataArray) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+        visited.add(meta);
+
+        return (
+            meta.arrays.some(
+                (a) => a === array || isArrayRecursive(visited)(array)(a.value),
+            ) ||
+            meta.aliases.some((d) =>
+                isArrayRecursive(visited)(array)(d.value),
+            ) ||
+            meta.tuples.some(
+                (t) =>
+                    !t.recursive &&
+                    t.elements.some((e) => isArrayRecursive(visited)(array)(e)),
+            ) ||
+            meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
+            meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
+            (meta.resolved !== null &&
+                isArrayRecursive(visited)(array)(meta.resolved.returns)) ||
+            (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
+        );
+    };
+
+const isTupleRecursive =
+    (visited: Set<Metadata>) =>
+    (tuple: MetadataTuple) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+        visited.add(meta);
+
+        return (
+            meta.tuples.some(
+                (t) =>
+                    t === tuple ||
+                    t.elements.some((e) => isTupleRecursive(visited)(tuple)(e)),
+            ) ||
+            meta.arrays.some(
+                (a) =>
+                    !a.recursive && isTupleRecursive(visited)(tuple)(a.value),
+            ) ||
+            meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
+            meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
+            meta.aliases.some((d) =>
+                isTupleRecursive(visited)(tuple)(d.value),
+            ) ||
+            (meta.resolved !== null &&
+                isTupleRecursive(visited)(tuple)(meta.resolved.returns)) ||
+            (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
+        );
+    };
+
+const isObjectRecursive =
+    (visited: Set<Metadata>) =>
+    (obj: MetadataObject) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+
+        visited.add(meta);
+        return (
+            meta.objects.some(
+                (o) =>
+                    obj === o ||
+                    o.properties.some((prop) =>
+                        isObjectRecursive(visited)(obj)(prop.value),
+                    ),
+            ) ||
+            meta.aliases.some((alias) =>
+                isObjectRecursive(visited)(obj)(alias.value),
+            ) ||
+            meta.arrays.some(
+                (array) =>
+                    !array.recursive &&
+                    isObjectRecursive(visited)(obj)(array.value),
+            ) ||
+            meta.tuples.some(
+                (tuple) =>
+                    !tuple.recursive &&
+                    tuple.elements.some((elem) =>
+                        isObjectRecursive(visited)(obj)(elem),
+                    ),
+            ) ||
+            meta.maps.some((map) =>
+                isObjectRecursive(visited)(obj)(map.value),
+            ) ||
+            meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
+            (meta.resolved !== null &&
+                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
+            (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
+        );
+    };

package/src/factories/internal/metadata/iterate_metadata_tag.ts

@@ -1,31 +1,31 @@
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { Writable } from "../../../typings/Writable";
-
-import { Escaper } from "../../../utils/Escaper";
-
-import { MetadataTagFactory } from "../../MetadataTagFactory";
-
-export const iterate_metadata_tag = (obj: MetadataObject) => {
-    if (obj.tagged_ === true) return;
-    obj.tagged_ = true;
-
-    for (const prop of obj.properties) {
-        const key: string = prop.key.getName();
-        const variable: string | null =
-            key.length >= 3 &&
-            key[0] === '"' &&
-            key[key.length - 1] === '"' &&
-            Escaper.variable(key.slice(1, -1))
-                ? key.slice(1, -1)
-                : null;
-
-        Writable(prop).tags = MetadataTagFactory.generate(prop.value)(
-            prop.jsDocTags,
-        )(
-            variable !== null
-                ? () => `${obj.name}.${variable}`
-                : () => `${obj.name}[${key}]`,
-        );
-    }
-};
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { Writable } from "../../../typings/Writable";
+
+import { Escaper } from "../../../utils/Escaper";
+
+import { MetadataTagFactory } from "../../MetadataTagFactory";
+
+export const iterate_metadata_tag = (obj: MetadataObject) => {
+    if (obj.tagged_ === true) return;
+    obj.tagged_ = true;
+
+    for (const prop of obj.properties) {
+        const key: string = prop.key.getName();
+        const variable: string | null =
+            key.length >= 3 &&
+            key[0] === '"' &&
+            key[key.length - 1] === '"' &&
+            Escaper.variable(key.slice(1, -1))
+                ? key.slice(1, -1)
+                : null;
+
+        Writable(prop).tags = MetadataTagFactory.generate(prop.value)(
+            prop.jsDocTags,
+        )(
+            variable !== null
+                ? () => `${obj.name}.${variable}`
+                : () => `${obj.name}[${key}]`,
+        );
+    }
+};

package/src/metadata/MetadataObject.ts

@@ -1,129 +1,129 @@
-import { ClassProperties } from "../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataObject } from "./IMetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
-
-export class MetadataObject {
-    public readonly name: string;
-    public readonly properties: Array<MetadataProperty>;
-    public readonly description: string | undefined;
-    public readonly jsDocTags: IJsDocTagInfo[];
-
-    public readonly index: number;
-    public validated: boolean;
-    public recursive: boolean;
-    public nullables: boolean[] = [];
-
-    /**
-     * @internal
-     */
-    public tagged_: boolean = false;
-
-    /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-    /**
-     * @hidden
-     */
-    private constructor(
-        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
-    ) {
-        this.name = props.name;
-        this.properties = props.properties;
-        this.description = props.description;
-        this.jsDocTags = props.jsDocTags;
-
-        this.index = props.index;
-        this.validated = props.validated;
-        this.recursive = props.recursive;
-        this.nullables = [];
-
-        this.tagged_ = false;
-    }
-
-    /**
-     * @internal
-     */
-    public static create(
-        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
-    ) {
-        return new MetadataObject(props);
-    }
-
-    /**
-     * @internal
-     */
-    public static _From_without_properties(
-        obj: IMetadataObject,
-    ): MetadataObject {
-        return this.create({
-            name: obj.name,
-            properties: [],
-            description: obj.description,
-            jsDocTags: obj.jsDocTags,
-
-            index: obj.index,
-            validated: obj.validated,
-            recursive: obj.recursive,
-            nullables: obj.nullables.slice(),
-        });
-    }
-
-    /**
-     * @internal
-     */
-    public _Is_simple(level: number = 0): boolean {
-        return (
-            this.recursive === false &&
-            this.properties.length < 10 &&
-            this.properties.every(
-                (property) =>
-                    property.key.isSoleLiteral() &&
-                    property.value.size() === 1 &&
-                    property.value.required === true &&
-                    property.value.nullable === false &&
-                    (property.value.atomics.length === 1 ||
-                        (level < 1 &&
-                            property.value.objects.length === 1 &&
-                            property.value.objects[0]!._Is_simple(level + 1))),
-            )
-        );
-    }
-
-    public toJSON(): IMetadataObject {
-        return {
-            name: this.name,
-            properties: this.properties.map((property) => property.toJSON()),
-            description: this.description,
-            jsDocTags: this.jsDocTags,
-
-            index: this.index,
-            validated: this.validated,
-            recursive: this.recursive,
-            nullables: this.nullables.slice(),
-        };
-    }
-}
-
-/**
- * @internal
- */
-export namespace MetadataObject {
-    export const intersects = (x: MetadataObject, y: MetadataObject): boolean =>
-        x.properties.some(
-            (prop) =>
-                y.properties.find(
-                    (oppo) => prop.key.getName() === oppo.key.getName(),
-                ) !== undefined,
-        );
-
-    export const covers = (x: MetadataObject, y: MetadataObject): boolean =>
-        x.properties.length >= y.properties.length &&
-        x.properties.every(
-            (prop) =>
-                y.properties.find(
-                    (oppo) => prop.key.getName() === oppo.key.getName(),
-                ) !== undefined,
-        );
-}
+import { ClassProperties } from "../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataObject } from "./IMetadataObject";
+import { MetadataProperty } from "./MetadataProperty";
+
+export class MetadataObject {
+    public readonly name: string;
+    public readonly properties: Array<MetadataProperty>;
+    public readonly description: string | undefined;
+    public readonly jsDocTags: IJsDocTagInfo[];
+
+    public readonly index: number;
+    public validated: boolean;
+    public recursive: boolean;
+    public nullables: boolean[] = [];
+
+    /**
+     * @internal
+     */
+    public tagged_: boolean = false;
+
+    /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    private constructor(
+        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
+    ) {
+        this.name = props.name;
+        this.properties = props.properties;
+        this.description = props.description;
+        this.jsDocTags = props.jsDocTags;
+
+        this.index = props.index;
+        this.validated = props.validated;
+        this.recursive = props.recursive;
+        this.nullables = [];
+
+        this.tagged_ = false;
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
+    ) {
+        return new MetadataObject(props);
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_properties(
+        obj: IMetadataObject,
+    ): MetadataObject {
+        return this.create({
+            name: obj.name,
+            properties: [],
+            description: obj.description,
+            jsDocTags: obj.jsDocTags,
+
+            index: obj.index,
+            validated: obj.validated,
+            recursive: obj.recursive,
+            nullables: obj.nullables.slice(),
+        });
+    }
+
+    /**
+     * @internal
+     */
+    public _Is_simple(level: number = 0): boolean {
+        return (
+            this.recursive === false &&
+            this.properties.length < 10 &&
+            this.properties.every(
+                (property) =>
+                    property.key.isSoleLiteral() &&
+                    property.value.size() === 1 &&
+                    property.value.required === true &&
+                    property.value.nullable === false &&
+                    (property.value.atomics.length === 1 ||
+                        (level < 1 &&
+                            property.value.objects.length === 1 &&
+                            property.value.objects[0]!._Is_simple(level + 1))),
+            )
+        );
+    }
+
+    public toJSON(): IMetadataObject {
+        return {
+            name: this.name,
+            properties: this.properties.map((property) => property.toJSON()),
+            description: this.description,
+            jsDocTags: this.jsDocTags,
+
+            index: this.index,
+            validated: this.validated,
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}
+
+/**
+ * @internal
+ */
+export namespace MetadataObject {
+    export const intersects = (x: MetadataObject, y: MetadataObject): boolean =>
+        x.properties.some(
+            (prop) =>
+                y.properties.find(
+                    (oppo) => prop.key.getName() === oppo.key.getName(),
+                ) !== undefined,
+        );
+
+    export const covers = (x: MetadataObject, y: MetadataObject): boolean =>
+        x.properties.length >= y.properties.length &&
+        x.properties.every(
+            (prop) =>
+                y.properties.find(
+                    (oppo) => prop.key.getName() === oppo.key.getName(),
+                ) !== undefined,
+        );
+}