@kubb/plugin-ts 5.0.10 → 5.0.12

package/dist/index.js

@@ -292,47 +292,6 @@ function toFilePath(name, caseLast = camelCase) {
 	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
-//#region src/constants.ts
-/**
-* `optionalType` values that cause a property's type to include `| undefined`.
-*/
-const OPTIONAL_ADDS_UNDEFINED = /* @__PURE__ */ new Set(["undefined", "questionTokenAndUndefined"]);
-/**
-* `optionalType` values that render the property key with a `?` token.
-*/
-const OPTIONAL_ADDS_QUESTION_TOKEN = /* @__PURE__ */ new Set(["questionToken", "questionTokenAndUndefined"]);
-/**
-* `enum.type` values that append a `typeSuffix` to the generated enum type alias.
-*/
-const ENUM_TYPES_WITH_KEY_SUFFIX = /* @__PURE__ */ new Set(["asConst"]);
-/**
-* `enum.type` values that require a runtime value declaration (object, enum, or literal).
-*/
-const ENUM_TYPES_WITH_RUNTIME_VALUE = /* @__PURE__ */ new Set([
-	"enum",
-	"asConst",
-	"constEnum",
-	"literal",
-	void 0
-]);
-/**
-* `enum.type` values whose type declaration is type-only (no runtime value emitted for the type alias).
-*/
-const ENUM_TYPES_WITH_TYPE_ONLY = /* @__PURE__ */ new Set([
-	"asConst",
-	"literal",
-	void 0
-]);
-/**
-* Ordering priority for function parameters: lower = sorted earlier.
-*/
-const PARAM_RANK = {
-	required: 0,
-	optional: 1,
-	withDefault: 2,
-	rest: 3
-};
-//#endregion
 //#region src/factory.ts
 var factory_exports = /* @__PURE__ */ __exportAll({
 	appendJSDocToNode: () => appendJSDocToNode,
@@ -343,14 +302,9 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	constToTypeNode: () => constToTypeNode,
 	createArrayDeclaration: () => createArrayDeclaration,
 	createEnumDeclaration: () => createEnumDeclaration,
-	createExportDeclaration: () => createExportDeclaration,
-	createImportDeclaration: () => createImportDeclaration,
 	createIntersectionDeclaration: () => createIntersectionDeclaration,
-	createJSDoc: () => createJSDoc,
 	createOmitDeclaration: () => createOmitDeclaration,
-	createParameterSignature: () => createParameterSignature,
 	createPropertySignature: () => createPropertySignature,
-	createQuestionToken: () => createQuestionToken,
 	createTypeDeclaration: () => createTypeDeclaration,
 	createTypeLiteralNode: () => createTypeLiteralNode,
 	createTypeReferenceNode: () => createTypeReferenceNode,
@@ -358,9 +312,10 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	createUrlTemplateType: () => createUrlTemplateType,
 	dateOrStringNode: () => dateOrStringNode,
 	isNonNullable: () => isNonNullable$1,
+	isUnionTypeNode: () => isUnionTypeNode,
 	keywordTypeNodes: () => keywordTypeNodes,
 	modifiers: () => modifiers,
-	syntaxKind: () => syntaxKind
+	wrapNullableOptional: () => wrapNullableOptional
 });
 /**
 * Loaded with `require`, not `import`. When ESM imports a CommonJS package, Node keeps a second
@@ -368,35 +323,14 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 */
 const typescript = createRequire(import.meta.url)("typescript");
 const { SyntaxKind, factory } = typescript;
-/**
-* Compares two strings by UTF-16 code unit, keeping sorted output identical across platforms
-* regardless of locale.
-*/
-function compareStrings(a, b) {
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
-}
 function isNumber(value) {
 	return typeof value === "number" && !Number.isNaN(value);
 }
 /**
-* TypeScript AST modifiers for common keywords (async, export, const, static).
+* TypeScript AST modifiers for the `export` keyword.
 */
-const modifiers = {
-	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.
-*/
-const syntaxKind = {
-	union: SyntaxKind.UnionType,
-	literalType: SyntaxKind.LiteralType,
-	stringLiteral: SyntaxKind.StringLiteral
-};
+const modifiers = { export: factory.createModifier(typescript.SyntaxKind.ExportKeyword) };
+const isUnionTypeNode = typescript.isUnionTypeNode;
 function isNonNullable$1(value) {
 	return value !== null && value !== void 0;
 }
@@ -450,7 +384,6 @@ function createArrayDeclaration({ nodes, arrayType = "array" }) {
 	if (!nodes.length) return factory.createTupleTypeNode([]);
 	if (nodes.length === 1) {
 		const node = nodes[0];
-		if (!node) return null;
 		if (arrayType === "generic") return factory.createTypeReferenceNode(factory.createIdentifier("Array"), [node]);
 		return factory.createArrayTypeNode(node);
 	}
@@ -478,23 +411,6 @@ function createPropertySignature({ readOnly, modifiers = [], name, questionToken
 	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.
-*/
-function createParameterSignature(name, { modifiers, dotDotDotToken, questionToken, type, initializer }) {
-	return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer);
-}
-/**
-* Creates a JSDoc comment node from an array of comment strings.
-* Returns null if no comments are provided.
-*/
-function createJSDoc({ comments }) {
-	if (!comments.length) return null;
-	return factory.createJSDocComment(factory.createNodeArray(comments.map((comment, i) => {
-		if (i === comments.length - 1) return factory.createJSDocText(comment);
-		return factory.createJSDocText(`${comment}\n`);
-	})));
-}
-/**
 * Attaches JSDoc comments to an AST node as synthetic leading comments.
 * Filters out undefined comments before attaching.
 *
@@ -513,19 +429,7 @@ function appendJSDocToNode({ node, comments }) {
 * Defines the key type (default: `string`) and value type on an object.
 */
 function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword) } = {}) {
-	return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type);
-}
-/**
-* Creates a TypeScript type alias declaration with optional modifiers and type parameters.
-*/
-function createTypeAliasDeclaration({ modifiers, name, typeParameters, type }) {
-	return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type);
-}
-/**
-* Creates a TypeScript interface declaration with optional modifiers, type parameters, and members.
-*/
-function createInterfaceDeclaration({ modifiers, name, typeParameters, members }) {
-	return factory.createInterfaceDeclaration(modifiers, name, typeParameters, void 0, members);
+	return factory.createIndexSignature(modifiers, [factory.createParameterDeclaration(void 0, void 0, indexName, void 0, indexType)], type);
 }
 /**
 * Creates a TypeScript type declaration as either a type alias or interface.
@@ -533,67 +437,22 @@ function createInterfaceDeclaration({ modifiers, name, typeParameters, members }
 */
 function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
 	if (syntax === "interface" && typescript.isTypeLiteralNode(type)) return appendJSDocToNode({
-		node: createInterfaceDeclaration({
-			members: [...type.members],
-			modifiers: isExportable ? [modifiers.export] : [],
-			name,
-			typeParameters: void 0
-		}),
+		node: factory.createInterfaceDeclaration(isExportable ? [modifiers.export] : [], name, void 0, void 0, [...type.members]),
 		comments
 	});
 	return appendJSDocToNode({
-		node: createTypeAliasDeclaration({
-			type,
-			modifiers: isExportable ? [modifiers.export] : [],
-			name,
-			typeParameters: void 0
-		}),
+		node: factory.createTypeAliasDeclaration(isExportable ? [modifiers.export] : [], name, void 0, type),
 		comments
 	});
 }
 /**
-* Creates an import declaration with support for default imports, named imports, namespace imports, and type-only imports.
-* Optionally rename imported members with `propertyName` and `name` pairs.
-*
-* @example Default import
-* `import Pet from './Pet'`
-*
-* @example Named imports with rename
-* `import { Pet as Cat } from './Pet'`
-*
-* @example Namespace import
-* `import * as Pet from './Pet'`
-*/
-function createImportDeclaration({ name, path, isTypeOnly = false, isNameSpace = false }) {
-	if (!Array.isArray(name)) {
-		const importPropertyName = isNameSpace ? void 0 : factory.createIdentifier(name);
-		const importName = isNameSpace ? factory.createNamespaceImport(factory.createIdentifier(name)) : void 0;
-		return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, importPropertyName, importName), factory.createStringLiteral(path), void 0);
-	}
-	const sortedName = name.toSorted((a, b) => compareStrings(typeof a === "object" ? a.propertyName : a, typeof b === "object" ? b.propertyName : b));
-	return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamedImports(sortedName.map((item) => {
-		if (typeof item === "object") {
-			const obj = item;
-			if (obj.name) return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name));
-			return factory.createImportSpecifier(false, void 0, factory.createIdentifier(obj.propertyName));
-		}
-		return factory.createImportSpecifier(false, void 0, factory.createIdentifier(item));
-	}))), factory.createStringLiteral(path), void 0);
-}
-/**
-* Creates an export declaration with support for named exports, namespace exports, and type-only exports.
-* Sorts export names alphabetically for consistent output across platforms.
+* 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.
 */
