typia 3.6.0 → 3.6.2

package/lib/transformers/internal/GenericTransformer.js

@@ -0,0 +1,72 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericTransformer = void 0;
+var typescript_1 = __importDefault(require("typescript"));
+var GenericTransformer;
+(function (GenericTransformer) {
+    GenericTransformer.scalar = function (method) {
+        return function (programmer) {
+            return function (project, modulo, expression) {
+                if (expression.arguments.length !== 1)
+                    throw new Error("Error on typia.".concat(method, "(): no input value."));
+                var _a = __read(expression.typeArguments && expression.typeArguments[0]
+                    ? [
+                        project.checker.getTypeFromTypeNode(expression.typeArguments[0]),
+                        expression.typeArguments[0],
+                        true,
+                    ]
+                    : [
+                        project.checker.getTypeAtLocation(expression.arguments[0]),
+                        expression.arguments[0],
+                        false,
+                    ], 3), type = _a[0], node = _a[1], generic = _a[2];
+                if (type.isTypeParameter())
+                    throw new Error("Error on typia.".concat(method, "(): non-specified generic argument."));
+                return typescript_1.default.factory.createCallExpression(programmer(project, modulo)(type, generic
+                    ? node.getText()
+                    : name(project.checker)(type)(node)), undefined, [expression.arguments[0]]);
+            };
+        };
+    };
+    GenericTransformer.factory = function (method) {
+        return function (programmer) {
+            return function (project, modulo, expression) {
+                var _a;
+                if (!((_a = expression.typeArguments) === null || _a === void 0 ? void 0 : _a[0]))
+                    throw new Error("Error on typia.".concat(method, "(): generic argument is not specified."));
+                var node = expression.typeArguments[0];
+                var type = project.checker.getTypeFromTypeNode(node);
+                if (type.isTypeParameter())
+                    throw new Error("Error on typia.".concat(method, "(): non-specified generic argument."));
+                return programmer(project, modulo)(type, node.getText());
+            };
+        };
+    };
+    var name = function (checker) {
+        return function (type) {
+            return function (node) {
+                return checker.typeToString(type, node, typescript_1.default.TypeFormatFlags.NodeBuilderFlagsMask);
+            };
+        };
+    };
+})(GenericTransformer = exports.GenericTransformer || (exports.GenericTransformer = {}));
+//# sourceMappingURL=GenericTransformer.js.map

package/lib/transformers/internal/GenericTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenericTransformer.js","sourceRoot":"","sources":["../../../src/transformers/internal/GenericTransformer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,0DAA4B;AAI5B,IAAiB,kBAAkB,CA8FlC;AA9FD,WAAiB,kBAAkB;IAClB,yBAAM,GACf,UAAC,MAAc;QACf,OAAA,UACI,UAGsD;YAE1D,OAAA,UACI,OAAiB,EACjB,MAAiC,EACjC,UAA6B;gBAG7B,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;oBACjC,MAAM,IAAI,KAAK,CAAC,yBAAkB,MAAM,wBAAqB,CAAC,CAAC;gBAG7D,IAAA,KAAA,OACF,UAAU,CAAC,aAAa,IAAI,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;oBACnD,CAAC,CAAC;wBACI,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAC/B,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAC9B;wBACD,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;wBAC3B,IAAI;qBACP;oBACH,CAAC,CAAC;wBACI,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAC7B,UAAU,CAAC,SAAS,CAAC,CAAC,CAAE,CAC3B;wBACD,UAAU,CAAC,SAAS,CAAC,CAAC,CAAE;wBACxB,KAAK;qBACR,IAAA,EAfJ,IAAI,QAAA,EAAE,IAAI,QAAA,EAAE,OAAO,QAef,CAAC;gBACZ,IAAI,IAAI,CAAC,eAAe,EAAE;oBACtB,MAAM,IAAI,KAAK,CACX,yBAAkB,MAAM,wCAAqC,CAChE,CAAC;gBAGN,OAAO,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAClC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CACvB,IAAI,EACJ,OAAO;oBACH,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE;oBAChB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAC1C,EACD,SAAS,EACT,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAE,CAAC,CAC7B,CAAC;YACN,CAAC;QA1CD,CA0CC;IAhDD,CAgDC,CAAC;IAEO,0BAAO,GAChB,UAAC,MAAc;QACf,OAAA,UACI,UAGsD;YAE1D,OAAA,UACI,OAAiB,EACjB,MAAiC,EACjC,UAA6B;;gBAG7B,IAAI,CAAC,CAAA,MAAA,UAAU,CAAC,aAAa,0CAAG,CAAC,CAAC,CAAA;oBAC9B,MAAM,IAAI,KAAK,CACX,yBAAkB,MAAM,2CAAwC,CACnE,CAAC;gBAGN,IAAM,IAAI,GAAgB,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;gBACtD,IAAM,IAAI,GAAY,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;gBAEhE,IAAI,IAAI,CAAC,eAAe,EAAE;oBACtB,MAAM,IAAI,KAAK,CACX,yBAAkB,MAAM,wCAAqC,CAChE,CAAC;gBAGN,OAAO,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;YAC7D,CAAC;QAtBD,CAsBC;IA5BD,CA4BC,CAAC;IAEN,IAAM,IAAI,GACN,UAAC,OAAuB;QACxB,OAAA,UAAC,IAAa;YACd,OAAA,UAAC,IAAa;gBACV,OAAA,OAAO,CAAC,YAAY,CAChB,IAAI,EACJ,IAAI,EACJ,oBAAE,CAAC,eAAe,CAAC,oBAAoB,CAC1C;YAJD,CAIC;QALL,CAKK;IANL,CAMK,CAAC;AACd,CAAC,EA9FgB,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QA8FlC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -18,6 +18,7 @@
     "eslint": "eslint ./**/*.ts",
     "eslint:fix": "eslint ./**/*.ts --fix",
     "issue": "node test/issue",
