typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230824

package/src/schemas/metadata/Metadata.ts

@@ -1,19 +1,24 @@
-import { Atomic } from "../../typings/Atomic";
+import { $clone } from "../../functional/$clone";
+
 import { ClassProperties } from "../../typings/ClassProperties";
 import { Writable } from "../../typings/Writable";
 
 import { ArrayUtil } from "../../utils/ArrayUtil";
 
 import { IMetadata } from "./IMetadata";
+import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataCollection } from "./IMetadataCollection";
 import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 import { MetadataAlias } from "./MetadataAlias";
 import { MetadataArray } from "./MetadataArray";
+import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataObject } from "./MetadataObject";
 import { MetadataProperty } from "./MetadataProperty";
 import { MetadataTuple } from "./MetadataTuple";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 export class Metadata {
     public any: boolean;
@@ -23,7 +28,7 @@ export class Metadata {
     public functional: boolean;
 
     public escaped: MetadataEscaped | null;
-    public atomics: Atomic.Literal[];
+    public atomics: IMetadataAtomic[];
     public constants: MetadataConstant[];
     public templates: Metadata[][];
 
@@ -115,16 +120,22 @@ export class Metadata {
             nullable: this.nullable,
             functional: this.functional,
 
-            atomics: this.atomics.slice(),
-            constants: JSON.parse(JSON.stringify(this.constants)),
+            atomics: $clone(this.atomics),
+            constants: $clone(this.constants),
             templates: this.templates.map((tpl) =>
                 tpl.map((meta) => meta.toJSON()),
             ),
             escaped: this.escaped ? this.escaped.toJSON() : null,
 
             rest: this.rest ? this.rest.toJSON() : null,
-            arrays: this.arrays.map((array) => array.name),
-            tuples: this.tuples.map((tuple) => tuple.name),
+            arrays: this.arrays.map((array) => ({
+                name: array.type.name,
+                tags: $clone(array.tags),
+            })),
+            tuples: this.tuples.map((tuple) => ({
+                name: tuple.type.name,
+                tags: $clone(tuple.tags),
+            })),
             objects: this.objects.map((obj) => obj.name),
             aliases: this.aliases.map((alias) => alias.name),
 
@@ -157,13 +168,13 @@ export class Metadata {
             arrays: new Map(
                 collection.arrays.map((arr) => [
                     arr.name,
-                    MetadataArray._From_without_value(arr),
+                    MetadataArrayType._From_without_value(arr),
                 ]),
             ),
             tuples: new Map(
                 collection.tuples.map((tpl) => [
                     tpl.name,
-                    MetadataTuple._From_without_elements(tpl),
+                    MetadataTupleType._From_without_elements(tpl),
                 ]),
             ),
         };
@@ -204,8 +215,8 @@ export class Metadata {
             nullable: meta.nullable,
             functional: meta.functional,
 
-            constants: JSON.parse(JSON.stringify(meta.constants)),
-            atomics: meta.atomics.slice(),
+            constants: $clone(meta.constants),
+            atomics: $clone(meta.atomics),
             templates: meta.templates.map((tpl) =>
                 tpl.map((meta) => this._From(meta, dict)),
             ),
@@ -214,21 +225,27 @@ export class Metadata {
                 : null,
 
             rest: meta.rest ? this._From(meta.rest, dict) : null,
-            arrays: meta.arrays.map((id) => {
-                const array = dict.arrays.get(id);
-                if (array === undefined)
+            arrays: meta.arrays.map((ref) => {
+                const type = dict.arrays.get(ref.name);
+                if (type === undefined)
                     throw new Error(
-                        `Error on Metadata.from(): failed to find array "${id}".`,
+                        `Error on Metadata.from(): failed to find array "${ref.name}".`,
                     );
-                return array;
+                return MetadataArray.create({
+                    type,
+                    tags: $clone(ref.tags),
+                });
             }),
-            tuples: meta.tuples.map((id) => {
-                const tuple = dict.tuples.get(id);
-                if (tuple === undefined)
+            tuples: meta.tuples.map((t) => {
+                const type = dict.tuples.get(t.name);
+                if (type === undefined)
                     throw new Error(
-                        `Error on Metadata.from(): failed to find tuple "${id}".`,
+                        `Error on Metadata.from(): failed to find tuple "${t.name}".`,
                     );
-                return tuple;
+                return MetadataTuple.create({
+                    type,
+                    tags: $clone(t.tags),
+                });
             }),
             objects: meta.objects.map((name) => {
                 const found = dict.objects.get(name);
@@ -294,8 +311,8 @@ export class Metadata {
      */
     public binarySize(): number {
         return (
-            new Set([
-                ...this.atomics,
+            new Set<string>([
+                ...this.atomics.map((a) => a.type),
                 ...this.constants.map((c) => c.type),
                 ...(this.templates.length ? ["string"] : []),
             ]).size +
@@ -403,7 +420,7 @@ export namespace Metadata {
         //----
         // ATOMICS
         for (const atomic of x.atomics)
-            if (y.atomics.includes(atomic)) return true;
+            if (y.atomics.some((ya) => atomic.type === ya.type)) return true;
 
         // CONSTANTS
         for (const constant of x.constants) {
@@ -440,7 +457,7 @@ export namespace Metadata {
             for (const ya of y.arrays)
                 if (
                     !x.arrays.some((xa) =>
-                        covers(xa.value, ya.value, level + 1),
+                        covers(xa.type.value, ya.type.value, level + 1),
                     )
                 ) {
                     return false;
@@ -449,14 +466,15 @@ export namespace Metadata {
             // TUPLES
             for (const yt of y.tuples)
                 if (
-                    yt.elements.length !== 0 &&
+                    yt.type.elements.length !== 0 &&
                     x.tuples.some(
                         (xt) =>
-                            xt.elements.length >= yt.elements.length &&
-                            xt.elements
-                                .slice(yt.elements.length)
+                            xt.type.elements.length >=
+                                yt.type.elements.length &&
+                            xt.type.elements
+                                .slice(yt.type.elements.length)
                                 .every((xv, i) =>
-                                    covers(xv, yt.elements[i]!, level + 1),
+                                    covers(xv, yt.type.elements[i]!, level + 1),
                                 ),
                     ) === false
                 )
@@ -485,12 +503,16 @@ export namespace Metadata {
         // VALUES
         //----
         // ATOMICS
-        if (y.atomics.some((atomic) => x.atomics.includes(atomic) === false))
+        if (
+            y.atomics.some(
+                (ya) => x.atomics.some((xa) => xa.type === ya.type) === false,
+            )
+        )
             return false;
 
         // CONSTANTS
         for (const yc of y.constants) {
-            if (x.atomics.some((type) => yc.type === type)) continue;
+            if (x.atomics.some((atom) => yc.type === atom.type)) continue;
             const xc: MetadataConstant | undefined = x.constants.find(
                 (elem) => elem.type === yc.type,
             );
@@ -523,8 +545,7 @@ export namespace Metadata {
 
             escaped:
                 x.escaped !== null && y.escaped !== null
-                    ? //? merge(x.resolved, y.resolved)
-                      MetadataEscaped.create({
+                    ? MetadataEscaped.create({
                           original: merge(
                               x.escaped.original,
                               y.escaped.original,
@@ -532,7 +553,11 @@ export namespace Metadata {
                           returns: merge(x.escaped.returns, y.escaped.returns),
                       })
                     : x.escaped ?? y.escaped,
-            atomics: [...new Set([...x.atomics, ...y.atomics])],
+            atomics: mergeTaggedTypes({
+                container: x.atomics,
+                equals: (x, y) => x.type === y.type,
+                getter: (x) => x.tags,
+            })(y.atomics),
             constants: [...x.constants],
             templates: x.templates.slice(),
 
@@ -540,8 +565,17 @@ export namespace Metadata {
                 x.rest !== null && y.rest !== null
                     ? merge(x.rest, y.rest)
                     : x.rest ?? y.rest,
-            arrays: x.arrays.slice(),
-            tuples: x.tuples.slice(),
+            // arrays: x.arrays.slice(),
+            arrays: mergeTaggedTypes({
+                container: x.arrays,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.arrays),
+            tuples: mergeTaggedTypes({
+                container: x.tuples,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.tuples),
             objects: x.objects.slice(),
             aliases: x.aliases.slice(),
 
@@ -561,10 +595,6 @@ export namespace Metadata {
             for (const value of constant.values)
                 ArrayUtil.add(target.values, value);
         }
-        for (const array of y.arrays)
-            ArrayUtil.set(output.arrays, array, (elem) => elem.name);
-        for (const tuple of y.tuples)
-            ArrayUtil.set(output.tuples, tuple, (elem) => elem.name);
         for (const obj of y.objects)
             ArrayUtil.set(output.objects, obj, (elem) => elem.name);
         for (const alias of y.aliases)
@@ -584,8 +614,8 @@ const getName = (metadata: Metadata): string => {
     if (metadata.isRequired() === false) elements.push("undefined");
 
     // ATOMIC
-    for (const type of metadata.atomics) {
-        elements.push(type);
+    for (const atom of metadata.atomics) {
+        elements.push(atom.type);
     }
     for (const constant of metadata.constants)
         for (const value of constant.values)
@@ -613,8 +643,8 @@ const getName = (metadata: Metadata): string => {
 
     // INSTANCES
     if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
-    for (const tuple of metadata.tuples) elements.push(tuple.name);
-    for (const array of metadata.arrays) elements.push(array.name);
+    for (const tuple of metadata.tuples) elements.push(tuple.type.name);
+    for (const array of metadata.arrays) elements.push(array.type.name);
     for (const object of metadata.objects) elements.push(object.name);
     for (const alias of metadata.aliases) elements.push(alias.name);
     if (metadata.escaped !== null) elements.push(metadata.escaped.getName());
@@ -632,3 +662,38 @@ export namespace Metadata {
         value: Metadata;
     }
 }
+
+const mergeTaggedTypes =
+    <T>(props: {
+        container: T[];
+        equals: (x: T, y: T) => boolean;
+        getter: (x: T) => IMetadataTypeTag[][];
+    }) =>
+    (opposite: T[]) => {
+        const output: T[] = [...props.container];
+        for (const elem of opposite) {
+            const equal = props.container.find((x) => props.equals(x, elem));
+            if (equal === undefined) {
+                output.push(elem);
+                continue;
+            }
+
+            const matrix: string[][] = props
+                .getter(equal)
+                .map((tags) => tags.map((t) => t.name))
+                .sort();
+            for (const tags of props.getter(elem)) {
+                const names: string[] = tags.map((t) => t.name).sort();
+                if (
+                    matrix.some(
+                        (m) =>
+                            m.length === names.length &&
+                            m.every((s, i) => s === names[i]),
+                    )
+                )
+                    continue;
+                props.getter(equal).push(tags);
+            }
+        }
+        return output;
+    };

package/src/schemas/metadata/MetadataAlias.ts

@@ -2,14 +2,14 @@ import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataTag } from "./IMetadataTag";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 import { Metadata } from "./Metadata";
 
 export class MetadataAlias {
     public readonly name: string;
     public readonly value: Metadata;
     public readonly description: string | null;
-    public readonly tags: IMetadataTag[];
+    public readonly tags: IMetadataCommentTag[];
     public readonly jsDocTags: IJsDocTagInfo[];
     public readonly recursive: boolean;
     public readonly nullables: boolean[];

package/src/schemas/metadata/MetadataArray.ts

@@ -1,55 +1,31 @@
+import { $clone } from "../../functional/$clone";
+
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IMetadataArray } from "./IMetadataArray";
-import { Metadata } from "./Metadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataArrayType } from "./MetadataArrayType";
 
 export class MetadataArray {
-    public readonly name: string;
-    public readonly value: Metadata;
-    public readonly nullables: boolean[];
-    public readonly recursive: boolean;
-    public readonly index: number | null;
+    public readonly type: MetadataArrayType;
+    public readonly tags: IMetadataTypeTag[][];
 
     /**
      * @hidden
      */
     private constructor(props: ClassProperties<MetadataArray>) {
-        this.name = props.name;
-        this.value = props.value;
-        this.index = props.index;
-        this.recursive = props.recursive;
-        this.nullables = props.nullables;
+        this.type = props.type;
+        this.tags = props.tags;
     }
 
-    /**
-     * @internal
-     */
-    public static _From_without_value(
-        props: Omit<IMetadataArray, "value">,
-    ): MetadataArray {
-        return this.create({
-            name: props.name,
-            value: null!,
-            index: props.index,
-            recursive: props.recursive,
-            nullables: props.nullables,
-        });
-    }
-
-    /**
-     * @internal
-     */
     public static create(props: ClassProperties<MetadataArray>): MetadataArray {
         return new MetadataArray(props);
     }
 
     public toJSON(): IMetadataArray {
         return {
-            name: this.name,
-            value: this.value.toJSON(),
-            nullables: this.nullables,
-            recursive: this.recursive,
-            index: this.index,
+            type: this.type.toJSON(),
+            tags: $clone(this.tags),
         };
     }
 }

package/src/schemas/metadata/MetadataArrayType.ts

@@ -0,0 +1,57 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { Metadata } from "./Metadata";
+
+export class MetadataArrayType {
+    public readonly name: string;
+    public readonly value: Metadata;
+    public readonly nullables: boolean[];
+    public readonly recursive: boolean;
+    public readonly index: number | null;
+
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataArrayType>) {
+        this.name = props.name;
+        this.value = props.value;
+        this.index = props.index;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_value(
+        props: Omit<IMetadataArrayType, "value">,
+    ): MetadataArrayType {
+        return this.create({
+            name: props.name,
+            value: null!,
+            index: props.index,
+            recursive: props.recursive,
+            nullables: props.nullables,
+        });
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: ClassProperties<MetadataArrayType>,
+    ): MetadataArrayType {
+        return new MetadataArrayType(props);
+    }
+
+    public toJSON(): IMetadataArrayType {
+        return {
+            name: this.name,
+            value: this.value.toJSON(),
+            nullables: this.nullables,
+            recursive: this.recursive,
+            index: this.index,
+        };
+    }
+}

package/src/schemas/metadata/MetadataProperty.ts

@@ -1,16 +1,16 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 import { IMetadataDictionary } from "./IMetadataDictionary";
 import { IMetadataProperty } from "./IMetadataProperty";
-import { IMetadataTag } from "./IMetadataTag";
 import { Metadata } from "./Metadata";
 
 export class MetadataProperty {
     public readonly key: Metadata;
     public readonly value: Metadata;
     public readonly description: string | null;
-    public readonly tags: IMetadataTag[];
+    public readonly tags: IMetadataCommentTag[];
     public readonly jsDocTags: IJsDocTagInfo[];
 
     /* -----------------------------------------------------------

package/src/schemas/metadata/MetadataTuple.ts

@@ -1,45 +1,21 @@
+import { $clone } from "../../functional/$clone";
+
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IMetadataTuple } from "./IMetadataTuple";
-import { Metadata } from "./Metadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 export class MetadataTuple {
-    public readonly name: string;
-    public readonly elements: Metadata[];
-
-    public readonly index: number | null;
-    public readonly recursive: boolean;
-    public readonly nullables: boolean[];
-
-    /**
-     * @internal
-     */
-    public of_map?: boolean;
+    public readonly type: MetadataTupleType;
+    public readonly tags: IMetadataTypeTag[][];
 
     /**
      * @internal
      */
     private constructor(props: ClassProperties<MetadataTuple>) {
-        this.name = props.name;
-        this.elements = props.elements;
-        this.index = props.index;
-        this.recursive = props.recursive;
-        this.nullables = props.nullables;
-    }
-
-    /**
-     * @internal
-     */
-    public static _From_without_elements(
-        props: Omit<IMetadataTuple, "elements">,
-    ): MetadataTuple {
-        return this.create({
-            name: props.name,
-            index: props.index,
-            elements: null!,
-            recursive: props.recursive,
-            nullables: props.nullables.slice(),
-        });
+        this.type = props.type;
+        this.tags = props.tags;
     }
 
     public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
@@ -48,11 +24,8 @@ export class MetadataTuple {
 
     public toJSON(): IMetadataTuple {
         return {
-            name: this.name,
-            index: this.index,
-            elements: this.elements.map((elem) => elem.toJSON()),
-            recursive: this.recursive,
-            nullables: this.nullables.slice(),
+            type: this.type.toJSON(),
+            tags: $clone(this.tags),
         };
     }
 }

package/src/schemas/metadata/MetadataTupleType.ts

@@ -0,0 +1,67 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTupleType } from "./IMetadataTupleType";
+import { Metadata } from "./Metadata";
+
+export class MetadataTupleType {
+    public readonly name: string;
+    public readonly elements: Metadata[];
+
+    public readonly index: number | null;
+    public readonly recursive: boolean;
+    public readonly nullables: boolean[];
+
+    /**
+     * @internal
+     */
+    public of_map?: boolean;
+
+    /**
+     * @internal
+     */
+    private constructor(props: ClassProperties<MetadataTupleType>) {
+        this.name = props.name;
+        this.elements = props.elements;
+        this.index = props.index;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_elements(
+        props: Omit<IMetadataTupleType, "elements">,
+    ): MetadataTupleType {
+        return this.create({
+            name: props.name,
+            index: props.index,
+            elements: null!,
+            recursive: props.recursive,
+            nullables: props.nullables.slice(),
+        });
+    }
+
+    public static create(
+        props: ClassProperties<MetadataTupleType>,
+    ): MetadataTupleType {
+        return new MetadataTupleType(props);
+    }
+
+    public isRest(): boolean {
+        return (
+            this.elements.length > 0 &&
+            this.elements[this.elements.length - 1]!.rest !== null
+        );
+    }
+
+    public toJSON(): IMetadataTupleType {
+        return {
+            name: this.name,
+            index: this.index,
+            elements: this.elements.map((elem) => elem.toJSON()),
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}

package/src/tags/ExclusiveMaximum.ts

@@ -0,0 +1,8 @@
+export type ExclusiveMaximum<Fixed extends number | bigint> = {
+    "typia.tag"?: {
+        target: Fixed extends number ? "number" : "bigint";
+        kind: "exclusiveMaximum";
+        value: Fixed;
+        validate?: `$input < ${Fixed}`;
+    };
+};

package/src/tags/ExclusiveMinimum.ts

@@ -0,0 +1,8 @@
+export type ExclusiveMinimum<Fixed extends number | bigint> = {
+    "typia.tag"?: {
+        target: Fixed extends number ? "number" : "bigint";
+        kind: "exclusiveMinimum";
+        value: Fixed;
+        validate?: `${Fixed} < $input`;
+    };
+};

package/src/tags/Format.ts

@@ -0,0 +1,29 @@
+export type Format<
+    Value extends
+        | "email"
+        | "uuid"
+        | "ipv4"
+        | "ipv6"
+        | "url"
+        | "date"
+        | "date-time",
+> = {
+    "typia.tag"?: {
+        target: "string";
+        kind: "format";
+        value: Value;
+        validate: Value extends "email"
+            ? `/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i.test($input)`
+            : Value extends "uuid"
+            ? `/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i.test($input)`
+            : Value extends "ipv4"
+            ? `/^(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test($input)`
+            : Value extends "ipv6"
+            ? `/^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/.test($input)`
+            : Value extends "url"
+            ? `/^[a-zA-Z0-9]+:\/\/(?:www.)?[-a-zA-Z0-9@:%._+~#=]{1,256}.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/.test($input)`
+            : Value extends "date"
+            ? `/^(\d{4})-(\d{2})-(\d{2})$/.test($input)`
+            : `!isNaN(new Date($input).getTime())`;
+    };
+};

package/src/tags/MaxItems.ts

@@ -0,0 +1,8 @@
+export type MaxItems<Size extends number> = {
+    "typia.tag"?: {
+        target: "array";
+        kind: "maxItems";
+        value: Size;
+        validate: `$input.length <= ${Size}`;
+    };
+};

package/src/tags/MaxLength.ts

@@ -0,0 +1,8 @@
+export type MaxLength<Fixed extends number> = {
+    "typia.tag"?: {
+        target: "array";
+        kind: "maxLength";
+        value: number;
+        validate: `$input.length <= ${Fixed}`;
+    };
+};