-function createExportDeclaration({ path, asAlias, isTypeOnly = false, name }) {
-	if (name && !Array.isArray(name) && !asAlias) console.warn(`When using name as string, asAlias should be true ${name}`);
-	if (!Array.isArray(name)) {
-		const parsedName = name?.match(/^\d/) ? `_${name?.slice(1)}` : name;
-		return factory.createExportDeclaration(void 0, isTypeOnly, asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : void 0, factory.createStringLiteral(path), void 0);
-	}
-	const sortedName = name.toSorted((a, b) => compareStrings(typeof a === "string" ? a : a.text, typeof b === "string" ? b : b.text));
-	return factory.createExportDeclaration(void 0, isTypeOnly, factory.createNamedExports(sortedName.map((propertyName) => {
-		return factory.createExportSpecifier(false, void 0, typeof propertyName === "string" ? factory.createIdentifier(propertyName) : propertyName);
-	})), factory.createStringLiteral(path), void 0);
+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());
 }
 /**
 * Apply casing transformation to enum keys
@@ -630,12 +489,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		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]) => {
-		let initializer = factory.createStringLiteral(value?.toString());
-		if (Number.parseInt(value.toString(), 10) === value && isNumber(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();
+		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({
@@ -654,12 +508,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 	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]) => {
-		let initializer = factory.createStringLiteral(value?.toString());
-		if (isNumber(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();
+		const initializer = valueToExpression(value);
 		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
 			return appendJSDocToNode({
@@ -738,66 +587,19 @@ const createTypeLiteralNode = factory.createTypeLiteralNode;
 */
 const createTypeReferenceNode = factory.createTypeReferenceNode;
 /**
-* Creates a numeric literal type node.
-*/
-const createNumericLiteral = factory.createNumericLiteral;
-/**
-* Creates a string literal type node.
-*/
-const createStringLiteral = factory.createStringLiteral;
-/**
-* Creates an array type node (e.g., `T[]`).
-*/
-const createArrayTypeNode = factory.createArrayTypeNode;
-/**
-* Creates a literal type node (e.g., `'hello'`, `42`, `true`).
-*/
-const createLiteralTypeNode = factory.createLiteralTypeNode;
-/**
-* Creates an identifier node.
-*/
-const createIdentifier = factory.createIdentifier;
-/**
-* Creates an optional type node (e.g., `T | undefined`).
-*/
-const createOptionalTypeNode = factory.createOptionalTypeNode;
-/**
-* Creates a tuple type node (e.g., `[string, number]`).
-*/
-const createTupleTypeNode = factory.createTupleTypeNode;
-/**
-* Creates a rest type node for variadic tuple elements (e.g., `...T[]`).
-*/
-const createRestTypeNode = factory.createRestTypeNode;
-/**
-* Creates a boolean true literal type node.
-*/
-const createTrue = factory.createTrue;
-/**
-* Creates a boolean false literal type node.
-*/
-const createFalse = factory.createFalse;
-/**
-* Creates a prefix unary expression (e.g., negative numbers, logical not).
-*/
-const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
-/**
 * Converts a primitive const value to a TypeScript literal type node.
 * Handles negative numbers via a prefix unary expression.
 */
 function constToTypeNode(value, format) {
-	if (format === "boolean") return createLiteralTypeNode(value === true ? createTrue() : createFalse());
-	if (format === "number" && typeof value === "number") {
-		if (value < 0) return createLiteralTypeNode(createPrefixUnaryExpression(SyntaxKind.MinusToken, createNumericLiteral(Math.abs(value))));
-		return createLiteralTypeNode(createNumericLiteral(value));
-	}
-	return createLiteralTypeNode(createStringLiteral(String(value)));
+	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));
 }
 /**
 * Returns a `Date` reference type node when `representation` is `'date'`, otherwise falls back to `string`.
 */
 function dateOrStringNode(node) {
-	return node.representation === "date" ? createTypeReferenceNode(createIdentifier("Date")) : keywordTypeNodes.string;
+	return node.representation === "date" ? createTypeReferenceNode(factory.createIdentifier("Date")) : keywordTypeNodes.string;
 }
 /**
 * Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.
@@ -817,20 +619,24 @@ 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 ? createOptionalTypeNode(item) : item);
-	if (max === void 0 && restNode) items.push(createRestTypeNode(createArrayTypeNode(restNode)));
-	return createTupleTypeNode(items);
+	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);
+}
+/**
+* Appends `| null` and then `| undefined` to a type when requested.
+*/
+function wrapNullableOptional(type, nullable, addsUndefined) {
+	const withNullable = nullable ? createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] }) : type;
+	return addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
 }
 /**
 * Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
 */
 function buildPropertyType(schema, baseType, optionalType, optional) {
-	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
+	const addsUndefined = optionalType === "undefined" || optionalType === "questionTokenAndUndefined";
 	const meta = syncSchemaRef(schema);
-	let type = baseType;
-	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-	return type;
+	return wrapNullableOptional(baseType, !!meta.nullable, addsUndefined && !!(optional || meta.nullish || meta.optional));
 }
 const indexSignaturePrinter = typescript.createPrinter();
 const indexSignatureSource = typescript.createSourceFile("", "", typescript.ScriptTarget.Latest);