+    "issue:generate": "ts-node src/executable/typia generate --input test/issues/input --output test/issues/output --project test/tsconfig.json",
     "package:latest": "ts-node build/publish.ts latest",
     "package:next": "ts-node build/publish.ts next",
     "package:deprecate": "npm deprecate typescript-json \"Renamed to typia\"",

package/src/programmers/AssertCloneProgrammer.ts

@@ -12,7 +12,7 @@ import { CloneProgrammer } from "./CloneProgrammer";
 export namespace AssertCloneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -23,16 +23,15 @@ export namespace AssertCloneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type),
+                        AssertProgrammer.generate(project, modulo)(type, name),
                     ),
                     StatementFactory.constant(
                         "clone",
@@ -46,7 +45,7 @@ export namespace AssertCloneProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createCallExpression(

package/src/programmers/AssertParseProgrammer.ts

@@ -11,7 +11,7 @@ import { AssertProgrammer } from "./AssertProgrammer";
 export namespace AssertParseProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -22,10 +22,9 @@ export namespace AssertParseProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
@@ -41,7 +40,7 @@ export namespace AssertParseProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/AssertProgrammer.ts

@@ -19,7 +19,7 @@ export namespace AssertProgrammer {
             modulo: ts.LeftHandSideExpression,
             equals: boolean = false,
         ) =>
-        (type: ts.Type) => {
+        (type: ts.Type, name?: string) => {
             const importer: FunctionImporter = new FunctionImporter();
             const program: ts.ArrowFunction = CheckerProgrammer.generate(
                 project,
@@ -35,7 +35,7 @@ export namespace AssertProgrammer {
                     success: ts.factory.createTrue(),
                 },
                 importer,
-            )(type);
+            )(type, name);
 
             return ts.factory.createArrowFunction(
                 undefined,
@@ -47,7 +47,7 @@ export namespace AssertProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
                 undefined,
                 ts.factory.createBlock(

package/src/programmers/AssertPruneProgrammer.ts

@@ -12,7 +12,7 @@ import { PruneProgrammer } from "./PruneProgrammer";
 export namespace AssertPruneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -23,13 +23,13 @@ export namespace AssertPruneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type),
+                        AssertProgrammer.generate(project, modulo)(type, name),
                     ),
                     StatementFactory.constant(
                         "prune",
@@ -43,7 +43,7 @@ export namespace AssertPruneProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createCallExpression(

package/src/programmers/AssertStringifyProgrammer.ts

@@ -12,7 +12,7 @@ import { StringifyProgrammer } from "./StringifyProgrammer";
 export namespace AssertStringifyProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -37,7 +37,7 @@ export namespace AssertStringifyProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     StatementFactory.constant(
                         "stringify",
@@ -51,7 +51,7 @@ export namespace AssertStringifyProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createReturnStatement(
                         ts.factory.createCallExpression(

package/src/programmers/CheckerProgrammer.ts

@@ -128,12 +128,13 @@ export namespace CheckerProgrammer {
         const output: FeatureProgrammer.IConfig = {
             types: {
                 input: () => TypeFactory.keyword("any"),
-                output: (type) =>
+                output: (type, name) =>
                     ts.factory.createTypePredicateNode(
                         undefined,
                         "input",
                         ts.factory.createTypeReferenceNode(
-                            TypeFactory.getFullName(project.checker, type),
+                            name ??
+                                TypeFactory.getFullName(project.checker, type),
                         ),
                     ),
             },

package/src/programmers/CloneProgrammer.ts

@@ -312,16 +312,15 @@ export namespace CloneProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
         types: {
-            input: (type) =>
+            input: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
-            output: (type) =>
+            output: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
         },
         functors: FUNCTORS,

package/src/programmers/FeatureProgrammer.ts

@@ -70,8 +70,8 @@ export namespace FeatureProgrammer {
     }
     export namespace IConfig {
         export interface ITypes {
-            input: (type: ts.Type, node?: ts.TypeNode) => ts.TypeNode;
-            output: (type: ts.Type, node?: ts.TypeNode) => ts.TypeNode;
+            input: (type: ts.Type, name?: string) => ts.TypeNode;
+            output: (type: ts.Type, name?: string) => ts.TypeNode;
         }
 
         export interface IObjector {
@@ -227,7 +227,7 @@ export namespace FeatureProgrammer {
                 collection: MetadataCollection,
             ) => ts.Statement[] | undefined,
         ) =>
-        (type: ts.Type, typeNode?: ts.TypeNode) => {
+        (type: ts.Type, name?: string) => {
             const [collection, meta] = config.initializer(project, type);
 
             // ITERATE OVER ALL METADATA
@@ -257,10 +257,10 @@ export namespace FeatureProgrammer {
             return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                PARAMETERS(config)(config.types.input(type, typeNode))(
+                PARAMETERS(config)(config.types.input(type, name))(
                     ValueFactory.INPUT(),
                 ),
-                config.types.output(type, typeNode),
+                config.types.output(type, name),
                 undefined,
                 ts.factory.createBlock(
                     [

package/src/programmers/IsCloneProgrammer.ts

@@ -12,7 +12,7 @@ import { IsProgrammer } from "./IsProgrammer";
 export namespace IsCloneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -24,10 +24,10 @@ export namespace IsCloneProgrammer {
                 ],
                 ts.factory.createUnionTypeNode([
                     ts.factory.createTypeReferenceNode(
-                        `typia.Primitive<${TypeFactory.getFullName(
-                            project.checker,
-                            type,
-                        )}>`,
+                        `typia.Primitive<${
+                            name ??
+                            TypeFactory.getFullName(project.checker, type)
+                        }>`,
                     ),
                     ts.factory.createLiteralTypeNode(ts.factory.createNull()),
                 ]),
@@ -35,7 +35,7 @@ export namespace IsCloneProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(project, modulo)(type),
+                        IsProgrammer.generate(project, modulo)(type, name),
                     ),
                     StatementFactory.constant(
                         "clone",
@@ -49,7 +49,7 @@ export namespace IsCloneProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createIfStatement(
                         ts.factory.createPrefixUnaryExpression(

package/src/programmers/IsParseProgrammer.ts

@@ -11,7 +11,7 @@ import { IsProgrammer } from "./IsProgrammer";
 export namespace IsParseProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -22,10 +22,9 @@ export namespace IsParseProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
@@ -41,7 +40,7 @@ export namespace IsParseProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/IsPruneProgrammer.ts

@@ -12,7 +12,7 @@ import { PruneProgrammer } from "./PruneProgrammer";
 export namespace IsPruneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -26,14 +26,14 @@ export namespace IsPruneProgrammer {
                     undefined,
                     "input",
                     ts.factory.createTypeReferenceNode(
-                        TypeFactory.getFullName(project.checker, type),
+                        name ?? TypeFactory.getFullName(project.checker, type),
                     ),
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(project, modulo)(type),
+                        IsProgrammer.generate(project, modulo)(type, name),
                     ),
                     StatementFactory.constant(
                         "prune",
@@ -47,7 +47,7 @@ export namespace IsPruneProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createIfStatement(
                         ts.factory.createPrefixUnaryExpression(

package/src/programmers/IsStringifyProgrammer.ts

@@ -12,7 +12,7 @@ import { StringifyProgrammer } from "./StringifyProgrammer";
 export namespace IsStringifyProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -20,7 +20,8 @@ export namespace IsStringifyProgrammer {
                     IdentifierFactory.parameter(
                         "input",
                         ts.factory.createTypeReferenceNode(
-                            TypeFactory.getFullName(project.checker, type),
+                            name ??
+                                TypeFactory.getFullName(project.checker, type),
                         ),
                     ),
                 ],
@@ -42,7 +43,7 @@ export namespace IsStringifyProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     StatementFactory.constant(
                         "stringify",
@@ -56,7 +57,7 @@ export namespace IsStringifyProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createReturnStatement(
                         ts.factory.createConditionalExpression(

package/src/programmers/PruneProgrammer.ts

@@ -272,9 +272,9 @@ export namespace PruneProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
         types: {
-            input: (type) =>
+            input: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
             output: () => TypeFactory.keyword("void"),
         },

package/src/programmers/RandomProgrammer.ts

@@ -23,7 +23,7 @@ export namespace RandomProgrammer {
         modulo: ts.LeftHandSideExpression,
     ) {
         const importer: FunctionImporter = new FunctionImporter();
-        return (type: ts.Type) => {
+        return (type: ts.Type, name?: string) => {
             // INITIALIZE METADATA
             const collection: MetadataCollection = new MetadataCollection();
             const meta: Metadata = MetadataFactory.generate(
@@ -65,10 +65,9 @@ export namespace RandomProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock(

package/src/programmers/StringifyProgrammer.ts

@@ -708,9 +708,9 @@ export namespace StringifyProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
         types: {
-            input: (type) =>
+            input: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
             output: () => TypeFactory.keyword("string"),
         },

package/src/programmers/ValidateCloneProgrammer.ts

@@ -12,7 +12,7 @@ import { ValidateProgrammer } from "./ValidateProgrammer";
 export namespace ValidateCloneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -23,10 +23,9 @@ export namespace ValidateCloneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>>`,
+                    `typia.IValidation<typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
@@ -42,7 +41,7 @@ export namespace ValidateCloneProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     StatementFactory.constant(
                         "clone",
@@ -56,7 +55,7 @@ export namespace ValidateCloneProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     StatementFactory.constant(
                         "output",

package/src/programmers/ValidateParseProgrammer.ts

@@ -11,7 +11,7 @@ import { ValidateProgrammer } from "./ValidateProgrammer";
 export namespace ValidateParseProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -22,10 +22,9 @@ export namespace ValidateParseProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>>`,
+                    `typia.IValidation<typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
@@ -41,7 +40,7 @@ export namespace ValidateParseProgrammer {
                                 },
                             },
                             modulo,
-                        )(type),
+                        )(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/ValidateProgrammer.ts

@@ -20,7 +20,7 @@ export namespace ValidateProgrammer {
             modulo: ts.LeftHandSideExpression,
             equals: boolean = false,
         ) =>
-        (type: ts.Type) => {
+        (type: ts.Type, name?: string) => {
             const importer: FunctionImporter = new FunctionImporter();
             const program: ts.ArrowFunction = CheckerProgrammer.generate(
                 project,
@@ -36,7 +36,7 @@ export namespace ValidateProgrammer {
                     success: ts.factory.createTrue(),
                 },
                 importer,
-            )(type);
+            )(type, name);
 
             return ts.factory.createArrowFunction(
                 undefined,
@@ -48,10 +48,9 @@ export namespace ValidateProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.IValidation<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock(