@nestia/factory 12.0.0-dev.20260520.1

package/src/factory/types/createIndexSignature.ts

@@ -0,0 +1,16 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createIndexSignature(
+  modifiers: readonly Node[] | undefined,
+  parameters: readonly Node[],
+  type: Node,
+): Node {
+  return createNode(SyntaxKind.IndexSignature, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    parameters: createNodeArray(parameters),
+    type,
+  });
+}

package/src/factory/types/createIntersectionTypeNode.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createIntersectionTypeNode(types: readonly Node[] = []): Node {
+  return createNode(SyntaxKind.IntersectionType, {
+    types: createNodeArray(types),
+  });
+}

package/src/factory/types/createKeywordTypeNode.ts

@@ -0,0 +1,6 @@
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createKeywordTypeNode(kind: number): Node {
+  return createNode(kind);
+}

package/src/factory/types/createLiteralTypeNode.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createLiteralTypeNode(literal: Node): Node {
+  return createNode(SyntaxKind.LiteralType, { literal });
+}

package/src/factory/types/createOptionalTypeNode.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createOptionalTypeNode(type: Node): Node {
+  return createNode(SyntaxKind.OptionalType, { type });
+}

package/src/factory/types/createParenthesizedType.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createParenthesizedType(type: Node): Node {
+  return createNode(SyntaxKind.ParenthesizedType, { type });
+}

package/src/factory/types/createPropertySignature.ts

@@ -0,0 +1,20 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createPropertySignature(
+  modifiers: readonly Node[] | undefined,
+  name: string | Node,
+  questionToken: Node | undefined,
+  type: Node | undefined,
+): Node {
+  return createNode(SyntaxKind.PropertySignature, {
+    modifiers: modifiers ? createNodeArray(modifiers) : undefined,
+    name: asName(name),
+    questionToken,
+    type,
+    jsDoc: undefined,
+  });
+}

package/src/factory/types/createRestTypeNode.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createRestTypeNode(type: Node): Node {
+  return createNode(SyntaxKind.RestType, { type });
+}

package/src/factory/types/createTemplateLiteralType.ts

@@ -0,0 +1,14 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createTemplateLiteralType(
+  head: Node,
+  templateSpans: readonly Node[],
+): Node {
+  return createNode(SyntaxKind.TemplateLiteralType, {
+    head,
+    templateSpans: createNodeArray(templateSpans),
+  });
+}

package/src/factory/types/createTemplateLiteralTypeSpan.ts

@@ -0,0 +1,7 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+
+export function createTemplateLiteralTypeSpan(type: Node, literal: Node): Node {
+  return createNode(SyntaxKind.TemplateLiteralTypeSpan, { type, literal });
+}

package/src/factory/types/createTupleTypeNode.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createTupleTypeNode(elements: readonly Node[] = []): Node {
+  return createNode(SyntaxKind.TupleType, {
+    elements: createNodeArray(elements),
+  });
+}

package/src/factory/types/createTypeLiteralNode.ts

@@ -0,0 +1,10 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createTypeLiteralNode(members: readonly Node[] = []): Node {
+  return createNode(SyntaxKind.TypeLiteral, {
+    members: createNodeArray(members),
+  });
+}

package/src/factory/types/createTypeQueryNode.ts

@@ -0,0 +1,8 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+
+export function createTypeQueryNode(exprName: string | Node): Node {
+  return createNode(SyntaxKind.TypeQuery, { exprName: asName(exprName) });
+}

package/src/factory/types/createTypeReferenceNode.ts

@@ -0,0 +1,15 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { asName } from "../../utils/asName";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createTypeReferenceNode(
+  typeName: string | Node,
+  typeArguments?: readonly Node[],
+): Node {
+  return createNode(SyntaxKind.TypeReference, {
+    typeName: asName(typeName),
+    typeArguments: typeArguments ? createNodeArray(typeArguments) : undefined,
+  });
+}

package/src/factory/types/createUnionTypeNode.ts

