@kubb/plugin-ts 5.1.0-canary.20261023T200213 → 5.2.0-canary.20261024T091509

package/dist/index.cjs

@@ -18,11 +18,11 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-let _kubb_parser_ts = require("@kubb/parser-ts");
 let kubb_jsx = require("kubb/jsx");
-let node_module = require("node:module");
 let kubb_kit = require("kubb/kit");
+let yuku_codegen = require("yuku-codegen");
 let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
+let _kubb_parser_ts = require("@kubb/parser-ts");
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -322,6 +322,7 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	createIntersectionDeclaration: () => createIntersectionDeclaration,
 	createOmitDeclaration: () => createOmitDeclaration,
 	createPropertySignature: () => createPropertySignature,
+	createRaw: () => createRaw,
 	createTypeDeclaration: () => createTypeDeclaration,
 	createTypeLiteralNode: () => createTypeLiteralNode,
 	createTypeReferenceNode: () => createTypeReferenceNode,
@@ -329,84 +330,113 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	createUrlTemplateType: () => createUrlTemplateType,
 	dateOrStringNode: () => dateOrStringNode,
 	isNonNullable: () => isNonNullable$1,
-	isUnionTypeNode: () => isUnionTypeNode,
 	keywordTypeNodes: () => keywordTypeNodes,
-	modifiers: () => modifiers,
+	print: () => print,
 	wrapNullableOptional: () => wrapNullableOptional
 });
-/**
-* Loaded with `require`, not `import`. When ESM imports a CommonJS package, Node keeps a second
-* copy of its source to detect named exports, and for TypeScript that copy is about 9 MB.
-*/
-const typescript = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("@typescript/typescript6");
-const { SyntaxKind, factory } = typescript;
 function isNumber(value) {
 	return typeof value === "number" && !Number.isNaN(value);
 }
-/**
-* TypeScript AST modifiers for the `export` keyword.
-*/
-const modifiers = { export: factory.createModifier(typescript.SyntaxKind.ExportKeyword) };
-const isUnionTypeNode = typescript.isUnionTypeNode;
 function isNonNullable$1(value) {
 	return value !== null && value !== void 0;
 }
 __name(isNonNullable$1, "isNonNullable");
