@nestia/sdk 12.0.0-dev.20260612.2 → 12.0.0-dev.20260619.1

package/lib/transform.js

@@ -3,48 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTtscPlugin = createTtscPlugin;
+exports.default = createTtscPlugin;
+const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
-const node_url_1 = require("node:url");
-const filename = currentFilename();
-const dirname = node_path_1.default.dirname(filename);
 /**
  * `@nestia/sdk` ttsc plugin descriptor.
  *
  * Points ttsc at this package's own Go source (`native/sdk`, package `sdk`).
  * Because that package is not `package main`, ttsc classifies it as a linked
  * transform and statically links it into the `@nestia/core` host binary as a
- * contributor — but only for projects that actually depend on `@nestia/sdk`.
- * A project depending on `@nestia/core` alone never links, compiles, or ships
- * any of this SDK transform code.
+ * contributor — but only for projects that actually depend on `@nestia/sdk`. A
+ * project depending on `@nestia/core` alone never links, compiles, or ships any
+ * of this SDK transform code.
  */
-function createTtscPlugin() {
-    // `<root>/lib/transform.js` (published) or `<root>/src/transform.ts` (dev)
-    // → `<root>` → the `native/sdk` linked-transform source package.
-    const root = node_path_1.default.resolve(dirname, "..");
+function createTtscPlugin(context) {
+    const requireFrom = (0, node_module_1.createRequire)(node_path_1.default.join(context.projectRoot, "package.json"));
+    const root = node_path_1.default.dirname(requireFrom.resolve("@nestia/sdk/package.json"));
     return {
         name: "@nestia/sdk",
         source: node_path_1.default.resolve(root, "native", "sdk"),
     };
 }
-exports.default = createTtscPlugin;
-function currentFilename() {
-    var _a;
-    var _b, _c;
-    if (typeof __filename === "string" &&
-        __filename !== "[stdin]" &&
-        __filename.length !== 0)
-        return normalizeFilename(__filename);
-    const line = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split("\n").find((entry) => entry.includes("/src/transform.ts") ||
-        entry.includes("/lib/transform.js") ||
-        entry.includes("/lib/transform.mjs"));
-    const matched = line === null || line === void 0 ? void 0 : line.match(/\(([^()]+):\d+:\d+\)|at ([^\s()]+):\d+:\d+/);
-    const fallback = typeof __filename === "string" ? __filename : "";
-    return normalizeFilename((_c = (_b = matched === null || matched === void 0 ? void 0 : matched[1]) !== null && _b !== void 0 ? _b : matched === null || matched === void 0 ? void 0 : matched[2]) !== null && _c !== void 0 ? _c : fallback);
-}
-function normalizeFilename(value) {
-    if (value.startsWith("file:"))
-        return (0, node_url_1.fileURLToPath)(value);
-    return value;
-}
 //# sourceMappingURL=transform.js.map

package/lib/transform.js.map

@@ -1 +1 @@
-{"version":3,"file":"transform.js","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAC7B,uCAAyC;AAOzC,MAAM,QAAQ,GAAW,eAAe,EAAE,CAAC;AAC3C,MAAM,OAAO,GAAW,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE/C;;;;;;;;;GASG;AACH;IACE,2EAA2E;IAC3E,iEAAiE;IACjE,MAAM,IAAI,GAAW,mBAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACjD,OAAO;QACL,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,mBAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC;KAC5C,CAAC;AACJ,CAAC;kBACc,gBAAgB;AAE/B,SAAS,eAAe;;;IACtB,IACE,OAAO,UAAU,KAAK,QAAQ;QAC9B,UAAU,KAAK,SAAS;QACxB,UAAU,CAAC,MAAM,KAAK,CAAC;QAEvB,OAAO,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAEvC,MAAM,IAAI,GAAuB,MAAA,IAAI,KAAK,EAAE,CAAC,KAAK,0CAC9C,KAAK,CAAC,IAAI,EACX,IAAI,CACH,CAAC,KAAK,EAAE,EAAE,CACR,KAAK,CAAC,QAAQ,CAAC,mBAAmB,CAAC;QACnC,KAAK,CAAC,QAAQ,CAAC,mBAAmB,CAAC;QACnC,KAAK,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CACvC,CAAC;IACJ,MAAM,OAAO,GAAwC,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,KAAK,CAC9D,4CAA4C,CAC7C,CAAC;IACF,MAAM,QAAQ,GAAW,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1E,OAAO,iBAAiB,aAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAG,CAAC,CAAC,mCAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAG,CAAC,CAAC,mCAAI,QAAQ,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAa;IACtC,IAAI,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC;QAAE,OAAO,IAAA,wBAAa,EAAC,KAAK,CAAC,CAAC;IAC3D,OAAO,KAAK,CAAC;AACf,CAAC"}
+{"version":3,"file":"transform.js","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAG7B;;;;;;;;;GASG;AACH,0BACE,OAAkC;IAElC,MAAM,WAAW,GAAG,IAAA,2BAAa,EAC/B,mBAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,cAAc,CAAC,CAC/C,CAAC;IACF,MAAM,IAAI,GAAW,mBAAI,CAAC,OAAO,CAC/B,WAAW,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAChD,CAAC;IACF,OAAO;QACL,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,mBAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC;KAC5C,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/sdk",
-  "version": "12.0.0-dev.20260612.2",
+  "version": "12.0.0-dev.20260619.1",
   "description": "Nestia SDK and Swagger generator",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -46,31 +46,31 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@typia/interface": "13.0.0-dev.20260612.1",
-    "@typia/utils": "13.0.0-dev.20260612.1",
+    "@ttsc/factory": "^0.16.2",
+    "@typia/interface": "13.0.0-dev.20260619.1",
+    "@typia/utils": "13.0.0-dev.20260619.1",
     "get-function-location": "^2.0.0",
     "glob": "^11.0.3",
     "path-to-regexp": "^6.2.1",
     "prettier": "^3.8.1",
     "tgrid": "^1.2.1",
-    "ttsc": "^0.15.3",
+    "ttsc": "^0.16.2",
     "tstl": "^3.0.0",
-    "typia": "13.0.0-dev.20260612.1",
-    "@nestia/factory": "^12.0.0-dev.20260612.2",
-    "@nestia/core": "^12.0.0-dev.20260612.2",
-    "@nestia/fetcher": "^12.0.0-dev.20260612.2"
+    "typia": "13.0.0-dev.20260619.1",
+    "@nestia/core": "^12.0.0-dev.20260619.1",
+    "@nestia/fetcher": "^12.0.0-dev.20260619.1"
   },
   "peerDependencies": {
-    "@nestia/core": "^12.0.0-dev.20260612.2"
+    "@nestia/core": "^12.0.0-dev.20260619.1"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.18.0",
     "@nestjs/common": "^11.1.6",
     "@nestjs/core": "^11.1.6",
-    "@typescript/native-preview": "7.0.0-dev.20260518.1",
     "@types/express": "^4.17.15",
     "@types/node": "^25.3.3",
-    "rimraf": "^6.1.3"
+    "rimraf": "^6.1.3",
+    "typescript": "7.0.1-rc"
   },
   "files": [
     "assets",

package/src/factories/ExpressionFactory.ts

@@ -0,0 +1,23 @@
+import {
+  type NumericLiteral,
+  type PrefixUnaryExpression,
+  SyntaxKind,
+  factory,
+} from "@ttsc/factory";
+
+/**
+ * Numeric-literal helper that handles negative values via a leading
+ * `MinusToken` prefix unary, matching how the TypeScript factory itself emits
+ * negative numeric literals.
+ */
+export namespace ExpressionFactory {
+  export const number = (
+    value: number,
+  ): NumericLiteral | PrefixUnaryExpression =>
+    value < 0
+      ? factory.createPrefixUnaryExpression(
+          SyntaxKind.MinusToken,
+          factory.createNumericLiteral(Math.abs(value)),
+        )
+      : factory.createNumericLiteral(value);
+}

package/src/factories/IdentifierFactory.ts

@@ -0,0 +1,84 @@
+import {
+  type Expression,
+  type Identifier,
+  type ParameterDeclaration,
+  type StringLiteral,
+  SyntaxKind,
+  type Token,
+  type TypeNode,
+  factory,
+} from "@ttsc/factory";
+
+import { TypeFactory } from "./TypeFactory";
+
+// Conservative "is this string a syntactically valid JavaScript variable
+// name?" test, inlined to avoid pulling in @typia/utils' full namespace.
+const VARIABLE_REGEX = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const isVariableName = (str: string): boolean => VARIABLE_REGEX.test(str);
+
+/**
+ * Identifier and member-access helpers. The surface kept here is the subset
+ * nestia generators actually call (`identifier`, `access`, `parameter`).
+ */
+export namespace IdentifierFactory {
+  /**
+   * Build an identifier or string literal depending on whether `name` is a
+   * valid JavaScript identifier.
+   */
+  export const identifier = (name: string): Identifier | StringLiteral =>
+    isVariableName(name)
+      ? factory.createIdentifier(name)
+      : factory.createStringLiteral(name);
+
+  /**
+   * Member access on `input` by `key`. Falls back to element access when the
+   * key is not a valid identifier.
+   */
+  export const access = (
+    input: Expression,
+    key: string,
+    chain?: boolean,
+  ): Expression => {
+    const postfix = identifier(key);
+    if (postfix.kind === "StringLiteral")
+      return chain === true
+        ? factory.createElementAccessChain(
+            input,
+            factory.createToken(SyntaxKind.QuestionDotToken),
+            postfix,
+          )
+        : factory.createElementAccessExpression(input, postfix);
+    return chain === true
+      ? factory.createPropertyAccessChain(
+          input,
+          factory.createToken(SyntaxKind.QuestionDotToken),
+          postfix,
+        )
+      : factory.createPropertyAccessExpression(input, postfix);
+  };
+
+  /**
+   * Parameter declaration with default `any` type when the caller omits one.
+   * Passing a `QuestionToken` as `init` marks the parameter optional.
+   */
+  export const parameter = (
+    name: string | Identifier,
+    type?: TypeNode,
+    init?: Expression | Token,
+  ): ParameterDeclaration => {
+    const isQuestionToken =
+      !!init &&
+      init.kind === "Token" &&
+      (init as Token).token === SyntaxKind.QuestionToken;
+    return factory.createParameterDeclaration(
+      undefined,
+      undefined,
+      name,
+      isQuestionToken
+        ? factory.createToken(SyntaxKind.QuestionToken)
+        : undefined,
+      type ?? TypeFactory.keyword("any"),
+      isQuestionToken ? undefined : (init as Expression | undefined),
+    );
+  };
+}

package/src/factories/LiteralFactory.ts

@@ -0,0 +1,54 @@
+import { type Expression, factory } from "@ttsc/factory";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+import { IdentifierFactory } from "./IdentifierFactory";
+
+const PASSTHROUGH_KINDS = new Set<string>([
+  "ArrowFunction",
+  "CallExpression",
+  "Identifier",
+]);
+
+const isNode = (value: unknown): value is Expression =>
+  typeof value === "object" &&
+  value !== null &&
+  typeof (value as { kind?: unknown }).kind === "string";
+
+/**
+ * Recursive value-to-AST-literal builder. Hands back already-AST inputs
+ * unchanged (so callers can mix factory output with raw JS values inside the
+ * same object/array), and emits the appropriate literal node otherwise.
+ */
+export namespace LiteralFactory {
+  export const write = (input: any): Expression => {
+    if (input === null) return factory.createNull();
+    if (isNode(input) && PASSTHROUGH_KINDS.has(input.kind)) return input;
+    if (Array.isArray(input)) return writeArray(input);
+    if (typeof input === "object") return writeObject(input as object);
+    if (typeof input === "boolean")
+      return input ? factory.createTrue() : factory.createFalse();
+    if (typeof input === "number") return ExpressionFactory.number(input);
+    if (typeof input === "string") return factory.createStringLiteral(input);
+    if (typeof input === "bigint")
+      return factory.createStringLiteral(input.toString());
+    if (typeof input === "function")
+      return factory.createIdentifier("undefined");
+    throw new TypeError("LiteralFactory.write: unsupported input type.");
+  };
+
+  const writeObject = (obj: object): Expression =>
+    factory.createObjectLiteralExpression(
+      Object.entries(obj)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) =>
+          factory.createPropertyAssignment(
+            IdentifierFactory.identifier(key),
+            write(value),
+          ),
+        ),
+      true,
+    );
+
+  const writeArray = (array: readonly any[]): Expression =>
+    factory.createArrayLiteralExpression(array.map(write), true);
+}