@@ -0,0 +1,8 @@
+import { SyntaxKind } from "../../constants/SyntaxKind";
+import type { Node } from "../../structures/Node";
+import { createNode } from "../../utils/createNode";
+import { createNodeArray } from "../../utils/createNodeArray";
+
+export function createUnionTypeNode(types: readonly Node[] = []): Node {
+  return createNode(SyntaxKind.UnionType, { types: createNodeArray(types) });
+}

package/src/helpers/ExpressionFactory.ts

@@ -0,0 +1,20 @@
+import { SyntaxKind } from "../constants/SyntaxKind";
+import { createNumericLiteral } from "../factory/literals/createNumericLiteral";
+import { createPrefixUnaryExpression } from "../factory/expressions/createPrefixUnaryExpression";
+import type { Node } from "../structures/Node";
+
+/**
+ * Numeric-literal helper that handles negative values via a leading
+ * `MinusToken` prefix unary, matching how the TypeScript factory itself
+ * emits negative numeric literals. Replaces the legacy `@typia/core`
+ * `ExpressionFactory.number` nestia previously imported.
+ */
+export namespace ExpressionFactory {
+  export const number = (value: number): Node =>
+    value < 0
+      ? createPrefixUnaryExpression(
+          SyntaxKind.MinusToken,
+          createNumericLiteral(Math.abs(value)),
+        )
+      : createNumericLiteral(value);
+}

package/src/helpers/FormatCheatSheet.ts

@@ -0,0 +1,71 @@
+const RegexCall = <Text extends string>(text: Text) =>
+  `${text}.test($input)` as const;
+
+/** @reference https://github.dev/ajv-validator/ajv-formats/blob/master/src/formats.ts */
+export const FormatCheatSheet = {
+  // SPECIAL CHARACTERS
+  byte: RegexCall(
+    `/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm`,
+  ),
+  password: `true`,
+  regex: `(() => { try { new RegExp($input); return true; } catch { return false; } })()`,
+  uuid: RegexCall(
+    `/^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i`,
+  ),
+
+  // ADDRESSES
+  email: RegexCall(
+    `/^[a-z0-9!#$%&'*+/=?^_\`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_\`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i`,
+  ),
+  hostname: RegexCall(
+    `/^(?=.{1,253}\\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\\.?$/i`,
+  ),
+  "idn-email": RegexCall(
+    `/^(([^<>()[\\]\\.,;:\\s@\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\"]+)*)|(\\".+\\"))@(([^<>()[\\]\\.,;:\\s@\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\"]{2,})$/i`,
+  ),
+  "idn-hostname": RegexCall(
+    `/^([a-z0-9\\u00a1-\\uffff0-9]+(-[a-z0-9\\u00a1-\\uffff0-9]+)*\\.)+[a-z\\u00a1-\\uffff]{2,}$/i`,
+  ),
+  iri: RegexCall(
+    `/^[A-Za-z][\\d+-.A-Za-z]*:[^\\u0000-\\u0020"<>\\\\^\`{|}]*$/u`,
+  ),
+  "iri-reference": RegexCall(
+    `/^[A-Za-z][\\d+-.A-Za-z]*:[^\\u0000-\\u0020"<>\\\\^\`{|}]*$/u`,
+  ),
+  ipv4: RegexCall(
+    `/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/`,
+  ),
+  ipv6: RegexCall(
+    `/^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i`,
+  ),
+  uri: `${RegexCall(`/\\/|:/`)} && ${RegexCall(
+    `/^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i`,
+  )}`,
+  "uri-reference": RegexCall(
+    `/^(?:[a-z][a-z0-9+\\-.]*:)?(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i`,
+  ),
+  "uri-template": RegexCall(
+    `/^(?:(?:[^\\x00-\\x20"'<>%\\\\^\`{|}]|%[0-9a-f]{2})|\\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?)*\\})*$/i`,
+  ),
+  url: RegexCall(
+    `/^(?:https?|ftp):\\/\\/(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)(?:\\.(?:[a-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)*(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu`,
+  ),
+
+  // TIMESTAMPS
+  "date-time": RegexCall(
+    `/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])(T|\\s)([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i`,
+  ),
+  date: RegexCall(`/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/`),
+  time: RegexCall(
+    `/^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i`,
+  ),
+  duration: RegexCall(
+    `/^P(?!$)((\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?|(\\d+W)?)$/`,
+  ),
+
+  // POINTERS
+  "json-pointer": RegexCall(`/^(?:\\/(?:[^~/]|~0|~1)*)*$/`),
+  "relative-json-pointer": RegexCall(
+    `/^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/`,
+  ),
+} as const;

