@kubb/plugin-ts 5.0.3 → 5.0.5

package/README.md

@@ -10,7 +10,7 @@
 [![Node][node-src]][node-href]
 
 <h4>
-<a href="https://kubb.dev/plugins/ts" target="_blank">Documentation</a>
+<a href="https://kubb.dev/plugins/plugin-ts" target="_blank">Documentation</a>
 <span> · </span>
 <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
 <span> · </span>
@@ -38,7 +38,7 @@ npm install @kubb/plugin-ts
 
 ## Documentation
 
-See the [full documentation](https://kubb.dev/plugins/ts) for configuration options and examples.
+See the [full documentation](https://kubb.dev/plugins/plugin-ts) for configuration options and examples.
 
 ## Supporting Kubb
 

package/dist/index.cjs

@@ -3,16 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 //#region \0rolldown/runtime.js
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", {
 	value,
 	configurable: true
 });
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -22,26 +17,11 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
 //#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 typescript = require("typescript");
-typescript = __toESM(typescript, 1);
 let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -401,7 +381,12 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	modifiers: () => modifiers,
 	syntaxKind: () => syntaxKind
 });
-const { SyntaxKind, factory } = typescript.default;
+/**
+* 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");
+const { SyntaxKind, factory } = typescript;
 /**
 * Compares two strings by UTF-16 code unit, keeping sorted output identical across platforms
 * regardless of locale.
@@ -418,10 +403,10 @@ function isNumber(value) {
 * TypeScript AST modifiers for common keywords (async, export, const, static).
 */
 const modifiers = {
-	async: factory.createModifier(typescript.default.SyntaxKind.AsyncKeyword),
-	export: factory.createModifier(typescript.default.SyntaxKind.ExportKeyword),
-	const: factory.createModifier(typescript.default.SyntaxKind.ConstKeyword),
-	static: factory.createModifier(typescript.default.SyntaxKind.StaticKeyword)
+	async: factory.createModifier(typescript.SyntaxKind.AsyncKeyword),
+	export: factory.createModifier(typescript.SyntaxKind.ExportKeyword),
+	const: factory.createModifier(typescript.SyntaxKind.ConstKeyword),
+	static: factory.createModifier(typescript.SyntaxKind.StaticKeyword)
 };
 /**
 * TypeScript syntax kind constants for union, literal, and string types.
@@ -438,10 +423,10 @@ __name(isNonNullable$1, "isNonNullable");
 function isValidIdentifier(str) {
 	if (!str.length || str.trim() !== str) return false;
 	let ch = str.codePointAt(0);
-	if (!typescript.default.isIdentifierStart(ch, typescript.default.ScriptTarget.Latest)) return false;
+	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.default.isIdentifierPart(ch, typescript.default.ScriptTarget.Latest)) return false;
+		if (!typescript.isIdentifierPart(ch, typescript.ScriptTarget.Latest)) return false;
 	}
 	return true;
 }
@@ -449,7 +434,7 @@ function propertyName(name) {
 	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
 	return name;
 }
-const questionToken = factory.createToken(typescript.default.SyntaxKind.QuestionToken);
+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.
@@ -509,7 +494,7 @@ function createUnionDeclaration({ nodes, withParentheses }) {
 * Supports optional markers, readonly modifiers, and type annotations.
 */
 function createPropertySignature({ readOnly, modifiers = [], name, questionToken, type }) {
-	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(typescript.default.SyntaxKind.ReadonlyKeyword) : void 0].filter((modifier) => modifier !== void 0), propertyName(name), createQuestionToken(questionToken), type);
+	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(typescript.SyntaxKind.ReadonlyKeyword) : void 0].filter((modifier) => modifier !== void 0), propertyName(name), createQuestionToken(questionToken), type);
 }
 /**
 * Creates a function parameter declaration with optional markers, rest parameters, and type annotations.
@@ -540,13 +525,13 @@ function appendJSDocToNode({ node, comments }) {
 	const text = filteredComments.reduce((acc = "", comment = "") => {
 		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
 	}, "*");
-	return typescript.default.addSyntheticLeadingComment(node, typescript.default.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
+	return typescript.addSyntheticLeadingComment(node, typescript.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
 }
 /**
 * Creates a TypeScript index signature for dynamic property access.
 * Defines the key type (default: `string`) and value type on an object.
 */
-function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(typescript.default.SyntaxKind.StringKeyword) } = {}) {
+function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword) } = {}) {
 	return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type);
 }
 /**
@@ -566,7 +551,7 @@ function createInterfaceDeclaration({ modifiers, name, typeParameters, members }
 * Intelligently selects the syntax based on the type structure and attaches JSDoc comments.
 */
 function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