package/src/factories/StatementFactory.ts

@@ -0,0 +1,56 @@
+import {
+  type Expression,
+  NodeFlags,
+  type TypeNode,
+  type VariableStatement,
+  factory,
+} from "@ttsc/factory";
+
+import { TypeFactory } from "./TypeFactory";
+
+/** Variable-statement helpers. `constant` emits `const`, `mut` emits `let`. */
+export namespace StatementFactory {
+  export const mut = (props: {
+    name: string;
+    type?: TypeNode | undefined;
+    initializer?: Expression | undefined;
+  }): VariableStatement =>
+    factory.createVariableStatement(
+      undefined,
+      factory.createVariableDeclarationList(
+        [
+          factory.createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type !== undefined
+              ? props.type
+              : props.initializer === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.initializer,
+          ),
+        ],
+        NodeFlags.Let,
+      ),
+    );
+
+  export const constant = (props: {
+    name: string;
+    type?: TypeNode | undefined;
+    value?: Expression | undefined;
+  }): VariableStatement =>
+    factory.createVariableStatement(
+      undefined,
+      factory.createVariableDeclarationList(
+        [
+          factory.createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type,
+            props.value,
+          ),
+        ],
+        NodeFlags.Const,
+      ),
+    );
+}

package/src/factories/TypeFactory.ts