package/src/helpers/IdentifierFactory.ts

@@ -0,0 +1,84 @@
+import { SyntaxKind } from "../constants/SyntaxKind";
+import { createIdentifier } from "../factory/literals/createIdentifier";
+import { createStringLiteral } from "../factory/literals/createStringLiteral";
+import { createElementAccessChain } from "../factory/expressions/createElementAccessChain";
+import { createElementAccessExpression } from "../factory/expressions/createElementAccessExpression";
+import { createPropertyAccessChain } from "../factory/expressions/createPropertyAccessChain";
+import { createPropertyAccessExpression } from "../factory/expressions/createPropertyAccessExpression";
+import { createParameterDeclaration } from "../factory/declarations/createParameterDeclaration";
+import { createToken } from "../factory/tokens/createToken";
+import type { Node } from "../structures/Node";
+
+import { TypeFactory } from "./TypeFactory";
+
+// Conservative "is this string a syntactically valid JavaScript variable
+// name?" test, inlined to avoid pulling in @typia/utils' full namespace from
+// an ESM bundle that only exposes a `default` export.
+const VARIABLE_REGEX = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const isVariableName = (str: string): boolean => VARIABLE_REGEX.test(str);
+
+/**
+ * Identifier and member-access helpers. Replaces the legacy `@typia/core`
+ * `IdentifierFactory` nestia previously depended on; the surface kept here is
+ * the subset nestia generators actually call (`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): Node =>
+    isVariableName(name) ? createIdentifier(name) : 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: Node, key: string, chain?: boolean): Node => {
+    const postfix = identifier(key);
+    const isElement = postfix.kind === SyntaxKind.StringLiteral;
+    if (chain === true) {
+      const dot = createToken(SyntaxKind.QuestionDotToken);
+      return isElement
+        ? createElementAccessChain(input, dot, postfix)
+        : createPropertyAccessChain(input, dot, postfix);
+    }
+    return isElement
+      ? createElementAccessExpression(input, postfix)
+      : createPropertyAccessExpression(input, postfix);
+  };
+
+  /** Recover the dotted name of a property/element-access chain. */
+  export const getName = (input: Node): string => {
+    if (input.kind === SyntaxKind.Identifier) {
+      const escaped = (input as { escapedText?: string }).escapedText;
+      if (typeof escaped === "string") return escaped;
+      return (input as { text?: string }).text ?? "";
+    }
+    if (input.kind === SyntaxKind.PropertyAccessExpression) {
+      const expr = (input as { expression?: Node }).expression;
+      const name = (input as { name?: Node }).name;
+      return name ? `${expr ? getName(expr) : ""}.${getName(name)}` : "";
+    }
+    if (input.kind === SyntaxKind.ElementAccessExpression) {
+      const expr = (input as { expression?: Node }).expression;
+      const arg = (input as { argumentExpression?: Node }).argumentExpression;
+      return arg ? `${expr ? getName(expr) : ""}[${getName(arg)}]` : "";
+    }
+    return "unknown";
+  };
+
+  /** Parameter declaration with default `any` type when the caller omits one. */
+  export const parameter = (
+    name: string | Node,
+    type?: Node,
+    init?: Node,
+  ): Node => {
+    const isQuestionToken =
+      (init as { kind?: number } | undefined)?.kind === SyntaxKind.QuestionToken;
+    return createParameterDeclaration(
+      undefined,
+      undefined,
+      name,
+      isQuestionToken ? createToken(SyntaxKind.QuestionToken) : undefined,
+      type ?? TypeFactory.keyword("any"),
+      isQuestionToken ? undefined : init,
+    );
+  };
+}