-function isValidIdentifier(str) {
-	if (!str.length || str.trim() !== str) return false;
-	let ch = str.codePointAt(0);
-	if (!typescript.isIdentifierStart(ch, typescript.ScriptTarget.Latest)) return false;
-	for (let i = ch > 65535 ? 2 : 1; i < str.length; i += ch > 65535 ? 2 : 1) {
-		ch = str.codePointAt(i);
-		if (!typescript.isIdentifierPart(ch, typescript.ScriptTarget.Latest)) return false;
-	}
-	return true;
+/**
+* Prints `node` as TypeScript source with single quotes and two-space indentation.
+*/
+function print(node) {
+	return (0, yuku_codegen.generate)(node, { quotes: "single" }).code;
+}
+/**
+* Wraps already printed TypeScript, such as a user override result, so it can sit inside a node tree.
+* Parentheses keep a union or function type intact when it lands inside an array or intersection.
+*/
+function createRaw(text) {
+	const name = {
+		type: "TSTypeReference",
+		typeName: identifier(text),
+		typeArguments: null
+	};
+	return /[|&?]|=>/.test(text) ? {
+		type: "TSParenthesizedType",
+		typeAnnotation: name
+	} : name;
+}
+function identifier(name) {
+	return {
+		type: "Identifier",
+		name
+	};
+}
+function literal(value) {
+	return {
+		type: "Literal",
+		value
+	};
+}
+function createLiteralType(value) {
+	return {
+		type: "TSLiteralType",
+		literal: literal(value)
+	};
+}
+/**
+* Whether `name` can be written as a bare property name instead of a quoted string.
+*/
+function isValidIdentifier(name) {
+	return /^[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*$/u.test(name);
 }
+/**
+* A property or enum member name, quoted when it is not a valid identifier.
+*/
 function propertyName(name) {
-	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
-	return name;
+	return isValidIdentifier(name) ? identifier(name) : literal(name);
 }
-const questionToken = factory.createToken(typescript.SyntaxKind.QuestionToken);
 /**
-* Creates a question token for optional type annotations.
-* Pass `true` to use the cached token, or provide a pre-created token.
+* Indents every non-empty line of `text` by two spaces.
 */
-function createQuestionToken(token) {
-	if (!token) return;
-	if (token === true) return questionToken;
-	return token;
+function indent(text) {
+	return text.split("\n").map((line) => line ? `  ${line}` : line).join("\n");
 }
 /**
-* Creates a TypeScript intersection type node from multiple type nodes.
-* Returns the single node if only one is provided, or wraps in parentheses if requested.
+* Creates a TypeScript intersection type.
+* Returns the single type if only one is provided. `yuku-codegen` adds the parentheses a union member needs.
 */
 function createIntersectionDeclaration({ nodes, withParentheses }) {
 	if (!nodes.length) return null;
 	if (nodes.length === 1) return nodes[0] || null;
-	const node = factory.createIntersectionTypeNode(nodes);
-	if (withParentheses) return factory.createParenthesizedType(node);
-	return node;
+	const node = {
+		type: "TSIntersectionType",
+		types: nodes
+	};
+	return withParentheses ? {
+		type: "TSParenthesizedType",
+		typeAnnotation: node
+	} : node;
 }
 /**
-* Creates a TypeScript array type node.
+* Creates a TypeScript array type.
 * Use `arrayType: 'array'` for bracket syntax (`T[]`), or `'generic'` for `Array<T>`.
 *
 * @example Array bracket syntax
-* `createArrayDeclaration({ nodes: [stringType], arrayType: 'array' }) // → string[]`
+* `createArrayDeclaration({ nodes: [string], arrayType: 'array' }) // → string[]`
 *
 * @example Generic Array syntax
-* `createArrayDeclaration({ nodes: [stringType], arrayType: 'generic' }) // → Array<string>`
+* `createArrayDeclaration({ nodes: [string], arrayType: 'generic' }) // → Array<string>`
 */
 function createArrayDeclaration({ nodes, arrayType = "array" }) {
-	if (!nodes.length) return factory.createTupleTypeNode([]);
-	if (nodes.length === 1) {
-		const node = nodes[0];
-		if (arrayType === "generic") return factory.createTypeReferenceNode(factory.createIdentifier("Array"), [node]);
-		return factory.createArrayTypeNode(node);
-	}
-	const unionType = factory.createUnionTypeNode(nodes);
-	if (arrayType === "generic") return factory.createTypeReferenceNode(factory.createIdentifier("Array"), [unionType]);
-	return factory.createArrayTypeNode(factory.createParenthesizedType(unionType));
+	if (!nodes.length) return {
+		type: "TSTupleType",
+		elementTypes: []
+	};
+	const node = nodes.length === 1 ? nodes[0] : {
+		type: "TSUnionType",
+		types: nodes
+	};
+	return arrayType === "generic" ? createTypeReferenceNode("Array", [node]) : {
+		type: "TSArrayType",
+		elementType: node
+	};
 }
 /**
 * Minimum nodes length of 2
@@ -416,60 +446,115 @@ function createArrayDeclaration({ nodes, arrayType = "array" }) {
 function createUnionDeclaration({ nodes, withParentheses }) {
 	if (!nodes.length) return keywordTypeNodes.any;
 	if (nodes.length === 1) return nodes[0];
-	const node = factory.createUnionTypeNode(nodes);
-	if (withParentheses) return factory.createParenthesizedType(node);
-	return node;
+	const node = {
+		type: "TSUnionType",
+		types: nodes
+	};
+	return withParentheses ? {
+		type: "TSParenthesizedType",
+		typeAnnotation: node
+	} : node;
 }
 /**
 * Creates a TypeScript property signature for object/interface members.
 * Supports optional markers, readonly modifiers, and type annotations.
 */
-function createPropertySignature({ readOnly, modifiers = [], name, questionToken, type }) {
-	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(typescript.SyntaxKind.ReadonlyKeyword) : void 0].filter((modifier) => modifier !== void 0), propertyName(name), createQuestionToken(questionToken), type);
+function createPropertySignature({ readOnly, name, questionToken, type }) {
+	return {
+		type: "TSPropertySignature",
+		key: propertyName(name),
+		computed: false,
+		optional: !!questionToken,
+		readonly: !!readOnly,
+		static: false,
+		typeAnnotation: type ? {
+			type: "TSTypeAnnotation",
+			typeAnnotation: type
+		} : null
+	};
 }
 /**
-* Attaches JSDoc comments to an AST node as synthetic leading comments.
-* Filters out undefined comments before attaching.
-*
-* @see https://github.com/microsoft/TypeScript/issues/44151
+* Attaches a JSDoc block built from `comments` to `node`, dropping empty comments.
 */
 function appendJSDocToNode({ node, comments }) {
-	const filteredComments = comments.filter(Boolean);
-	if (!filteredComments.length) return node;
-	const text = filteredComments.flatMap((comment = "") => comment.split(/\r?\n/)).reduce((acc = "", comment = "") => {
-		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
-	}, "*");
-	return typescript.addSyntheticLeadingComment(node, typescript.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
+	const lines = comments.filter(Boolean).flatMap((comment = "") => comment.split(/\r?\n/));
+	if (!lines.length) return node;
+	const value = `*\n${lines.map((line) => ` * ${line.replaceAll("*/", "*\\/")}`.trimEnd()).join("\n")}\n `;
+	return {
+		...node,
+		comments: [{
+			type: "Block",
+			value,
+			position: "before",
+			sameLine: false
+		}]
+	};
 }
 /**
-* Creates a TypeScript index signature for dynamic property access.
-* Defines the key type (default: `string`) and value type on an object.
+* Creates a TypeScript type literal (anonymous object type) with one member per line.
 */
-function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword) } = {}) {
-	return factory.createIndexSignature(modifiers, [factory.createParameterDeclaration(void 0, void 0, indexName, void 0, indexType)], type);
+function createTypeLiteralNode(members) {
+	return {
+		type: "TSTypeLiteral",
+		members
+	};
+}
+/**
+* Creates a TypeScript type reference (e.g., `Array<string>`, `Record<K, V>`).
+*/
+function createTypeReferenceNode(name, typeArguments) {
+	return {
+		type: "TSTypeReference",
+		typeName: identifier(name),
+		typeArguments: typeArguments?.length ? {
+			type: "TSTypeParameterInstantiation",
+			params: typeArguments
+		} : null
+	};
+}
+function exportNamed(declaration, exportKind) {
+	return {
+		type: "ExportNamedDeclaration",
+		declaration,
+		specifiers: [],
+		source: null,
+		attributes: [],
+		exportKind
+	};
 }
 /**
-* Creates a TypeScript type declaration as either a type alias or interface.
-* Intelligently selects the syntax based on the type structure and attaches JSDoc comments.
+* Prints a TypeScript type declaration as either a type alias or interface.
+* Uses interface syntax only when requested and the type is an object literal, and attaches JSDoc comments.
 */
 function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
-	if (syntax === "interface" && typescript.isTypeLiteralNode(type)) return appendJSDocToNode({
-		node: factory.createInterfaceDeclaration(isExportable ? [modifiers.export] : [], name, void 0, void 0, [...type.members]),
-		comments
-	});
-	return appendJSDocToNode({
-		node: factory.createTypeAliasDeclaration(isExportable ? [modifiers.export] : [], name, void 0, type),
+	const declaration = syntax === "interface" && type.type === "TSTypeLiteral" ? {
+		type: "TSInterfaceDeclaration",
+		declare: false,
+		id: identifier(name),
+		typeParameters: null,
+		extends: [],
+		body: {
+			type: "TSInterfaceBody",
+			body: type.members
+		}
+	} : {
+		type: "TSTypeAliasDeclaration",
+		declare: false,
+		id: identifier(name),
+		typeParameters: null,
+		typeAnnotation: type
+	};
+	return print(appendJSDocToNode({
+		node: isExportable ? exportNamed(declaration, "type") : declaration,
 		comments
-	});
+	}));
 }
 /**
-* Converts an enum member value to a literal expression. Numbers become numeric literals (negatives use a prefix
-* minus, as `createNumericLiteral` rejects them) unless `asNumber` is `false`, which emits the string form.
+* Converts an enum member value to a literal. Numbers become numeric literals unless `asNumber` is `false`,
+* which emits the string form.
 */
 function valueToExpression(value, asNumber = isNumber(value)) {
-	if (typeof value === "boolean") return value ? factory.createTrue() : factory.createFalse();
-	if (asNumber && isNumber(value)) return value < 0 ? factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))) : factory.createNumericLiteral(value);
-	return factory.createStringLiteral(value.toString());
+	return literal(typeof value === "boolean" || asNumber && isNumber(value) ? value : value.toString());
 }
 /**
 * Apply casing transformation to enum keys
@@ -484,7 +569,7 @@ function applyEnumKeyCasing(key, casing = "none") {
 }
 /**
 * Creates a TypeScript enum declaration or equivalent construct in various formats.
-* Returns a tuple of [name node, type node] - name node may be undefined for certain types.
+* Returns a tuple of [name declaration, type declaration] - the name declaration may be undefined for certain types.
 *
 * @example
 * ```ts
@@ -497,126 +582,135 @@ function applyEnumKeyCasing(key, casing = "none") {
 * ```
 */
 function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCasing = "none" }) {
-	if (type === "literal" || type === "inlineLiteral") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
-		if (isNumber(value)) {
-			if (value < 0) return factory.createLiteralTypeNode(factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))));
-			return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()));
-		}
-		if (typeof value === "boolean") return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
-		if (value !== null && value !== void 0) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
-	}).filter((node) => node !== void 0)))];
-	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value, description]) => {
-		const initializer = valueToExpression(value, Number.parseInt(value.toString(), 10) === value);
-		if (isNumber(Number.parseInt(key.toString(), 10))) {
-			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
-			return appendJSDocToNode({
-				node: factory.createEnumMember(propertyName(casingKey), initializer),
-				comments: [description]
-			});
-		}
-		if (key !== null && key !== void 0) {
-			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
+	const typeAlias = (annotation) => createTypeDeclaration({
+		syntax: "type",
+		isExportable: true,
+		name: typeName,
+		comments: [],
+		type: annotation
+	});
+	if (type === "literal" || type === "inlineLiteral") {
+		const members = enums.map(([_key, value]) => isNonNullable$1(value) ? {
+			type: "TSLiteralType",
+			literal: valueToExpression(value)
+		} : void 0).filter(isNonNullable$1);
+		return [void 0, typeAlias(members.length ? createUnionDeclaration({ nodes: members }) : keywordTypeNodes.never)];
+	}
+	if (type === "enum" || type === "constEnum") {
+		const members = enums.map(([key, value, description]) => {
+			const initializer = valueToExpression(value, Number.parseInt(value.toString(), 10) === value);
+			const memberName = isNumber(Number.parseInt(key.toString(), 10)) ? `${typeName}_${key}` : key?.toString();
+			if (memberName === void 0) return void 0;
 			return appendJSDocToNode({
-				node: factory.createEnumMember(propertyName(casingKey), initializer),
+				node: {
+					type: "TSEnumMember",
+					id: propertyName(applyEnumKeyCasing(memberName, enumKeyCasing)),
+					initializer
+				},
 				comments: [description]
 			});
-		}
-	}).filter((member) => member !== void 0))];
+		}).filter(isNonNullable$1);
+		return [void 0, print(exportNamed({
+			type: "TSEnumDeclaration",
+			declare: false,
+			const: type === "constEnum",
+			id: identifier(typeName),
+			body: {
+				type: "TSEnumBody",
+				members
+			}
+		}, "value"))];
+	}
 	const identifierName = name;