@@ -873,7 +679,7 @@ function getEnumNames({ node, enum: enumOptions, resolver }) {
 	const resolved = resolver.name(node.name);
 	return {
 		enumName: enumOptions.constCasing === "pascalCase" ? resolved : camelCase(node.name),
-		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolved
+		typeName: enumOptions.type === "asConst" ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolved
 	};
 }
 /**
@@ -914,30 +720,16 @@ function Enum({ node, enum: enumOptions, resolver }) {
 	}), /* @__PURE__ */ jsx(File.Source, {
 		name: typeName,
 		isIndexable: !namesMerge,
-		isExportable: !namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type),
-		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumOptions.type),
+		isExportable: !namesMerge && enumOptions.type !== "inlineLiteral",
+		isTypeOnly: [
+			"asConst",
+			"literal",
+			void 0
+		].includes(enumOptions.type),
 		children: parserTs().print(typeNode)
 	})] });
 }
 //#endregion
-//#region ../../internals/shared/src/params.ts
-/**
-* Drops parameters that share the same name, keeping the first.
-*
-* A malformed spec can declare the same parameter name twice within one `in` location. Both would
-* resolve to the same output property, so emitting both would yield an object type with a duplicate
-* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
-* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
-*/
-function dedupeParams(params) {
-	const seen = /* @__PURE__ */ new Set();
-	return params.filter((param) => {
-		if (seen.has(param.name)) return false;
-		seen.add(param.name);
-		return true;
-	});
-}
-//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Maps a content type to the PascalCase suffix used to name per-content-type variants
@@ -997,11 +789,19 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
+	const group = (location) => {
+		const seen = /* @__PURE__ */ new Set();
+		return node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		});
+	};
 	const groups = {
-		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
-		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
-		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
-		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+		path: group("path"),
+		query: group("query"),
+		header: group("header"),
+		cookie: group("cookie")
 	};
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
@@ -1203,20 +1003,6 @@ function createCasedFile(caseLast) {
 	} };
 }
 //#endregion