-	if (syntax === "interface" && typescript.default.isTypeLiteralNode(type)) return appendJSDocToNode({
+	if (syntax === "interface" && typescript.isTypeLiteralNode(type)) return appendJSDocToNode({
 		node: createInterfaceDeclaration({
 			members: [...type.members],
 			modifiers: isExportable ? [modifiers.export] : [],
@@ -655,18 +640,18 @@ 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.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
+	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.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(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.default.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.default.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value, description]) => {
+	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]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
 		if (Number.parseInt(value.toString(), 10) === value && isNumber(value)) {
-			if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 			else initializer = factory.createNumericLiteral(value);
 		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
@@ -686,11 +671,11 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		}
 	}).filter((member) => member !== void 0))];
 	const identifierName = name;
-	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(typescript.default.SyntaxKind.NeverKeyword))];
-	return [factory.createVariableStatement([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value, description]) => {
+	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]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
 		if (isNumber(value)) {
-			if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+			if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
 			else initializer = factory.createNumericLiteral(value);
 		}
 		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
@@ -701,7 +686,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 				comments: [description]
 			});
 		}
-	}).filter((property) => property !== void 0), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], typescript.default.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(typescript.default.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(typescript.default.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
+	}).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.
@@ -719,18 +704,18 @@ function createOmitDeclaration({ keys, type, nonNullable }) {
 * Use these to avoid repeatedly creating the same type nodes.
 */
 const keywordTypeNodes = {
-	any: factory.createKeywordTypeNode(typescript.default.SyntaxKind.AnyKeyword),
-	unknown: factory.createKeywordTypeNode(typescript.default.SyntaxKind.UnknownKeyword),
-	void: factory.createKeywordTypeNode(typescript.default.SyntaxKind.VoidKeyword),
-	number: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NumberKeyword),
-	integer: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NumberKeyword),
-	bigint: factory.createKeywordTypeNode(typescript.default.SyntaxKind.BigIntKeyword),
-	object: factory.createKeywordTypeNode(typescript.default.SyntaxKind.ObjectKeyword),
-	string: factory.createKeywordTypeNode(typescript.default.SyntaxKind.StringKeyword),
-	boolean: factory.createKeywordTypeNode(typescript.default.SyntaxKind.BooleanKeyword),
-	undefined: factory.createKeywordTypeNode(typescript.default.SyntaxKind.UndefinedKeyword),
-	null: factory.createLiteralTypeNode(factory.createToken(typescript.default.SyntaxKind.NullKeyword)),
-	never: factory.createKeywordTypeNode(typescript.default.SyntaxKind.NeverKeyword)
+	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)
 };
 /**
 * Converts a path like '/pet/{petId}/uploadImage' to a template literal type
@@ -753,15 +738,15 @@ function createUrlTemplateType(path) {
 			parts.push(segment);
 		} else if (segment) parts.push(segment);
 	});
-	const head = typescript.default.factory.createTemplateHead(parts[0] || "");
+	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.default.factory.createTemplateTail(nextPart) : typescript.default.factory.createTemplateMiddle(nextPart);
-		templateSpans.push(typescript.default.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal));
+		const literal = isLast ? typescript.factory.createTemplateTail(nextPart) : typescript.factory.createTemplateMiddle(nextPart);
+		templateSpans.push(typescript.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal));
 	});
-	return typescript.default.factory.createTemplateLiteralType(head, templateSpans);
+	return typescript.factory.createTemplateLiteralType(head, templateSpans);
 }
 /**
 * Creates a TypeScript type literal node (anonymous object type).
@@ -866,8 +851,8 @@ function buildPropertyType(schema, baseType, optionalType, optional) {
 	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 	return type;
 }
-const indexSignaturePrinter = typescript.default.createPrinter();
-const indexSignatureSource = typescript.default.createSourceFile("", "", typescript.default.ScriptTarget.Latest);
+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
@@ -886,7 +871,7 @@ function buildIndexSignatures(node, propertyCount, print) {
 	if (valueTypes.length === 0) return [];
 	const seen = /* @__PURE__ */ new Set();
 	const distinct = valueTypes.filter((type) => {
-		const key = indexSignaturePrinter.printNode(typescript.default.EmitHint.Unspecified, type, indexSignatureSource);
+		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 }))];
@@ -954,115 +939,6 @@ function Enum({ node, enum: enumOptions, resolver }) {
 	})] });
 }
 //#endregion