-	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword))];
-	return [factory.createVariableStatement([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value, description]) => {
-		const initializer = valueToExpression(value);
-		if (key !== null && key !== void 0) {
-			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
-			return appendJSDocToNode({
-				node: factory.createPropertyAssignment(propertyName(casingKey), initializer),
-				comments: [description]
-			});
+	if (enums.length === 0) return [void 0, typeAlias(keywordTypeNodes.never)];
+	const properties = enums.map(([key, value, description]) => {
+		if (key === null || key === void 0) return void 0;
+		return print(appendJSDocToNode({
+			node: {
+				type: "Property",
+				kind: "init",
+				key: propertyName(applyEnumKeyCasing(key.toString(), enumKeyCasing)),
+				value: valueToExpression(value),
+				computed: false,
+				method: false,
+				shorthand: false
+			},
+			comments: [description]
+		}));
+	}).filter(isNonNullable$1);
+	const query = {
+		type: "TSTypeQuery",
+		exprName: identifier(identifierName),
+		typeArguments: null
+	};
+	return [`export const ${identifierName} = {\n${properties.map(indent).join(",\n")},\n} as const;`, typeAlias({
+		type: "TSIndexedAccessType",
+		objectType: {
+			type: "TSParenthesizedType",
+			typeAnnotation: query
+		},
+		indexType: {
+			type: "TSTypeOperator",
+			operator: "keyof",
+			typeAnnotation: query
 		}
-	}).filter((property) => property !== void 0), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], typescript.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(typescript.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(typescript.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
+	})];
 }
 /**
-* Creates a TypeScript `Omit<T, Keys>` type reference node.
+* Creates a TypeScript `Omit<T, Keys>` type reference.
 * Optionally wraps the type in `NonNullable<T>` if `nonNullable` is true.
 */
 function createOmitDeclaration({ keys, type, nonNullable }) {
-	const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier("NonNullable"), [type]) : type;
-	if (Array.isArray(keys)) return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createUnionTypeNode(keys.map((key) => {
-		return factory.createLiteralTypeNode(factory.createStringLiteral(key));
-	}))]);
-	return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))]);
+	return createTypeReferenceNode("Omit", [nonNullable ? createTypeReferenceNode("NonNullable", [type]) : type, createUnionDeclaration({ nodes: [keys].flat().map(createLiteralType) })]);
 }
 /**
-* Pre-built TypeScript keyword type nodes for common primitive types.
-* Use these to avoid repeatedly creating the same type nodes.
+* TypeScript keyword types for common primitive types.
 */
 const keywordTypeNodes = {
-	any: factory.createKeywordTypeNode(typescript.SyntaxKind.AnyKeyword),
-	unknown: factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword),
-	void: factory.createKeywordTypeNode(typescript.SyntaxKind.VoidKeyword),
-	number: factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword),
-	integer: factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword),
-	bigint: factory.createKeywordTypeNode(typescript.SyntaxKind.BigIntKeyword),
-	object: factory.createKeywordTypeNode(typescript.SyntaxKind.ObjectKeyword),
-	string: factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword),
-	boolean: factory.createKeywordTypeNode(typescript.SyntaxKind.BooleanKeyword),
-	undefined: factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword),
-	null: factory.createLiteralTypeNode(factory.createToken(typescript.SyntaxKind.NullKeyword)),
-	never: factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword)
+	any: { type: "TSAnyKeyword" },
+	unknown: { type: "TSUnknownKeyword" },
+	void: { type: "TSVoidKeyword" },
+	number: { type: "TSNumberKeyword" },
+	integer: { type: "TSNumberKeyword" },
+	bigint: { type: "TSBigIntKeyword" },
+	object: { type: "TSObjectKeyword" },
+	string: { type: "TSStringKeyword" },
+	boolean: { type: "TSBooleanKeyword" },
+	undefined: { type: "TSUndefinedKeyword" },
+	null: { type: "TSNullKeyword" },
+	never: { type: "TSNeverKeyword" }
 };
 /**
-* Converts a path like '/pet/{petId}/uploadImage' to a template literal type
-* like `/pet/${string}/uploadImage`
-*/
-/**
 * Converts an OAS-style path (e.g. `/pets/{petId}`) or an Express-style path
 * (e.g. `/pets/:petId`) to a TypeScript template literal type
 * like `` `/pets/${string}` ``.
 */
 function createUrlTemplateType(path) {
 	const normalized = path.replace(/:([^/]+)/g, "{$1}");
-	if (!normalized.includes("{")) return factory.createLiteralTypeNode(factory.createStringLiteral(normalized));
-	const segments = normalized.split(/(\{[^}]+\})/);
-	const parts = [];
-	const parameterIndices = [];
-	segments.forEach((segment) => {
-		if (segment.startsWith("{") && segment.endsWith("}")) {
-			parameterIndices.push(parts.length);
-			parts.push(segment);
-		} else if (segment) parts.push(segment);
-	});
-	const head = typescript.factory.createTemplateHead(parts[0] || "");
-	const templateSpans = [];
-	parameterIndices.forEach((paramIndex, i) => {
-		const isLast = i === parameterIndices.length - 1;
-		const nextPart = parts[paramIndex + 1] || "";
-		const literal = isLast ? typescript.factory.createTemplateTail(nextPart) : typescript.factory.createTemplateMiddle(nextPart);
-		templateSpans.push(typescript.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal));
-	});
-	return typescript.factory.createTemplateLiteralType(head, templateSpans);
+	if (!normalized.includes("{")) return createLiteralType(normalized);
+	const segments = normalized.split(/\{[^}]+\}/);
+	return {
+		type: "TSTemplateLiteralType",
+		quasis: segments.map((cooked, i) => ({
+			type: "TemplateElement",
+			value: { cooked },
+			tail: i === segments.length - 1
+		})),
+		types: segments.slice(1).map(() => keywordTypeNodes.string)
+	};
 }
 /**
-* Creates a TypeScript type literal node (anonymous object type).
-*/
-const createTypeLiteralNode = factory.createTypeLiteralNode;
-/**
-* Creates a TypeScript type reference node (e.g., `Array<string>`, `Record<K, V>`).
-*/
-const createTypeReferenceNode = factory.createTypeReferenceNode;
-/**
-* Converts a primitive const value to a TypeScript literal type node.
-* Handles negative numbers via a prefix unary expression.
+* Converts a primitive const value to a TypeScript literal type.
 */
 function constToTypeNode(value, format) {
-	if (format === "boolean") return factory.createLiteralTypeNode(value === true ? factory.createTrue() : factory.createFalse());
-	const literal = format === "number" && typeof value === "number" ? value : String(value);
-	return factory.createLiteralTypeNode(valueToExpression(literal));
+	if (format === "boolean") return createLiteralType(value === true);
+	return createLiteralType(format === "number" && typeof value === "number" ? value : String(value));
 }
 /**
-* Returns a `Date` reference type node when `representation` is `'date'`, otherwise falls back to `string`.
+* Returns a `Date` reference type when `representation` is `'date'`, otherwise falls back to `string`.
 */
 function dateOrStringNode(node) {
-	return node.representation === "date" ? createTypeReferenceNode(factory.createIdentifier("Date")) : keywordTypeNodes.string;
+	return node.representation === "date" ? createTypeReferenceNode("Date") : keywordTypeNodes.string;
 }
 /**
 * Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.
@@ -625,7 +719,7 @@ function buildMemberNodes(members, print) {
 	return (members ?? []).map(print).filter(isNonNullable$1);
 }
 /**
-* Builds a TypeScript tuple type node from an array schema's `items`,
+* Builds a TypeScript tuple type from an array schema's `items`,
 * applying min/max slice and optional/rest element rules.
 */
 function buildTupleNode(node, print) {
@@ -636,9 +730,21 @@ function buildTupleNode(node, print) {
 		items = items.slice(0, max);
 		if (items.length < max && restNode) items = [...items, ...Array(max - items.length).fill(restNode)];
 	}
-	if (min !== void 0) items = items.map((item, i) => i >= min ? factory.createOptionalTypeNode(item) : item);
-	if (max === void 0 && restNode) items.push(factory.createRestTypeNode(factory.createArrayTypeNode(restNode)));
-	return factory.createTupleTypeNode(items);
+	if (min !== void 0) items = items.map((item, i) => i >= min ? {
+		type: "TSOptionalType",
+		typeAnnotation: item
+	} : item);
+	if (max === void 0 && restNode) items.push({
+		type: "TSRestType",
+		typeAnnotation: {
+			type: "TSArrayType",
+			elementType: restNode
+		}
+	});
+	return {
+		type: "TSTupleType",
+		elementTypes: items
+	};
 }
 /**
 * Appends `| null` and then `| undefined` to a type when requested.
@@ -655,8 +761,6 @@ function buildPropertyType(schema, baseType, optionalType, optional) {
 	const meta = (0, kubb_kit.syncSchemaRef)(schema);
 	return wrapNullableOptional(baseType, !!meta.nullable, addsUndefined && !!(optional || meta.nullish || meta.optional));
 }
-const indexSignaturePrinter = typescript.createPrinter();
-const indexSignatureSource = typescript.createSourceFile("", "", typescript.ScriptTarget.Latest);
 /**
 * Creates a TypeScript index signature for `additionalProperties` and `patternProperties` on an
 * object schema node. TypeScript allows only one string index signature and its value must be
@@ -664,21 +768,35 @@ const indexSignatureSource = typescript.createSourceFile("", "", typescript.Scri
 * union of all value types (deduplicated), or `unknown` when the object also has fixed properties.
 * The key regex of `patternProperties` cannot be expressed by an index signature and is dropped.
 */