package/src/helpers/LiteralFactory.ts

@@ -0,0 +1,59 @@
+import { SyntaxKind } from "../constants/SyntaxKind";
+import { createArrayLiteralExpression } from "../factory/expressions/createArrayLiteralExpression";
+import { createObjectLiteralExpression } from "../factory/expressions/createObjectLiteralExpression";
+import { createPropertyAssignment } from "../factory/expressions/createPropertyAssignment";
+import { createFalse } from "../factory/literals/createFalse";
+import { createIdentifier } from "../factory/literals/createIdentifier";
+import { createNull } from "../factory/literals/createNull";
+import { createStringLiteral } from "../factory/literals/createStringLiteral";
+import { createTrue } from "../factory/literals/createTrue";
+import type { Node } from "../structures/Node";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+import { IdentifierFactory } from "./IdentifierFactory";
+
+const PASSTHROUGH_KINDS = new Set<number>([
+  SyntaxKind.ArrowFunction,
+  SyntaxKind.CallExpression,
+  SyntaxKind.Identifier,
+]);
+
+const isNode = (value: unknown): value is Node =>
+  typeof value === "object" &&
+  value !== null &&
+  typeof (value as { kind?: unknown }).kind === "number";
+
+/**
+ * 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.
+ * Replaces the legacy `@typia/core` `LiteralFactory.write` nestia generators
+ * previously imported.
+ */
+export namespace LiteralFactory {
+  export const write = (input: any): Node => {
+    if (input === null) return 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 ? createTrue() : createFalse();
+    if (typeof input === "number") return ExpressionFactory.number(input);
+    if (typeof input === "string") return createStringLiteral(input);
+    if (typeof input === "bigint") return createStringLiteral(input.toString());
+    if (typeof input === "function") return createIdentifier("undefined");
+    throw new TypeError("LiteralFactory.write: unsupported input type.");
+  };
+
+  const writeObject = (obj: object): Node =>
+    createObjectLiteralExpression(
+      Object.entries(obj)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) =>
+          createPropertyAssignment(IdentifierFactory.identifier(key), write(value)),
+        ),
+      true,
+    );
+
+  const writeArray = (array: readonly any[]): Node =>
+    createArrayLiteralExpression(array.map(write), true);
+}

package/src/helpers/StatementFactory.ts