-//#region src/utils.ts
-/**
-* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
-* rather than a named enum reference or a runtime enum declaration.
-*
-* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
-* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
-* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
-* a named enum, which keeps the declaration and its references in sync across adapter versions.
-*/
-function isInlineConstEnum(node, enumSchemaNames) {
-	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
-}
-/**
-* Collects JSDoc annotation strings for a schema node.
-*
-* Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
-* Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
-
-*/
-function isSchemaOptional(schema) {
-	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
-}
-function formatExample(value) {
-	if (value === null || typeof value !== "object") return String(value);
-	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
-}
-function buildPropertyJSDocComments(schema, optional) {
-	const meta = (0, kubb_kit.syncSchemaRef)(schema);
-	const isArray = meta?.primitive === "array";
-	const hasDescription = meta && "description" in meta && meta.description;
-	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
-	const exampleValues = meta?.examples ?? [];
-	const comments = [
-		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
-		...formatComment,
-		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
-		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
-		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
-		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
-		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
-		...exampleValues.map((example) => `@example ${formatExample(example)}`)
-	].filter(Boolean);
-	const typeTag = comments.length && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
-	return [...comments, typeTag].filter(Boolean);
-}
-/**
-* Builds the object schema for a group of parameters sharing one `in` location (path, query, or
-* header), embedding each param's own schema (and JSDoc) directly rather than referencing a
-* separate per-param type — the group itself is the only type these params get exported as.
-*/
-function buildParams({ params }) {
-	return kubb_kit.ast.factory.createSchema({
-		type: "object",
-		properties: params.map((param) => kubb_kit.ast.factory.createProperty({
-			name: param.name,
-			required: param.required,
-			schema: kubb_kit.ast.factory.createSchema({
-				...param.schema,
-				optional: !param.required
-			})
-		}))
-	});
-}
-function buildResponseUnion(node, { resolver }) {
-	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
-	if (responsesWithSchema.length === 0) return null;
-	return kubb_kit.ast.factory.createSchema({
-		type: "union",
-		members: responsesWithSchema.map((res) => kubb_kit.ast.factory.createSchema({
-			type: "ref",
-			name: resolver.response.status(node, res.statusCode)
-		}))
-	});
-}
-//#endregion
-//#region src/components/Type.tsx
-function Type({ name, node, printer, enum: enumOptions, resolver }) {
-	const enumSchemaNodes = kubb_kit.ast.collectSync(node, { schema(n) {
-		const enumNode = kubb_kit.ast.narrowSchema(n, kubb_kit.ast.schemaTypes.enum);
-		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
-	} });
-	const output = printer.print(node);
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			node,
-			...getEnumNames({
-				node,
-				enum: enumOptions,
-				resolver
-			})
-		};
-	});
-	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
-	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Enum, {
-		node,
-		enum: enumOptions,
-		resolver
-	}, node.name)), shouldExportType && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
-		name,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
-}
-//#endregion
 //#region ../../internals/shared/src/params.ts
 /**
 * Drops parameters that share the same name, keeping the first.
@@ -1262,6 +1138,14 @@ function buildResponses(node, resolver) {
 		}))
 	});
 }
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
 //#endregion
 //#region ../../internals/shared/src/resolver.ts
 /**
@@ -1412,6 +1296,117 @@ function mapSchemaItems(node, transform) {
 	}));
 }
 //#endregion
+//#region src/utils.ts
+/**
+* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
+* rather than a named enum reference or a runtime enum declaration.
+*
+* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
+* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
+* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
+* a named enum, which keeps the declaration and its references in sync across adapter versions.
+*/
+function isInlineConstEnum(node, enumSchemaNames) {
+	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
+}
+/**
+* Collects JSDoc annotation strings for a schema node.
+*
+* Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
+* Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
+
+*/
+function isSchemaOptional(schema) {
+	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
+}
+function formatExample(value) {
+	if (value === null || typeof value !== "object") return String(value);
+	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
+}
+function buildPropertyJSDocComments(schema, optional) {
+	const meta = (0, kubb_kit.syncSchemaRef)(schema);
+	const isArray = meta?.primitive === "array";
+	const hasDescription = meta && "description" in meta && meta.description;
+	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
+	const exampleValues = meta?.examples ?? [];
+	const comments = [
+		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
+		...formatComment,
+		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
+		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
+		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
+		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
+		...exampleValues.map((example) => `@example ${formatExample(example)}`)
+	].filter(Boolean);
+	const typeTag = comments.length && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
+	return [...comments, typeTag].filter(Boolean);
+}
+/**
+* Builds the object schema for a group of parameters sharing one `in` location (path, query, or
+* header), embedding each param's own schema (and JSDoc) directly rather than referencing a
+* separate per-param type — the group itself is the only type these params get exported as.
+*/
+function buildParams({ params }) {
+	return kubb_kit.ast.factory.createSchema({
+		type: "object",
+		properties: params.map((param) => kubb_kit.ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: kubb_kit.ast.factory.createSchema({
+				...param.schema,
+				optional: !param.required
+			})
+		}))
+	});
+}
+function buildResponseUnion(node, { resolver }) {
+	const allWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
+	const successWithSchema = allWithSchema.filter((res) => isSuccessStatusCode(res.statusCode));
+	const responsesWithSchema = successWithSchema.length > 0 ? successWithSchema : allWithSchema;
+	if (responsesWithSchema.length === 0) return null;
+	return kubb_kit.ast.factory.createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => kubb_kit.ast.factory.createSchema({
+			type: "ref",
+			name: resolver.response.status(node, res.statusCode)
+		}))
+	});
+}
+//#endregion
+//#region src/components/Type.tsx
+function Type({ name, node, printer, enum: enumOptions, resolver }) {
+	const enumSchemaNodes = kubb_kit.ast.collectSync(node, { schema(n) {
+		const enumNode = kubb_kit.ast.narrowSchema(n, kubb_kit.ast.schemaTypes.enum);
+		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
+	} });
+	const output = printer.print(node);
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames({
+				node,
+				enum: enumOptions,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Enum, {
+		node,
+		enum: enumOptions,
+		resolver
+	}, node.name)), shouldExportType && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
+}
+//#endregion
 //#region src/printers/printerTs.ts
 const { isNonNullable } = factory_exports;
 /**