@@ -0,0 +1,27 @@
+import { type KeywordTypeNode, SyntaxKind, factory } from "@ttsc/factory";
+
+/**
+ * Higher-level type-keyword factory.
+ *
+ * Wraps {@link factory.createKeywordTypeNode} with a name-based interface so
+ * generator code reads as `TypeFactory.keyword("any")` instead of selecting the
+ * `SyntaxKind.AnyKeyword` token by hand.
+ */
+export namespace TypeFactory {
+  const KEYWORDS = {
+    void: SyntaxKind.VoidKeyword,
+    any: SyntaxKind.AnyKeyword,
+    unknown: SyntaxKind.UnknownKeyword,
+    boolean: SyntaxKind.BooleanKeyword,
+    number: SyntaxKind.NumberKeyword,
+    bigint: SyntaxKind.BigIntKeyword,
+    string: SyntaxKind.StringKeyword,
+    never: SyntaxKind.NeverKeyword,
+    undefined: SyntaxKind.UndefinedKeyword,
+  } as const;
+
+  export type Keyword = keyof typeof KEYWORDS;
+
+  export const keyword = (type: Keyword): KeywordTypeNode =>
+    factory.createKeywordTypeNode(KEYWORDS[type]);
+}

package/src/generates/CloneGenerator.ts