@@ -0,0 +1,57 @@
+import { NodeFlags } from "../constants/NodeFlags";
+import { createVariableDeclaration } from "../factory/declarations/createVariableDeclaration";
+import { createVariableDeclarationList } from "../factory/declarations/createVariableDeclarationList";
+import { createVariableStatement } from "../factory/declarations/createVariableStatement";
+import type { Node } from "../structures/Node";
+
+import { TypeFactory } from "./TypeFactory";
+
+/**
+ * Variable-statement helpers. `constant` emits `const`, `mut` emits `let`.
+ * Mirrors the legacy `@typia/core` `StatementFactory` nestia generators call.
+ */
+export namespace StatementFactory {
+  export const mut = (props: {
+    name: string;
+    type?: Node | undefined;
+    initializer?: Node | undefined;
+  }): Node =>
+    createVariableStatement(
+      undefined,
+      createVariableDeclarationList(
+        [
+          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?: Node | undefined;
+    value?: Node | undefined;
+  }): Node =>
+    createVariableStatement(
+      undefined,
+      createVariableDeclarationList(
+        [
+          createVariableDeclaration(
+            props.name,
+            undefined,
+            props.type,
+            props.value,
+          ),
+        ],
+        NodeFlags.Const,
+      ),
+    );
+}

package/src/helpers/TypeFactory.ts

@@ -0,0 +1,30 @@
+import { SyntaxKind } from "../constants/SyntaxKind";
+import { createKeywordTypeNode } from "../factory/types/createKeywordTypeNode";
+import type { Node } from "../structures/Node";
+
+/**
+ * Higher-level type-keyword factory.
+ *
+ * Wraps {@link createKeywordTypeNode} with a name-based interface so generator
+ * code reads as `TypeFactory.keyword("any")` instead of selecting the
+ * `SyntaxKind.AnyKeyword` token by hand. Mirrors the legacy `@typia/core`
+ * `TypeFactory` namespace nestia previously depended on.
+ */
+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): Node =>
+    createKeywordTypeNode(KEYWORDS[type]);
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+import { nts } from "./nts";
+
+export { nts } from "./nts";
+export { NodeFlags } from "./constants/NodeFlags";
+export { SyntaxKind } from "./constants/SyntaxKind";
+export * as factory from "./factory/index";
+export { TypeScriptFactory } from "./TypeScriptFactory";
+export { TypeScriptPrinter } from "./printers/TypeScriptPrinter";
+export type {
+  CommentNode,
+  EmitNode,
+  Node,
+  NodeArray,
+  NodeProps,
+} from "./structures";
+
+// High-level helpers that wrap the factory primitives. These replace the
+// legacy `@typia/core` helpers (IdentifierFactory, LiteralFactory, etc.)
+// nestia generators previously imported, so nothing in nestia source needs
+// to reach into `@typia/core` for AST construction anymore.
+export { ExpressionFactory } from "./helpers/ExpressionFactory";
+export { FormatCheatSheet } from "./helpers/FormatCheatSheet";
+export { IdentifierFactory } from "./helpers/IdentifierFactory";
+export { LiteralFactory } from "./helpers/LiteralFactory";
+export { StatementFactory } from "./helpers/StatementFactory";
+export { TypeFactory } from "./helpers/TypeFactory";
+
+export default nts;

package/src/nts.ts

@@ -0,0 +1,9 @@
+import { TypeScriptFactory } from "./TypeScriptFactory";
+import * as factory from "./factory/index";
+import { TypeScriptPrinter } from "./printers/TypeScriptPrinter";
+
+export const nts = {
+  factory,
+  TypeScriptFactory,
+  TypeScriptPrinter,
+} as const;

package/src/printers/TypeScriptPrinter.ts

@@ -0,0 +1,51 @@
+import { TypeScriptFactory } from "../TypeScriptFactory";
+import { NodeFlags } from "../constants/NodeFlags";
+import { SyntaxKind } from "../constants/SyntaxKind";
+import type { Node } from "../structures/Node";
+import { NodePrinter } from "./internal/NodePrinter";
+
+export class TypeScriptPrinter {
+  private readonly printer: NodePrinter;
+
+  public constructor() {
+    this.printer = new NodePrinter();
+  }
+
+  public printFile(file: Node): string {
+    return this.printer.printFile(file);
+  }
+
+  public printStatements(
+    statements: readonly Node[],
+    props: TypeScriptPrinter.IPrintStatementsProps = {},
+  ): string {
+    const file = TypeScriptFactory.createSourceFile(
+      statements,
+      props.endOfFileToken ??
+        TypeScriptFactory.createToken(SyntaxKind.EndOfFileToken),
+      props.flags ?? NodeFlags.None,
+    );
+
+    return (props.top ?? "") + this.printFile(file);
+  }
+
+  public printNode(_hint: unknown, node: Node, _sourceFile?: Node): string {
+    return this.printer.printNode(node);
+  }
+
+  public static write(props: TypeScriptPrinter.IWriteProps): string {
+    return new TypeScriptPrinter().printStatements(props.statements, props);
+  }
+}
+
+export namespace TypeScriptPrinter {
+  export interface IPrintStatementsProps {
+    endOfFileToken?: Node;
+    flags?: number;
+    top?: string;
+  }
+
+  export interface IWriteProps extends IPrintStatementsProps {
+    statements: readonly Node[];
+  }
+}