-function buildIndexSignatures(node, propertyCount, print) {
+function buildIndexSignatures(node, propertyCount, printNode) {
 	const valueTypes = [];
-	if (node.additionalProperties && node.additionalProperties !== true) valueTypes.push(print(node.additionalProperties) ?? keywordTypeNodes.unknown);
+	if (node.additionalProperties && node.additionalProperties !== true) valueTypes.push(printNode(node.additionalProperties) ?? keywordTypeNodes.unknown);
 	else if (node.additionalProperties === true) valueTypes.push(keywordTypeNodes.unknown);
 	for (const schema of Object.values(node.patternProperties ?? {})) {
-		const patternType = print(schema) ?? keywordTypeNodes.unknown;
+		const patternType = printNode(schema) ?? keywordTypeNodes.unknown;
 		valueTypes.push(schema.nullable ? createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] }) : patternType);
 	}
 	if (valueTypes.length === 0) return [];
-	const seen = /* @__PURE__ */ new Set();
-	const distinct = valueTypes.filter((type) => {
-		const key = indexSignaturePrinter.printNode(typescript.EmitHint.Unspecified, type, indexSignatureSource);
-		return seen.has(key) ? false : (seen.add(key), true);
-	});
-	return [createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : createUnionDeclaration({ nodes: distinct }))];
+	const distinct = [...new Map(valueTypes.map((type) => [print(type), type])).values()];
+	const valueType = propertyCount > 0 ? keywordTypeNodes.unknown : createUnionDeclaration({ nodes: distinct });
+	return [{
+		type: "TSIndexSignature",
+		parameters: [{
+			type: "Identifier",
+			name: "key",
+			typeAnnotation: {
+				type: "TSTypeAnnotation",
+				typeAnnotation: keywordTypeNodes.string
+			}
+		}],
+		typeAnnotation: {
+			type: "TSTypeAnnotation",
+			typeAnnotation: valueType
+		},
+		readonly: false,
+		static: false,
+		accessibility: null
+	}];
 }
 //#endregion
 //#region src/components/Enum.tsx