@@ -1,9 +1,10 @@
 import {
-  Node,
+  type Node,
   NodeFlags,
+  type Statement,
   SyntaxKind,
-  TypeScriptFactory,
-} from "@nestia/factory";
+  factory,
+} from "@ttsc/factory";
 import fs from "fs";
 
 import { INestiaProject } from "../structures/INestiaProject";
@@ -60,10 +61,10 @@ export namespace CloneGenerator {
         for (const child of modulo.children.values())
           internal.push(...iterate(importer)(child));
         output.push(
-          TypeScriptFactory.createModuleDeclaration(
-            [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
-            TypeScriptFactory.createIdentifier(modulo.name),
-            TypeScriptFactory.createModuleBlock(internal),
+          factory.createModuleDeclaration(
+            [factory.createModifier(SyntaxKind.ExportKeyword)],
+            factory.createIdentifier(modulo.name),
+            factory.createModuleBlock(internal as Statement[]),
             NodeFlags.Namespace,
           ),
         );

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,11 +1,14 @@
 import {
-  Node,
+  type Node,
   NodeFlags,
+  type NumericLiteral,
   SyntaxKind,
-  TypeScriptFactory,
-} from "@nestia/factory";
-import { IdentifierFactory, LiteralFactory } from "@nestia/factory";
+  type TypeNode,
+  factory,
+} from "@ttsc/factory";
 
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { FilePrinter } from "./FilePrinter";
@@ -44,12 +47,12 @@ export namespace E2eFileProgrammer {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute): Node =>
-      TypeScriptFactory.createVariableStatement(
-        [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
-        TypeScriptFactory.createVariableDeclarationList(
+      factory.createVariableStatement(
+        [factory.createModifier(SyntaxKind.ExportKeyword)],
+        factory.createVariableDeclarationList(
           [
-            TypeScriptFactory.createVariableDeclaration(
-              TypeScriptFactory.createIdentifier(getFunctionName(route)),
+            factory.createVariableDeclaration(
+              factory.createIdentifier(getFunctionName(route)),
               undefined,
               undefined,
               generateArrow(project)(importer)(route),
@@ -64,34 +67,36 @@ export namespace E2eFileProgrammer {
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute) => {
       const random = IdentifierFactory.access(
-        TypeScriptFactory.createIdentifier(SdkImportWizard.typia(importer)),
+        factory.createIdentifier(SdkImportWizard.typia(importer)),
         "random",
       );
       const connection = route.headerObject
-        ? TypeScriptFactory.createObjectLiteralExpression(
+        ? factory.createObjectLiteralExpression(
             [
-              TypeScriptFactory.createSpreadAssignment(
-                TypeScriptFactory.createIdentifier("connection"),
+              factory.createSpreadAssignment(
+                factory.createIdentifier("connection"),
               ),
-              TypeScriptFactory.createPropertyAssignment(
+              factory.createPropertyAssignment(
                 "headers",
-                TypeScriptFactory.createObjectLiteralExpression(
+                factory.createObjectLiteralExpression(
                   [
-                    TypeScriptFactory.createSpreadAssignment(
+                    factory.createSpreadAssignment(
                       IdentifierFactory.access(
-                        TypeScriptFactory.createIdentifier("connection"),
+                        factory.createIdentifier("connection"),
                         "headers",
                       ),
                     ),
-                    TypeScriptFactory.createSpreadAssignment(
-                      TypeScriptFactory.createCallExpression(
+                    factory.createSpreadAssignment(
+                      factory.createCallExpression(
                         random,
                         [
-                          project.config.clone === true
+                          (project.config.clone === true
                             ? SdkAliasCollection.from(project)(importer)(
                                 route.headerObject.metadata,
                               )
-                            : SdkAliasCollection.name(route.headerObject),
+                            : SdkAliasCollection.name(
+                                route.headerObject,
+                              )) as TypeNode,
                         ],
                         undefined,
                       ),
@@ -103,7 +108,7 @@ export namespace E2eFileProgrammer {
             ],
             true,
           )
-        : TypeScriptFactory.createIdentifier("connection");
+        : factory.createIdentifier("connection");
       const entries = SdkHttpParameterProgrammer.getEntries({
         project,
         importer,
@@ -112,8 +117,8 @@ export namespace E2eFileProgrammer {
         e2e: true,
         prefix: ["api", "functional", ...route.accessor].join(".") + ".",
       });
-      const fetch = TypeScriptFactory.createCallExpression(
-        TypeScriptFactory.createIdentifier(
+      const fetch = factory.createCallExpression(
+        factory.createIdentifier(
           ["api", "functional", ...route.accessor].join("."),
         ),
         undefined,
@@ -125,9 +130,9 @@ export namespace E2eFileProgrammer {
                   Object.fromEntries(
                     entries.map((e) => [
                       e.key,
-                      TypeScriptFactory.createCallExpression(
+                      factory.createCallExpression(
                         IdentifierFactory.access(
-                          TypeScriptFactory.createIdentifier(
+                          factory.createIdentifier(
                             SdkImportWizard.typia(importer),
                           ),
                           "random",
@@ -140,11 +145,9 @@ export namespace E2eFileProgrammer {
                 ),
               ]
             : entries.map((e) =>
-                TypeScriptFactory.createCallExpression(
+                factory.createCallExpression(
                   IdentifierFactory.access(
-                    TypeScriptFactory.createIdentifier(
-                      SdkImportWizard.typia(importer),
-                    ),
+                    factory.createIdentifier(SdkImportWizard.typia(importer)),
                     "random",
                   ),
                   [getRandomType(importer)(e)],
@@ -153,39 +156,41 @@ export namespace E2eFileProgrammer {
               )),
         ],
       );
-      const assert = TypeScriptFactory.createCallExpression(
+      const assert = factory.createCallExpression(
         IdentifierFactory.access(
-          TypeScriptFactory.createIdentifier(SdkImportWizard.typia(importer)),
+          factory.createIdentifier(SdkImportWizard.typia(importer)),
           "assert",
         ),
         undefined,
-        [TypeScriptFactory.createIdentifier("output")],
+        [factory.createIdentifier("output")],
       );
 
-      return TypeScriptFactory.createArrowFunction(
-        [TypeScriptFactory.createModifier(SyntaxKind.AsyncKeyword)],
+      return factory.createArrowFunction(
+        [factory.createModifier(SyntaxKind.AsyncKeyword)],
         undefined,
         [
           IdentifierFactory.parameter(
             "connection",
-            TypeScriptFactory.createTypeReferenceNode("api.IConnection"),
+            factory.createTypeReferenceNode("api.IConnection"),
           ),
         ],
         undefined,
         undefined,
-        TypeScriptFactory.createBlock([
-          TypeScriptFactory.createVariableStatement(
+        factory.createBlock([
+          factory.createVariableStatement(
             [],
-            TypeScriptFactory.createVariableDeclarationList(
+            factory.createVariableDeclarationList(
               [
-                TypeScriptFactory.createVariableDeclaration(
+                factory.createVariableDeclaration(
                   "output",
                   undefined,
                   project.config.propagate !== true &&
                     route.success.type!.name === "void"
                     ? undefined
-                    : SdkAliasCollection.response(project)(importer)(route),
-                  TypeScriptFactory.createAwaitExpression(fetch),
+                    : (SdkAliasCollection.response(project)(importer)(
+                        route,
+                      ) as TypeNode),
+                  factory.createAwaitExpression(fetch),
                 ),
               ],
               NodeFlags.Const,
@@ -193,7 +198,7 @@ export namespace E2eFileProgrammer {
           ),
           ...(route.success.binary === true
             ? []
-            : [TypeScriptFactory.createExpressionStatement(assert)]),
+            : [factory.createExpressionStatement(assert)]),
         ]),
       );
     };
@@ -201,13 +206,14 @@ export namespace E2eFileProgrammer {
 
 const getRandomType =
   (importer: ImportDictionary) =>
-  (entry: SdkHttpParameterProgrammer.IEntry): Node => {
-    if (isPlainStringPathParameter(entry) === false) return entry.type;
-    return TypeScriptFactory.createIntersectionTypeNode([
-      entry.type,
-      TypeScriptFactory.createTypeReferenceNode(
-        TypeScriptFactory.createQualifiedName(
-          TypeScriptFactory.createIdentifier(
+  (entry: SdkHttpParameterProgrammer.IEntry): TypeNode => {
+    if (isPlainStringPathParameter(entry) === false)
+      return entry.type as TypeNode;
+    return factory.createIntersectionTypeNode([
+      entry.type as TypeNode,
+      factory.createTypeReferenceNode(
+        factory.createQualifiedName(
+          factory.createIdentifier(
             importer.external({
               declaration: true,
               file: "typia",
@@ -215,11 +221,11 @@ const getRandomType =
               name: "tags",
             }),
           ),
-          TypeScriptFactory.createIdentifier("MinLength"),
+          factory.createIdentifier("MinLength"),
         ),
         [
-          TypeScriptFactory.createLiteralTypeNode(
-            LiteralFactory.write(1) as Node,
+          factory.createLiteralTypeNode(
+            LiteralFactory.write(1) as NumericLiteral,
           ),
         ],
       ),