-//#region ../../internals/shared/src/refs.ts
-/**
-* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
-* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
-* `resolver.imports` would resolve file paths that are then discarded.
-*/
-function collectRefNames(schema) {
-	return ast.collectSync(schema, { schema: (node) => {
-		const refNode = ast.narrowSchema(node, "ref");
-		if (!refNode?.ref) return null;
-		return ast.resolveRefName(refNode);
-	} });
-}
-//#endregion
 //#region ../../internals/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -1278,6 +1064,9 @@ function mapSchemaItems(node, transform) {
 }
 //#endregion
 //#region src/utils.ts
+function enumTypeName({ resolver, name, enumOptions, isEnum }) {
+	return isEnum && enumOptions?.type === "asConst" && enumOptions.typeSuffix ? resolver.enum.keyName({ name }, enumOptions.typeSuffix) : resolver.name(name);
+}
 /**
 * 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.
@@ -1414,7 +1203,7 @@ const { isNonNullable } = factory_exports;
 * ```
 */
 const printerTs = ast.createPrinter((options) => {
-	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
+	const addsUndefined = options.optionalType === "undefined" || options.optionalType === "questionTokenAndUndefined";
 	return {
 		name: "typescript",
 		options,
@@ -1445,7 +1234,12 @@ const printerTs = ast.createPrinter((options) => {
 				if (!node.name) return null;
 				const refName = ast.resolveRefName(node);
 				if (!refName) return null;
-				const name = node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.enum.keyName({ name: refName }, this.options.enum.typeSuffix) : node.ref ? this.options.resolver.name(refName) : refName;
+				const name = 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);
 			},
 			enum(node) {
@@ -1453,8 +1247,13 @@ const printerTs = ast.createPrinter((options) => {
 				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)
-				}) ?? void 0;
-				const resolvedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.enum.keyName(node, this.options.enum.typeSuffix) : this.options.resolver.name(node.name);
+				});
+				const resolvedName = enumTypeName({
+					resolver: this.options.resolver,
+					name: node.name,
+					enumOptions: this.options.enum,
+					isEnum: true
+				});
 				return createTypeReferenceNode(resolvedName, void 0);
 			},
 			union(node) {
@@ -1472,30 +1271,30 @@ const printerTs = ast.createPrinter((options) => {
 						});
 						return this.transform(m);
 					}).filter(isNonNullable)