@@ -733,7 +851,7 @@ function Enum({ node, enum: enumOptions, resolver }) {
 		isExportable: true,
 		isIndexable: true,
 		isTypeOnly: false,
-		children: (0, _kubb_parser_ts.parserTs)().print(nameNode)
+		children: nameNode
 	}), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name: typeName,
 		isIndexable: !namesMerge,
@@ -743,7 +861,7 @@ function Enum({ node, enum: enumOptions, resolver }) {
 			"literal",
 			void 0
 		].includes(enumOptions.type),
-		children: (0, _kubb_parser_ts.parserTs)().print(typeNode)
+		children: typeNode
 	})] });
 }
 //#endregion
@@ -1197,12 +1315,30 @@ function Type({ name, node, printer, enum: enumOptions, resolver }) {
 //#region src/printers/printerTs.ts
 const { isNonNullable } = factory_exports;
 /**
+* Adapts user overrides, which work in strings, to the node-based printer: `this.transform` hands them printed
+* strings and their result is wrapped back into a node. A deprecated compiler node prints through `@kubb/parser-ts`.
+*/
+function toNodeHandlers(nodes) {
+	return Object.fromEntries(Object.entries(nodes ?? {}).map(([type, handler]) => [type, function(node) {
+		const transform = (child) => {
+			const output = this.transform(child);
+			return output ? print(output) : null;
+		};
+		const result = handler.call({
+			...this,
+			transform
+		}, node);
+		if (result === null || result === void 0) return result;
+		return createRaw(typeof result === "string" ? result : (0, _kubb_parser_ts.parserTs)().print(result).trimEnd());
+	}]));
+}
+/**
 * TypeScript type printer built with `definePrinter`.
 *
-* Converts a `SchemaNode` AST node into a TypeScript AST node:
-* - **`printer.print(node)`** — when `options.typeName` is set, returns a full
-*   `type Name = …` or `interface Name { … }` declaration (`ts.Node`).
-*   Without `typeName`, returns the raw `ts.TypeNode` for the schema.
+* Converts a `SchemaNode` AST node into TypeScript source:
+* - **`printer.print(node)`** — when `options.name` is set, returns a full
+*   `type Name = …` or `interface Name { … }` declaration.
+*   Without `name`, returns the type for the schema, such as `string | null`.
 *
 * Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
 * over per printer instance, so each call to `printerTs(options)` produces an independent printer.
@@ -1210,13 +1346,13 @@ const { isNonNullable } = factory_exports;
 * @example Raw type node (no `typeName`)
 * ```ts
 * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })
-* const typeNode = printer.print(schemaNode) // ts.TypeNode
+* const type = printer.print(schemaNode) // 'string | null'
 * ```
 *
 * @example Full declaration (with `typeName`)
 * ```ts
 * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })
-* const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
+* const declaration = printer.print(schemaNode) // 'export type MyType = …'
 * ```
 */
 const printerTs = kubb_kit.ast.createPrinter((options) => {
@@ -1231,7 +1367,7 @@ const printerTs = kubb_kit.ast.createPrinter((options) => {
 			never: () => keywordTypeNodes.never,
 			boolean: () => keywordTypeNodes.boolean,
 			null: () => keywordTypeNodes.null,
-			blob: () => createTypeReferenceNode("Blob", []),
+			blob: () => createTypeReferenceNode("Blob"),
 			string: () => keywordTypeNodes.string,
 			uuid: () => keywordTypeNodes.string,
 			email: () => keywordTypeNodes.string,
@@ -1251,27 +1387,22 @@ const printerTs = kubb_kit.ast.createPrinter((options) => {
 				if (!node.name) return null;
 				const refName = kubb_kit.ast.resolveRefName(node);
 				if (!refName) return null;
-				const name = node.ref ? enumTypeName({
+				return createTypeReferenceNode(node.ref ? enumTypeName({
 					resolver: this.options.resolver,
 					name: refName,
 					enumOptions: this.options.enum,
 					isEnum: !!this.options.enumSchemaNames?.has(refName)
-				}) : refName;
-				return createTypeReferenceNode(name, void 0);
+				}) : refName);
 			},
 			enum(node) {
 				const values = kubb_kit.ast.getSchemaLiteralValues(node);
-				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({
-					withParentheses: true,
-					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable)
-				});
-				const resolvedName = enumTypeName({
+				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({ nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable) });
+				return createTypeReferenceNode(enumTypeName({
 					resolver: this.options.resolver,
 					name: node.name,
 					enumOptions: this.options.enum,
 					isEnum: true
-				});
-				return createTypeReferenceNode(resolvedName, void 0);
+				}));
 			},
 			union(node) {
 				const members = node.members ?? [];
@@ -1279,26 +1410,14 @@ const printerTs = kubb_kit.ast.createPrinter((options) => {
 					return kubb_kit.ast.narrowSchema(m, kubb_kit.ast.schemaTypes.enum)?.primitive === "string";
 				});
 				const hasPlainString = members.some((m) => (0, kubb_kit.isStringType)(m));
-				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
-					withParentheses: true,
-					nodes: members.map((m) => {
-						if ((0, kubb_kit.isStringType)(m)) return createIntersectionDeclaration({
-							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
-							withParentheses: true
-						});
-						return this.transform(m);
-					}).filter(isNonNullable)
-				});
-				return createUnionDeclaration({
-					withParentheses: true,
-					nodes: buildMemberNodes(members, this.transform)
-				});
+				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({ nodes: members.map((m) => {
+					if ((0, kubb_kit.isStringType)(m)) return createIntersectionDeclaration({ nodes: [keywordTypeNodes.string, createTypeLiteralNode([])] });
+					return this.transform(m);
+				}).filter(isNonNullable) });
+				return createUnionDeclaration({ nodes: buildMemberNodes(members, this.transform) });
 			},
 			intersection(node) {
-				return createIntersectionDeclaration({
-					withParentheses: true,
-					nodes: buildMemberNodes(node.members, this.transform)
-				});
+				return createIntersectionDeclaration({ nodes: buildMemberNodes(node.members, this.transform) });
 			},
 			array(node) {
 				return createArrayDeclaration({
@@ -1331,35 +1450,30 @@ const printerTs = kubb_kit.ast.createPrinter((options) => {
 				if (!allElements.length) return keywordTypeNodes.object;
 				return createTypeLiteralNode(allElements);
 			},
-			...options.nodes
+			...toNodeHandlers(options.nodes)
 		},
 		print(node) {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
 			const meta = (0, kubb_kit.syncSchemaRef)(node);
-			if (!name) {
-				const result = wrapNullableOptional(transformed, !!meta.nullable, !!(meta.nullish || meta.optional) && addsUndefined);
-				return (0, _kubb_parser_ts.parserTs)().print(result);
-			}
-			const inner = (() => {
-				return wrapNullableOptional(keysToOmit?.length ? createOmitDeclaration({
-					keys: keysToOmit,
-					type: transformed,
-					nonNullable: true
-				}) : transformed, !!meta.nullable, !!(meta.nullish || meta.optional));
-			})();
-			const typeNode = createTypeDeclaration({
+			if (!name) return print(wrapNullableOptional(transformed, !!meta.nullable, !!(meta.nullish || meta.optional) && addsUndefined));
+			return createTypeDeclaration({
 				name,
 				isExportable: true,
-				type: inner,
-				syntax: syntaxType === "type" || isUnionTypeNode(inner) || !!keysToOmit?.length ? "type" : "interface",
+				type: (() => {
+					return wrapNullableOptional(keysToOmit?.length ? createOmitDeclaration({
+						keys: keysToOmit,
+						type: transformed,
+						nonNullable: true
+					}) : transformed, !!meta.nullable, !!(meta.nullish || meta.optional));
+				})(),
+				syntax: syntaxType === "type" || !!keysToOmit?.length ? "type" : "interface",
 				comments: buildPropertyJSDocComments({
 					...meta,
 					description
 				})
 			});
-			return (0, _kubb_parser_ts.parserTs)().print(typeNode);
 		}
 	};
 });
@@ -1642,7 +1756,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.1.0-canary.20261023T200213";
+var version = "5.2.0-canary.20261024T091509";
 //#endregion
 //#region src/resolvers/resolverTs.ts
 /**