-				}) ?? void 0;
+				});
 				return createUnionDeclaration({
 					withParentheses: true,
 					nodes: buildMemberNodes(members, this.transform)
-				}) ?? void 0;
+				});
 			},
 			intersection(node) {
 				return createIntersectionDeclaration({
 					withParentheses: true,
 					nodes: buildMemberNodes(node.members, this.transform)
-				}) ?? null;
+				});
 			},
 			array(node) {
 				return createArrayDeclaration({
 					nodes: mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
-				}) ?? null;
+				});
 			},
 			tuple(node) {
-				return buildTupleNode(node, this.transform) ?? null;
+				return buildTupleNode(node, this.transform);
 			},
 			object(node) {
 				const { transform, options } = this;
-				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
+				const addsQuestionToken = options.optionalType === "questionToken" || options.optionalType === "questionTokenAndUndefined";
 				const propertyNodes = mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
 					const baseType = output ?? keywordTypeNodes.unknown;
 					const optional = !property.required || !!property.schema.optional || !!property.schema.nullish;
@@ -1523,24 +1322,21 @@ const printerTs = ast.createPrinter((options) => {
 			if (!transformed) return null;
 			const meta = syncSchemaRef(node);
 			if (!name) {
-				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [transformed, keywordTypeNodes.null] }) : transformed;
-				const result = (meta.nullish || meta.optional) && addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
+				const result = wrapNullableOptional(transformed, !!meta.nullable, !!(meta.nullish || meta.optional) && addsUndefined);
 				return parserTs().print(result);
 			}
 			const inner = (() => {
-				const omitted = keysToOmit?.length ? createOmitDeclaration({
+				return wrapNullableOptional(keysToOmit?.length ? createOmitDeclaration({
 					keys: keysToOmit,
 					type: transformed,
 					nonNullable: true
-				}) : transformed;
-				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [omitted, keywordTypeNodes.null] }) : omitted;
-				return meta.nullish || meta.optional ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
+				}) : transformed, !!meta.nullable, !!(meta.nullish || meta.optional));
 			})();
 			const typeNode = createTypeDeclaration({
 				name,
 				isExportable: true,
 				type: inner,
-				syntax: syntaxType === "type" || inner.kind === syntaxKind.union || !!keysToOmit?.length ? "type" : "interface",
+				syntax: syntaxType === "type" || isUnionTypeNode(inner) || !!keysToOmit?.length ? "type" : "interface",
 				comments: buildPropertyJSDocComments({
 					...meta,
 					description
@@ -1553,15 +1349,6 @@ const printerTs = ast.createPrinter((options) => {
 //#endregion
 //#region src/generators/typeGenerator.tsx
 /**
-* Resolves the imported type name for a referenced schema. An enum schema emitted
-* as a `const` object imports its suffixed key alias (e.g. `StatusKey`); every other
-* schema imports its plain resolved name.
-*/
-function resolveImportName({ schemaName, enumOptions, enumSchemaNames, resolver }) {
-	if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.enum.keyName({ name: schemaName }, enumOptions.typeSuffix);
-	return resolver.name(schemaName);
-}
-/**
 * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
 * schema in the spec plus per-operation request, response, and parameter
 * types. Drop-replace with a custom `Generator<PluginTs>` to change how
@@ -1575,11 +1362,11 @@ const typeGenerator = defineGenerator({
 		const { config, resolver, root } = ctx;
 		if (!node.name) return;
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
-		const importName = (schemaName) => resolveImportName({
-			schemaName,
+		const importName = (schemaName) => enumTypeName({
+			resolver,
+			name: schemaName,
 			enumOptions,
-			enumSchemaNames,
-			resolver
+			isEnum: enumSchemaNames.has(schemaName)
 		});
 		const imports = resolver.imports({
 			node,
@@ -1591,7 +1378,7 @@ const typeGenerator = defineGenerator({
 		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
 		const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolver.name(node.name),
+			name: enumOptions.type === "asConst" && isEnumSchema ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolver.name(node.name),
 			file: resolver.file({
 				name: node.name,
 				extname: ".ts",
@@ -1662,11 +1449,11 @@ const typeGenerator = defineGenerator({
 			group: group ?? void 0
 		}) };
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
-		const importName = (schemaName) => resolveImportName({
-			schemaName,
+		const importName = (schemaName) => enumTypeName({
+			resolver,
+			name: schemaName,
 			enumOptions,
-			enumSchemaNames,
-			resolver
+			isEnum: enumSchemaNames.has(schemaName)
 		});
 		function renderSchemaType({ schema, name, keysToOmit }) {
 			if (!schema) return null;
@@ -1789,7 +1576,7 @@ const typeGenerator = defineGenerator({
 			if (!node.responses.some(hasSchema)) return null;
 			const responseName = resolver.response.response(node);
 			const responsesWithSchema = node.responses.filter(hasSchema);
-			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema).map(importName) : []))).has(responseName)) return null;
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? ast.collectImportedRefNames(entry.schema).map(importName) : []))).has(responseName)) return null;
 			return renderSchemaType({
 				schema: {
 					...buildResponseUnion(node, { resolver }),
@@ -1838,7 +1625,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.0.10";
+var version = "5.0.12";
 //#endregion
 //#region src/resolvers/resolverTs.ts
 /**
@@ -2116,6 +1903,15 @@ function createFunctionParameters(props = {}) {
 //#endregion
 //#region src/printers/functionPrinter.ts
 /**
+* Ordering priority for function parameters: lower = sorted earlier.
+*/
+const PARAM_RANK = {
+	required: 0,
+	optional: 1,
+	withDefault: 2,
+	rest: 3
+};
+/**
 * Renders a {@link TypeExpression} to its TypeScript source.
 *
 * - a `string` is a type reference, returned as-is
@@ -2136,13 +1932,17 @@ function renderType(type, transformType) {
 function renderKey(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
 }
+function renderMembers(members) {
+	return `{ ${members.map((member) => `${renderKey(member.key)}${member.optional ? "?" : ""}: ${member.type}`).join("; ")} }`;
+}
 function renderTypeExpression(type) {
 	if (typeof type === "string") return type;
 	if (isIndexedAccessType(type)) return `${type.target}['${type.key}']`;
-	return `{ ${type.members.map((member) => {
-		const value = renderTypeExpression(member.type);
-		return member.optional ? `${renderKey(member.name)}?: ${value}` : `${renderKey(member.name)}: ${value}`;
-	}).join("; ")} }`;
+	return renderMembers(type.members.map((member) => ({
+		key: member.name,
+		type: renderTypeExpression(member.type),
+		optional: member.optional
+	})));
 }
 function groupMembers(param) {
 	if (typeof param.name === "string") return null;
@@ -2155,9 +1955,6 @@ function rank(param) {
 	if (members) return members.every((m) => m.optional) ? PARAM_RANK.optional : PARAM_RANK.required;
 	return param.optional ? PARAM_RANK.optional : PARAM_RANK.required;
 }
-function sortParams(params) {
-	return params.toSorted((a, b) => rank(a) - rank(b));
-}
 function sortedGroupMembers(name, type) {
 	const members = type && isTypeLiteral(type) ? type.members : [];
 	const memberRank = (optional) => optional ? PARAM_RANK.optional : PARAM_RANK.required;
@@ -2186,11 +1983,11 @@ function renderGroupType(type, sorted, transformType) {
 	if (!isTypeLiteral(type)) return renderType(type);
 	const typed = sorted.filter((member) => member.type !== void 0);
 	if (!typed.length) return void 0;
-	return `{ ${typed.map((member) => {
-		const key = renderKey(member.propertyName ?? member.name);
-		const value = renderType(member.type, transformType);
-		return member.optional ? `${key}?: ${value}` : `${key}: ${value}`;
-	}).join("; ")} }`;
+	return renderMembers(typed.map((member) => ({
+		key: member.propertyName ?? member.name,
+		type: renderType(member.type, transformType),
+		optional: member.optional
+	})));
 }
 function printParameter(node, options) {
 	const { mode, transformName, transformType } = options;
@@ -2243,190 +2040,11 @@ function functionPrinter(options) {
 		name: "functionParameters",
 		options,
 		print(node) {
-			return sortParams(node.params).map((p) => printParameter(p, options)).filter(Boolean).join(", ");
+			return node.params.toSorted((a, b) => rank(a) - rank(b)).map((p) => printParameter(p, options)).filter(Boolean).join(", ");
 		}
 	};
 }
 //#endregion
-//#region src/printers/operationParams.ts
-/**
-* Resolves the {@link TypeExpression} for an individual parameter.
-*
-* Without a resolver, it falls back to the schema primitive (a plain type-name string). When the
-* parameter belongs to a named group, it emits an `IndexedAccessType` like `GroupParams['petId']`,
-* otherwise the resolved individual name.
-*/
-function resolveParamType({ node, param, resolver }) {
-	if (!resolver) return param.schema.primitive ?? "unknown";
-	const individualName = resolver.param.name(node, param);
-	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
-	const groupResolvers = {
-		path: resolver.param.path,
-		query: resolver.param.query,
-		header: resolver.param.headers
-	};
-	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
-	if (groupName && groupName !== individualName) return createIndexedAccessType({
-		target: groupName,
-		key: param.name
-	});
-	return individualName;
-}
-/**
-* Derives a {@link ParamGroupType} for a query or header group from the resolver.
-*
-* Returns `null` when there is no resolver, no params, or the group name equals the
-* individual param name (so there is no real group to emit).
-*/
-function resolveGroupType({ node, params, group, resolver }) {
-	if (!resolver || !params.length) return null;
-	const firstParam = params[0];
-	const groupName = (group === "query" ? resolver.param.query : resolver.param.headers).call(resolver, node, firstParam);
-	if (groupName === resolver.param.name(node, firstParam)) return null;
-	return {
-		type: groupName,
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Converts an `OperationNode` into function parameters for code generation.
-*
-* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
-* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
-* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
-* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
-*/
-function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
-	const dataName = paramNames?.data ?? "data";
-	const paramsName = paramNames?.params ?? "params";
-	const headersName = paramNames?.headers ?? "headers";
-	const pathName = paramNames?.path ?? "pathParams";
-	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
-	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
-	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
-	const toProperty = (param) => ({
-		name: param.name,
-		type: wrapTypeExpression(resolveParamType({
-			node,
-			param,
-			resolver
-		})),
-		optional: !param.required
-	});
-	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
-	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.response.body(node) ?? "unknown") : void 0;
-	const bodyProperty = bodyType ? [{
-		name: dataName,
-		type: bodyType,
-		optional: !(node.requestBody?.required ?? false)
-	}] : [];
-	const trailingGroups = [{
-		name: paramsName,
-		node,
-		params: queryParams,
-		groupType: resolveGroupType({
-			node,
-			params: queryParams,
-			group: "query",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}, {
-		name: headersName,
-		node,
-		params: headerParams,
-		groupType: resolveGroupType({
-			node,
-			params: headerParams,
-			group: "header",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}];
-	const params = [];
-	if (paramsType === "object") {
-		const children = [
-			...pathParams.map(toProperty),
-			...bodyProperty,
-			...trailingGroups.flatMap(buildGroupProperty)
-		];
-		if (children.length) params.push(createFunctionParameter({
-			properties: children,
-			default: emptyObjectDefault(children)
-		}));
-	} else {
-		if (pathParamsType === "inlineSpread" && pathParams.length) {
-			const spreadType = resolver?.param.path(node, pathParams[0]);
-			params.push(createFunctionParameter({
-				name: pathName,
-				type: spreadType ? wrapType(spreadType) : void 0,
-				rest: true
-			}));
-		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))));
-		else if (pathParams.length) {
-			const pathChildren = pathParams.map(toProperty);
-			params.push(createFunctionParameter({
-				properties: pathChildren,
-				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
-			}));
-		}
-		params.push(...bodyProperty.map((p) => createFunctionParameter(p)));
-		params.push(...trailingGroups.flatMap(buildGroupParam));
-	}
-	params.push(...extraParams);
-	return createFunctionParameters({ params });
-}
-/**
-* Builds the property descriptor for a query or header group.
-* Returns an empty array when there are no params to emit.
-*
-* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
-* {@link TypeLiteralNode} from the individual params.
-*/
-function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
-	if (groupType) return [{
-		name,
-		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
-		optional: groupType.optional
-	}];
-	if (params.length) return [{
-		name,
-		type: buildTypeLiteral({
-			node,
-			params,
-			resolver
-		}),
-		optional: params.every((p) => !p.required)
-	}];
-	return [];
-}
-/**
-* Builds a single {@link FunctionParameterNode} for a query or header group.
-* Returns an empty array when there are no params to emit.
-*/
-function buildGroupParam(args) {
-	return buildGroupProperty(args).map((p) => createFunctionParameter(p));
-}
-/**
-* Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
-*
-* Used when query or header parameters have no dedicated group type name.
-*/
-function buildTypeLiteral({ node, params, resolver }) {
-	return createTypeLiteral({ members: params.map((p) => ({
-		name: p.name,
-		type: resolveParamType({
-			node,
-			param: p,
-			resolver
-		}),
-		optional: !p.required
-	})) });
-}
-//#endregion
-export { Enum, Type, buildParams, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
+export { Enum, Type, buildParams, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral, pluginTs as default, pluginTs, enumTypeName, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
 
 //# sourceMappingURL=index.js.map