@kubb/plugin-ts 5.0.0-alpha.22 → 5.0.0-alpha.24

package/dist/index.js

@@ -1,47 +1,1527 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as typeGenerator, t as typeGeneratorLegacy } from "./generators-DFDut8o-.js";
-import { n as resolverTs, t as resolverTsLegacy } from "./resolverTsLegacy-CPiqqsO6.js";
+import "./chunk--u3MIqq1.js";
 import path from "node:path";
-import { walk } from "@kubb/ast";
-import { createPlugin, definePreset, definePresets, getBarrelFiles, getPreset, renderOperation, renderSchema } from "@kubb/core";
-//#region src/presets.ts
+import { safePrint } from "@kubb/fabric-core/parsers/typescript";
+import { File } from "@kubb/react-fabric";
+import { isNumber } from "remeda";
+import ts from "typescript";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+import { caseParams, collect, composeTransformers, createPrinterFactory, createProperty, createSchema, isStringType, narrowSchema, schemaTypes, transform, walk } from "@kubb/ast";
+import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getBarrelFiles, getMode, getPreset, renderOperation, renderSchema } from "@kubb/core";
+//#region ../../internals/utils/src/casing.ts
 /**
-* Built-in preset registry for `@kubb/plugin-ts`.
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
 *
-* - `default` — uses `resolverTs` and `typeGenerator` (current naming conventions).
-* - `kubbV4` — uses `resolverTsLegacy` and `typeGeneratorLegacy` (Kubb v4 naming conventions).
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
 */
-const presets = definePresets({
-	default: definePreset("default", {
-		resolvers: [resolverTs],
-		generators: [typeGenerator]
-	}),
-	kubbV4: definePreset("kubbV4", {
-		resolvers: [resolverTsLegacy],
-		generators: [typeGeneratorLegacy]
-	})
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+*/
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+/**
+* Converts `text` to snake_case.
+*
+* @example
+* snakeCase('helloWorld')  // 'hello_world'
+* snakeCase('Hello-World') // 'hello_world'
+*/
+function snakeCase(text, { prefix = "", suffix = "" } = {}) {
+	return `${prefix} ${text} ${suffix}`.trim().replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s\-.]+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").toLowerCase().split("_").filter(Boolean).join("_");
+}
+/**
+* Converts `text` to SCREAMING_SNAKE_CASE.
+*
+* @example
+* screamingSnakeCase('helloWorld') // 'HELLO_WORLD'
+*/
+function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
+	return snakeCase(text, {
+		prefix,
+		suffix
+	}).toUpperCase();
+}
+//#endregion
+//#region ../../internals/utils/src/string.ts
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
+*
+* @example
+* trimQuotes('"hello"') // 'hello'
+* trimQuotes('hello')   // 'hello'
+*/
+function trimQuotes(text) {
+	if (text.length >= 2) {
+		const first = text[0];
+		const last = text[text.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
+	}
+	return text;
+}
+/**
+* Escapes characters that are not allowed inside JS string literals.
+* Handles quotes, backslashes, and Unicode line terminators (U+2028 / U+2029).
+*
+* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+*
+* @example
+* ```ts
+* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+* ```
+*/
+function jsStringEscape(input) {
+	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+		switch (character) {
+			case "\"":
+			case "'":
+			case "\\": return `\\${character}`;
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return "";
+		}
+	});
+}
+//#endregion
+//#region ../../internals/utils/src/object.ts
+/**
+* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
+*
+* @example
+* stringify('hello')   // '"hello"'
+* stringify('"hello"') // '"hello"'
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "\"\"";
+	return JSON.stringify(trimQuotes(value.toString()));
+}
+//#endregion
+//#region src/constants.ts
+/**
+* `optionalType` values that cause a property's type to include `| undefined`.
+*/
+const OPTIONAL_ADDS_UNDEFINED = new Set(["undefined", "questionTokenAndUndefined"]);
+/**
+* `optionalType` values that render the property key with a `?` token.
+*/
+const OPTIONAL_ADDS_QUESTION_TOKEN = new Set(["questionToken", "questionTokenAndUndefined"]);
+/**
+* `enumType` values that append a `Key` suffix to the generated enum type alias.
+*/
+const ENUM_TYPES_WITH_KEY_SUFFIX = new Set(["asConst", "asPascalConst"]);
+/**
+* `enumType` values that require a runtime value declaration (object, enum, or literal).
+*/
+const ENUM_TYPES_WITH_RUNTIME_VALUE = new Set([
+	"enum",
+	"asConst",
+	"asPascalConst",
+	"constEnum",
+	"literal",
+	void 0
+]);
+/**
+* `enumType` values whose type declaration is type-only (no runtime value emitted for the type alias).
+*/
+const ENUM_TYPES_WITH_TYPE_ONLY = new Set([
+	"asConst",
+	"asPascalConst",
+	"literal",
+	void 0
+]);
+//#endregion
+//#region src/factory.ts
+const { SyntaxKind, factory } = ts;
+const modifiers = {
+	async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+	export: factory.createModifier(ts.SyntaxKind.ExportKeyword),
+	const: factory.createModifier(ts.SyntaxKind.ConstKeyword),
+	static: factory.createModifier(ts.SyntaxKind.StaticKeyword)
+};
+const syntaxKind = {
+	union: SyntaxKind.UnionType,
+	literalType: SyntaxKind.LiteralType,
+	stringLiteral: SyntaxKind.StringLiteral
+};
+function isValidIdentifier(str) {
+	if (!str.length || str.trim() !== str) return false;
+	const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest);
+	return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind) === void 0;
+}
+function propertyName(name) {
+	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
+	return name;
+}
+const questionToken = factory.createToken(ts.SyntaxKind.QuestionToken);
+function createQuestionToken(token) {
+	if (!token) return;
+	if (token === true) return questionToken;
+	return token;
+}
+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;
+}
+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);
+	}
+	const unionType = factory.createUnionTypeNode(nodes);
+	if (arrayType === "generic") return factory.createTypeReferenceNode(factory.createIdentifier("Array"), [unionType]);
+	return factory.createArrayTypeNode(factory.createParenthesizedType(unionType));
+}
+/**
+* Minimum nodes length of 2
+* @example `string | number`
+*/
+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;
+}
+function createPropertySignature({ readOnly, modifiers = [], name, questionToken, type }) {
+	return factory.createPropertySignature([...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : void 0].filter(Boolean), propertyName(name), createQuestionToken(questionToken), type);
+}
+function createParameterSignature(name, { modifiers, dotDotDotToken, questionToken, type, initializer }) {
+	return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer);
+}
+/**
+* @link https://github.com/microsoft/TypeScript/issues/44151
+*/
+function appendJSDocToNode({ node, comments }) {
+	const filteredComments = comments.filter(Boolean);
+	if (!filteredComments.length) return node;
+	const text = filteredComments.reduce((acc = "", comment = "") => {
+		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
+	}, "*");
+	return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
+}
+function createIndexSignature(type, { modifiers, indexName = "key", indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword) } = {}) {
+	return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type);
+}
+function createTypeAliasDeclaration({ modifiers, name, typeParameters, type }) {
+	return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type);
+}
+function createInterfaceDeclaration({ modifiers, name, typeParameters, members }) {
+	return factory.createInterfaceDeclaration(modifiers, name, typeParameters, void 0, members);
+}
+function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
+	if (syntax === "interface" && "members" in type) return appendJSDocToNode({
+		node: createInterfaceDeclaration({
+			members: type.members,
+			modifiers: isExportable ? [modifiers.export] : [],
+			name,
+			typeParameters: void 0
+		}),
+		comments
+	});
+	return appendJSDocToNode({
+		node: createTypeAliasDeclaration({
+			type,
+			modifiers: isExportable ? [modifiers.export] : [],
+			name,
+			typeParameters: void 0
+		}),
+		comments
+	});
+}
+/**
+* Apply casing transformation to enum keys
+*/
+function applyEnumKeyCasing(key, casing = "none") {
+	if (casing === "none") return key;
+	if (casing === "screamingSnakeCase") return screamingSnakeCase(key);
+	if (casing === "snakeCase") return snakeCase(key);
+	if (casing === "pascalCase") return pascalCase(key);
+	if (casing === "camelCase") return camelCase(key);
+	return key;
+}
+function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCasing = "none" }) {
+	if (type === "literal" || type === "inlineLiteral") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
+		if (isNumber(value)) {
+			if (value < 0) return factory.createLiteralTypeNode(factory.createPrefixUnaryExpression(ts.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) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
+	}).filter(Boolean)))];
+	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter(Boolean), factory.createIdentifier(typeName), enums.map(([key, value]) => {
+		let initializer = factory.createStringLiteral(value?.toString());
+		if (Number.parseInt(value.toString(), 10) === value && isNumber(Number.parseInt(value.toString(), 10))) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+		else initializer = factory.createNumericLiteral(value);
+		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
+		if (isNumber(Number.parseInt(key.toString(), 10))) {
+			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
+			return factory.createEnumMember(propertyName(casingKey), initializer);
+		}
+		if (key) {
+			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
+			return factory.createEnumMember(propertyName(casingKey), initializer);
+		}
+	}).filter(Boolean))];
+	const identifierName = name;
+	if (enums.length === 0) return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword))];
+	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value]) => {
+		let initializer = factory.createStringLiteral(value?.toString());
+		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+		else initializer = factory.createNumericLiteral(value);
+		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
+		if (key) {
+			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
+			return factory.createPropertyAssignment(propertyName(casingKey), initializer);
+		}
+	}).filter(Boolean), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], ts.NodeFlags.Const)), factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
+}
+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))]);
+}
+const keywordTypeNodes = {
+	any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+	unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+	void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),
+	number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+	integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+	bigint: factory.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword),
+	object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),
+	string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+	boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
+	undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+	null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),
+	never: factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
+};
+/**
+* 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 = ts.factory.createTemplateHead(parts[0] || "");
+	const templateSpans = [];
+	parameterIndices.forEach((paramIndex, i) => {
+		const isLast = i === parameterIndices.length - 1;
+		const nextPart = parts[paramIndex + 1] || "";
+		const literal = isLast ? ts.factory.createTemplateTail(nextPart) : ts.factory.createTemplateMiddle(nextPart);
+		templateSpans.push(ts.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal));
+	});
+	return ts.factory.createTemplateLiteralType(head, templateSpans);
+}
+const createTypeLiteralNode = factory.createTypeLiteralNode;
+const createTypeReferenceNode = factory.createTypeReferenceNode;
+const createNumericLiteral = factory.createNumericLiteral;
+const createStringLiteral = factory.createStringLiteral;
+const createArrayTypeNode = factory.createArrayTypeNode;
+factory.createParenthesizedType;
+const createLiteralTypeNode = factory.createLiteralTypeNode;
+factory.createNull;
+const createIdentifier = factory.createIdentifier;
+const createOptionalTypeNode = factory.createOptionalTypeNode;
+const createTupleTypeNode = factory.createTupleTypeNode;
+const createRestTypeNode = factory.createRestTypeNode;
+const createTrue = factory.createTrue;
+const createFalse = factory.createFalse;
+factory.createIndexedAccessTypeNode;
+factory.createTypeOperatorNode;
+const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
+//#endregion
+//#region src/components/Enum.tsx
+/**
+* Resolves the runtime identifier name and the TypeScript type name for an enum schema node.
+*
+* The raw `node.name` may be a YAML key such as `"enumNames.Type"` which is not a
+* valid TypeScript identifier. The resolver normalizes it; for inline enum
+* properties the adapter already emits a PascalCase+suffix name so resolution is typically a no-op.
+*/
+function getEnumNames({ node, enumType, enumTypeSuffix, resolver }) {
+	const resolved = resolver.default(node.name, "type");
+	return {
+		enumName: enumType === "asPascalConst" ? resolved : camelCase(node.name),
+		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
+	};
+}
+/**
+* Renders the enum declaration(s) for a single named `EnumSchemaNode`.
+*
+* Depending on `enumType` this may emit:
+* - A runtime object (`asConst` / `asPascalConst`) plus a `typeof` type alias
+* - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)
+* - A union literal type alias (`literal`)
+*
+* The emitted `File.Source` nodes carry the resolved names so that the barrel
+* index picks up the correct export identifiers.
+*/
+function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
+	const { enumName, typeName } = getEnumNames({
+		node,
+		enumType,
+		enumTypeSuffix,
+		resolver
+	});
+	const [nameNode, typeNode] = createEnumDeclaration({
+		name: enumName,
+		typeName,
+		enums: node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
+		type: enumType,
+		enumKeyCasing
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
+		name: enumName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: false,
+		children: safePrint(nameNode)
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isIndexable: true,
+		isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
+		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
+		children: safePrint(typeNode)
+	})] });
+}
+//#endregion
+//#region src/printers/printerTs.ts
+/**
+* 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)));
+}
+/**
+* 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;
+}
+/**
+* Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.
+*/
+function buildMemberNodes(members, print) {
+	return (members ?? []).map(print).filter(Boolean);
+}
+/**
+* Builds a TypeScript tuple type node from an array schema's `items`,
+* applying min/max slice and optional/rest element rules.
+*/
+function buildTupleNode(node, print) {
+	let items = (node.items ?? []).map(print).filter(Boolean);
+	const restNode = node.rest ? print(node.rest) ?? void 0 : void 0;
+	const { min, max } = node;
+	if (max !== void 0) {
+		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);
+}
+/**
+* Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
+*/
+function buildPropertyType(schema, baseType, optionalType) {
+	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
+	let type = baseType;
+	if (schema.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+	if ((schema.nullish || schema.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+	return type;
+}
+/**
+* Collects JSDoc annotation strings (description, deprecated, min/max, pattern, default, example, type) for a schema node.
+*/
+function buildPropertyJSDocComments(schema) {
+	const isArray = schema.type === "array";
+	return [
+		"description" in schema && schema.description ? `@description ${jsStringEscape(schema.description)}` : void 0,
+		"deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
+		!isArray && "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
+		!isArray && "max" in schema && schema.max !== void 0 ? `@maxLength ${schema.max}` : void 0,
+		"pattern" in schema && schema.pattern ? `@pattern ${schema.pattern}` : void 0,
+		"default" in schema && schema.default !== void 0 ? `@default ${"primitive" in schema && schema.primitive === "string" ? stringify(schema.default) : schema.default}` : void 0,
+		"example" in schema && schema.example !== void 0 ? `@example ${schema.example}` : void 0,
+		"primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+	];
+}
+/**
+* Creates TypeScript index signatures for `additionalProperties` and `patternProperties` on an object schema node.
+*/
+function buildIndexSignatures(node, propertyCount, print) {
+	const elements = [];
+	if (node.additionalProperties && node.additionalProperties !== true) {
+		const additionalType = print(node.additionalProperties) ?? keywordTypeNodes.unknown;
+		elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
+	} else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
+	if (node.patternProperties) {
+		const first = Object.values(node.patternProperties)[0];
+		if (first) {
+			let patternType = print(first) ?? keywordTypeNodes.unknown;
+			if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
+			elements.push(createIndexSignature(patternType));
+		}
+	}
+	return elements;
+}
+/**
+* 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.
+*
+* 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.
+*
+* @example Raw type node (no `typeName`)
+* ```ts
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral' })
+* const typeNode = printer.print(schemaNode) // ts.TypeNode
+* ```
+*
+* @example Full declaration (with `typeName`)
+* ```ts
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral', typeName: 'MyType' })
+* const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
+* ```
+*/
+const printerTs = definePrinter((options) => {
+	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
+	return {
+		name: "typescript",
+		options,
+		nodes: {
+			any: () => keywordTypeNodes.any,
+			unknown: () => keywordTypeNodes.unknown,
+			void: () => keywordTypeNodes.void,
+			never: () => keywordTypeNodes.never,
+			boolean: () => keywordTypeNodes.boolean,
+			null: () => keywordTypeNodes.null,
+			blob: () => createTypeReferenceNode("Blob", []),
+			string: () => keywordTypeNodes.string,
+			uuid: () => keywordTypeNodes.string,
+			email: () => keywordTypeNodes.string,
+			url: (node) => {
+				if (node.path) return createUrlTemplateType(node.path);
+				return keywordTypeNodes.string;
+			},
+			datetime: () => keywordTypeNodes.string,
+			number: () => keywordTypeNodes.number,
+			integer: () => keywordTypeNodes.number,
+			bigint: () => keywordTypeNodes.bigint,
+			date: dateOrStringNode,
+			time: dateOrStringNode,
+			ref(node) {
+				if (!node.name) return;
+				const refName = node.ref ? node.ref.split("/").at(-1) ?? node.name : node.name;
+				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
+			},
+			enum(node) {
+				const values = node.namedEnumValues?.map((v) => v.value) ?? node.enumValues ?? [];
+				if (this.options.enumType === "inlineLiteral" || !node.name) return createUnionDeclaration({
+					withParentheses: true,
+					nodes: values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
+				}) ?? void 0;
+				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enumTypeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
+			},
+			union(node) {
+				const members = node.members ?? [];
+				const hasStringLiteral = members.some((m) => {
+					return narrowSchema(m, schemaTypes.enum)?.primitive === "string";
+				});
+				const hasPlainString = members.some((m) => isStringType(m));
+				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
+					withParentheses: true,
+					nodes: members.map((m) => {
+						if (isStringType(m)) return createIntersectionDeclaration({
+							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
+							withParentheses: true
+						});
+						return this.transform(m);
+					}).filter(Boolean)
+				}) ?? 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)
+				}) ?? void 0;
+			},
+			array(node) {
+				return createArrayDeclaration({
+					nodes: (node.items ?? []).map((item) => this.transform(item)).filter(Boolean),
+					arrayType: this.options.arrayType
+				}) ?? void 0;
+			},
+			tuple(node) {
+				return buildTupleNode(node, this.transform);
+			},
+			object(node) {
+				const { transform, options } = this;
+				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
+				const propertyNodes = node.properties.map((prop) => {
+					const baseType = transform(prop.schema) ?? keywordTypeNodes.unknown;
+					const type = buildPropertyType(prop.schema, baseType, options.optionalType);
+					return appendJSDocToNode({
+						node: createPropertySignature({
+							questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
+							name: prop.name,
+							type,
+							readOnly: prop.schema.readOnly
+						}),
+						comments: buildPropertyJSDocComments(prop.schema)
+					});
+				});
+				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)];
+				if (!allElements.length) return keywordTypeNodes.object;
+				return createTypeLiteralNode(allElements);
+			}
+		},
+		print(node) {
+			let type = this.transform(node);
+			if (!type) return null;
+			if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+			if ((node.nullish || node.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+			const { name, syntaxType = "type", description, keysToOmit } = this.options;
+			if (!name) return safePrint(type);
+			const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!keysToOmit?.length;
+			return safePrint(createTypeDeclaration({
+				name,
+				isExportable: true,
+				type: keysToOmit?.length ? createOmitDeclaration({
+					keys: keysToOmit,
+					type,
+					nonNullable: true
+				}) : type,
+				syntax: useTypeGeneration ? "type" : "interface",
+				comments: [
+					node?.title ? jsStringEscape(node.title) : void 0,
+					description ? `@description ${jsStringEscape(description)}` : void 0,
+					node?.deprecated ? "@deprecated" : void 0,
+					node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
+					node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
+					node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
+					node?.default ? `@default ${node.default}` : void 0,
+					node?.example ? `@example ${node.example}` : void 0
+				]
+			}));
+		}
+	};
+});
+//#endregion
+//#region src/components/Type.tsx
+function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver, enumSchemaNames }) {
+	const resolvedDescription = description || node?.description;
+	const enumSchemaNodes = collect(node, { schema(n) {
+		const enumNode = narrowSchema(n, schemaTypes.enum);
+		if (enumNode?.name) return enumNode;
+	} });
+	const output = printerTs({
+		optionalType,
+		arrayType,
+		enumType,
+		enumTypeSuffix,
+		name,
+		syntaxType,
+		description: resolvedDescription,
+		keysToOmit,
+		resolver,
+		enumSchemaNames
+	}).print(node);
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames({
+				node,
+				enumType,
+				enumTypeSuffix,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumType !== "inlineLiteral";
+	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
+		node,
+		enumType,
+		enumTypeSuffix,
+		enumKeyCasing,
+		resolver
+	})), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
+}
+//#endregion
+//#region src/utils.ts
+function buildParams({ params, node, resolver }) {
+	return createSchema({
+		type: "object",
+		properties: params.map((param) => createProperty({
+			name: param.name,
+			required: param.required,
+			schema: createSchema({
+				type: "ref",
+				name: resolver.resolveParamName(node, param)
+			})
+		}))
+	});
+}
+function buildData({ node, resolver }) {
+	const pathParams = node.parameters.filter((p) => p.in === "path");
+	const queryParams = node.parameters.filter((p) => p.in === "query");
+	const headerParams = node.parameters.filter((p) => p.in === "header");
+	return createSchema({
+		type: "object",
+		deprecated: node.deprecated,
+		properties: [
+			createProperty({
+				name: "data",
+				schema: node.requestBody?.schema ? createSchema({
+					type: "ref",
+					name: resolver.resolveDataName(node),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "pathParams",
+				required: pathParams.length > 0,
+				schema: pathParams.length > 0 ? buildParams({
+					params: pathParams,
+					node,
+					resolver
+				}) : createSchema({ type: "never" })
+			}),
+			createProperty({
+				name: "queryParams",
+				schema: queryParams.length > 0 ? createSchema({
+					...buildParams({
+						params: queryParams,
+						node,
+						resolver
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "headerParams",
+				schema: headerParams.length > 0 ? createSchema({
+					...buildParams({
+						params: headerParams,
+						node,
+						resolver
+					}),
+					optional: true
+				}) : createSchema({
+					type: "never",
+					optional: true
+				})
+			}),
+			createProperty({
+				name: "url",
+				required: true,
+				schema: createSchema({
+					type: "url",
+					path: node.path
+				})
+			})
+		]
+	});
+}
+function buildResponses({ node, resolver }) {
+	if (node.responses.length === 0) return null;
+	return createSchema({
+		type: "object",
+		properties: node.responses.map((res) => createProperty({
+			name: String(res.statusCode),
+			required: true,
+			schema: createSchema({
+				type: "ref",
+				name: resolver.resolveResponseStatusName(node, res.statusCode)
+			})
+		}))
+	});
+}
+function buildResponseUnion({ node, resolver }) {
+	const responsesWithSchema = node.responses.filter((res) => res.schema);
+	if (responsesWithSchema.length === 0) return null;
+	return createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => createSchema({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	});
+}
+//#endregion
+//#region src/generators/typeGenerator.tsx
+const typeGenerator = defineGenerator({
+	name: "typescript",
+	type: "react",
+	Operation({ node, adapter, options, config, resolver }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const file = resolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output,
+			group
+		});
+		const params = caseParams(node.parameters, paramsCasing);
+		const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+		function resolveImportName(schemaName) {
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			return resolver.default(schemaName, "type");
+		}
+		function renderSchemaType({ node: schemaNode, name, description, keysToOmit }) {
+			if (!schemaNode) return null;
+			const transformedNode = transform(schemaNode, composeTransformers(...transformers));
+			const imports = adapter.getImports(transformedNode, (schemaName) => ({
+				name: resolveImportName(schemaName),
+				path: resolver.resolveFile({
+					name: schemaName,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				}).path
+			}));
+			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name,
+				node: transformedNode,
+				description,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType,
+				resolver,
+				keysToOmit,
+				enumSchemaNames
+			})] });
+		}
+		const paramTypes = params.map((param) => renderSchemaType({
+			node: param.schema,
+			name: resolver.resolveParamName(node, param)
+		}));
+		const requestType = node.requestBody?.schema ? renderSchemaType({
+			node: node.requestBody.schema,
+			name: resolver.resolveDataName(node),
+			description: node.requestBody.description ?? node.requestBody.schema.description,
+			keysToOmit: node.requestBody.keysToOmit
+		}) : null;
+		const responseTypes = node.responses.map((res) => renderSchemaType({
+			node: res.schema,
+			name: resolver.resolveResponseStatusName(node, res.statusCode),
+			description: res.description,
+			keysToOmit: res.keysToOmit
+		}));
+		const dataType = renderSchemaType({
+			node: buildData({
+				node: {
+					...node,
+					parameters: params
+				},
+				resolver
+			}),
+			name: resolver.resolveRequestConfigName(node)
+		});
+		const responsesType = renderSchemaType({
+			node: buildResponses({
+				node,
+				resolver
+			}),
+			name: resolver.resolveResponsesName(node)
+		});
+		const responseType = renderSchemaType({
+			node: buildResponseUnion({
+				node,
+				resolver
+			}),
+			name: resolver.resolveResponseName(node),
+			description: "Union of all possible responses"
+		});
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				paramTypes,
+				responseTypes,
+				requestType,
+				dataType,
+				responsesType,
+				responseType
+			]
+		});
+	},
+	Schema({ node, adapter, options, config, resolver }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		if (!node.name) return;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+		function resolveImportName(schemaName) {
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			return resolver.default(schemaName, "type");
+		}
+		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+			name: resolveImportName(schemaName),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
+		const type = {
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name),
+			file: resolver.resolveFile({
+				name: node.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: type.file.baseName,
+			path: type.file.path,
+			meta: type.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: type.file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				node.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name: type.name,
+				node: transformedNode,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType,
+				resolver,
+				enumSchemaNames
+			})]
+		});
+	}
 });
+//#endregion
+//#region src/resolvers/resolverTs.ts
+function resolveName(name, type) {
+	return pascalCase(name, { isFile: type === "file" });
+}
 /**
-* Resolves a compatibility preset for `plugin-ts`, merging user-supplied resolvers,
-* transformers, and generators on top of the built-in preset defaults.
+* Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
+* helpers used by the plugin. Import this in other plugins to resolve the exact names and
+* paths that `plugin-ts` generates without hardcoding the conventions.
 *
-* `resolverTs` is always prepended to the resolver list as the baseline.
+* The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
+* for identifiers/files and `pascalCase` for type names.
 *
 * @example
 * ```ts
-* const preset = getPreset('kubbV4', { resolvers: [], transformers: [], generators: [] })
+* import { resolver } from '@kubb/plugin-ts'
+*
+* resolver.default('list pets', 'type')              // → 'ListPets'
+* resolver.resolveName('list pets status 200')        // → 'ListPetsStatus200'
+* resolver.resolvePathName('list pets', 'file')       // → 'listPets'
 * ```
 */
-function getPreset$1(preset, { resolvers, transformers, generators }) {
-	return getPreset({
-		preset,
-		presets,
-		resolvers: [resolverTs, ...resolvers ?? []],
-		transformers,
-		generators
+const resolverTs = defineResolver(() => {
+	return {
+		name: "default",
+		pluginName: "plugin-ts",
+		default(name, type) {
+			return resolveName(name, type);
+		},
+		resolveName(name) {
+			return this.default(name, "function");
+		},
+		resolvePathName(name, type) {
+			return this.default(name, type);
+		},
+		resolveParamName(node, param) {
+			return this.resolveName(`${node.operationId} ${param.in} ${param.name}`);
+		},
+		resolveResponseStatusName(node, statusCode) {
+			return this.resolveName(`${node.operationId} Status ${statusCode}`);
+		},
+		resolveDataName(node) {
+			return this.resolveName(`${node.operationId} Data`);
+		},
+		resolveRequestConfigName(node) {
+			return this.resolveName(`${node.operationId} RequestConfig`);
+		},
+		resolveResponsesName(node) {
+			return this.resolveName(`${node.operationId} Responses`);
+		},
+		resolveResponseName(node) {
+			return this.resolveName(`${node.operationId} Response`);
+		},
+		resolveEnumKeyName(node, enumTypeSuffix = "key") {
+			return `${this.resolveName(node.name ?? "")}${enumTypeSuffix}`;
+		},
+		resolvePathParamsName(node, param) {
+			return this.resolveParamName(node, param);
+		},
+		resolveQueryParamsName(node, param) {
+			return this.resolveParamName(node, param);
+		},
+		resolveHeaderParamsName(node, param) {
+			return this.resolveParamName(node, param);
+		}
+	};
+});
+//#endregion
+//#region src/resolvers/resolverTsLegacy.ts
+/**
+* Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions
+* used before the v2 resolver refactor. Enable via `compatibilityPreset: 'kubbV4'`
+* (or by composing this resolver manually).
+*
+* Key differences from the default resolver:
+* - Response status types: `<OperationId><StatusCode>` (e.g. `CreatePets201`) instead of `<OperationId>Status201`
+* - Default/error responses: `<OperationId>Error` instead of `<OperationId>StatusDefault`
+* - Request body: `<OperationId>MutationRequest` (non-GET) / `<OperationId>QueryRequest` (GET)
+* - Combined responses type: `<OperationId>Mutation` / `<OperationId>Query`
+* - Response union: `<OperationId>MutationResponse` / `<OperationId>QueryResponse`
+*
+* @example
+* ```ts
+* import { resolverTsLegacy } from '@kubb/plugin-ts'
+*
+* resolverTsLegacy.resolveResponseStatusTypedName(node, 201)  // → 'CreatePets201'
+* resolverTsLegacy.resolveResponseStatusTypedName(node, 'default')  // → 'CreatePetsError'
+* resolverTsLegacy.resolveDataTypedName(node)  // → 'CreatePetsMutationRequest' (POST)
+* resolverTsLegacy.resolveResponsesTypedName(node)  // → 'CreatePetsMutation' (POST)
+* resolverTsLegacy.resolveResponseTypedName(node)  // → 'CreatePetsMutationResponse' (POST)
+* ```
+*/
+const resolverTsLegacy = defineResolver(() => {
+	return {
+		...resolverTs,
+		pluginName: "plugin-ts",
+		resolveResponseStatusName(node, statusCode) {
+			if (statusCode === "default") return this.resolveName(`${node.operationId} Error`);
+			return this.resolveName(`${node.operationId} ${statusCode}`);
+		},
+		resolveDataName(node) {
+			const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponsesName(node) {
+			const suffix = node.method === "GET" ? "Query" : "Mutation";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolveResponseName(node) {
+			const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+			return this.resolveName(`${node.operationId} ${suffix}`);
+		},
+		resolvePathParamsName(node, _param) {
+			return this.resolveName(`${node.operationId} PathParams`);
+		},
+		resolveQueryParamsName(node, _param) {
+			return this.resolveName(`${node.operationId} QueryParams`);
+		},
+		resolveHeaderParamsName(node, _param) {
+			return this.resolveName(`${node.operationId} HeaderParams`);
+		}
+	};
+});
+//#endregion
+//#region src/generators/typeGeneratorLegacy.tsx
+function buildGroupedParamsSchema({ params, parentName }) {
+	return createSchema({
+		type: "object",
+		properties: params.map((param) => {
+			let schema = param.schema;
+			if (narrowSchema(schema, "enum") && !schema.name && parentName) schema = {
+				...schema,
+				name: pascalCase([
+					parentName,
+					param.name,
+					"enum"
+				].join(" "))
+			};
+			return createProperty({
+				name: param.name,
+				required: param.required,
+				schema
+			});
+		})
+	});
+}
+function buildLegacyResponsesSchemaNode({ node, resolver }) {
+	const isGet = node.method.toLowerCase() === "get";
+	const successResponses = node.responses.filter((res) => {
+		const code = Number(res.statusCode);
+		return !Number.isNaN(code) && code >= 200 && code < 300;
+	});
+	const errorResponses = node.responses.filter((res) => res.statusCode === "default" || Number(res.statusCode) >= 400);
+	const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? createSchema({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
+	}) : createSchema({
+		type: "union",
+		members: successResponses.map((res) => createSchema({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	}) : createSchema({ type: "any" });
+	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, errorResponses[0].statusCode)
+	}) : createSchema({
+		type: "union",
+		members: errorResponses.map((res) => createSchema({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
+	}) : createSchema({ type: "any" });
+	const properties = [createProperty({
+		name: "Response",
+		required: true,
+		schema: responseSchema
+	})];
+	if (!isGet && node.requestBody?.schema) properties.push(createProperty({
+		name: "Request",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolveDataName(node)
+		})
+	}));
+	const queryParam = node.parameters.find((p) => p.in === "query");
+	if (queryParam) properties.push(createProperty({
+		name: "QueryParams",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolveQueryParamsName(node, queryParam)
+		})
+	}));
+	const pathParam = node.parameters.find((p) => p.in === "path");
+	if (pathParam) properties.push(createProperty({
+		name: "PathParams",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolvePathParamsName(node, pathParam)
+		})
+	}));
+	const headerParam = node.parameters.find((p) => p.in === "header");
+	if (headerParam) properties.push(createProperty({
+		name: "HeaderParams",
+		required: true,
+		schema: createSchema({
+			type: "ref",
+			name: resolver.resolveHeaderParamsName(node, headerParam)
+		})
+	}));
+	properties.push(createProperty({
+		name: "Errors",
+		required: true,
+		schema: errorsSchema
+	}));
+	return createSchema({
+		type: "object",
+		properties
+	});
+}
+function buildLegacyResponseUnionSchemaNode({ node, resolver }) {
+	const successResponses = node.responses.filter((res) => {
+		const code = Number(res.statusCode);
+		return !Number.isNaN(code) && code >= 200 && code < 300;
+	});
+	if (successResponses.length === 0) return createSchema({ type: "any" });
+	if (successResponses.length === 1) return createSchema({
+		type: "ref",
+		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
+	});
+	return createSchema({
+		type: "union",
+		members: successResponses.map((res) => createSchema({
+			type: "ref",
+			name: resolver.resolveResponseStatusName(node, res.statusCode)
+		}))
 	});
 }
-__name(getPreset$1, "getPreset");
+function nameUnnamedEnums(node, parentName) {
+	return transform(node, {
+		schema(n) {
+			const enumNode = narrowSchema(n, "enum");
+			if (enumNode && !enumNode.name) return {
+				...enumNode,
+				name: pascalCase([parentName, "enum"].join(" "))
+			};
+		},
+		property(p) {
+			const enumNode = narrowSchema(p.schema, "enum");
+			if (enumNode && !enumNode.name) return {
+				...p,
+				schema: {
+					...enumNode,
+					name: pascalCase([
+						parentName,
+						p.name,
+						"enum"
+					].join(" "))
+				}
+			};
+		}
+	});
+}
+const typeGeneratorLegacy = defineGenerator({
+	name: "typescript-legacy",
+	type: "react",
+	Operation({ node, adapter, options, config, resolver }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		const file = resolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output,
+			group
+		});
+		const params = caseParams(node.parameters, paramsCasing);
+		function renderSchemaType({ node: schemaNode, name, description, keysToOmit }) {
+			if (!schemaNode) return null;
+			const transformedNode = transform(schemaNode, composeTransformers(...transformers));
+			const imports = adapter.getImports(transformedNode, (schemaName) => ({
+				name: resolver.default(schemaName, "type"),
+				path: resolver.resolveFile({
+					name: schemaName,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				}).path
+			}));
+			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name,
+				node: transformedNode,
+				description,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType,
+				resolver,
+				keysToOmit
+			})] });
+		}
+		const pathParams = params.filter((p) => p.in === "path");
+		const queryParams = params.filter((p) => p.in === "query");
+		const headerParams = params.filter((p) => p.in === "header");
+		const responseTypes = node.responses.map((res) => {
+			const responseName = resolver.resolveResponseStatusName(node, res.statusCode);
+			const baseResponseName = resolverTsLegacy.resolveResponseStatusName(node, res.statusCode);
+			return renderSchemaType({
+				node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
+				name: responseName,
+				description: res.description,
+				keysToOmit: res.keysToOmit
+			});
+		});
+		const requestType = node.requestBody?.schema ? renderSchemaType({
+			node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
+			name: resolver.resolveDataName(node),
+			description: node.requestBody.description ?? node.requestBody.schema.description,
+			keysToOmit: node.requestBody.keysToOmit
+		}) : null;
+		const legacyParamTypes = [
+			pathParams.length > 0 ? renderSchemaType({
+				node: buildGroupedParamsSchema({
+					params: pathParams,
+					parentName: resolverTsLegacy.resolvePathParamsName(node, pathParams[0])
+				}),
+				name: resolver.resolvePathParamsName(node, pathParams[0])
+			}) : null,
+			queryParams.length > 0 ? renderSchemaType({
+				node: buildGroupedParamsSchema({
+					params: queryParams,
+					parentName: resolverTsLegacy.resolveQueryParamsName(node, queryParams[0])
+				}),
+				name: resolver.resolveQueryParamsName(node, queryParams[0])
+			}) : null,
+			headerParams.length > 0 ? renderSchemaType({
+				node: buildGroupedParamsSchema({
+					params: headerParams,
+					parentName: resolverTsLegacy.resolveHeaderParamsName(node, headerParams[0])
+				}),
+				name: resolver.resolveHeaderParamsName(node, headerParams[0])
+			}) : null
+		];
+		const legacyResponsesType = renderSchemaType({
+			node: buildLegacyResponsesSchemaNode({
+				node,
+				resolver
+			}),
+			name: resolver.resolveResponsesName(node)
+		});
+		const legacyResponseType = renderSchemaType({
+			node: buildLegacyResponseUnionSchemaNode({
+				node,
+				resolver
+			}),
+			name: resolver.resolveResponseName(node)
+		});
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				legacyParamTypes,
+				responseTypes,
+				requestType,
+				legacyResponseType,
+				legacyResponsesType
+			]
+		});
+	},
+	Schema({ node, adapter, options, config, resolver }) {
+		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
+		const root = path.resolve(config.root, config.output.path);
+		const mode = getMode(path.resolve(root, output.path));
+		if (!node.name) return;
+		const transformedNode = transform(node, composeTransformers(...transformers));
+		const imports = adapter.getImports(transformedNode, (schemaName) => ({
+			name: resolver.default(schemaName, "type"),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			}).path
+		}));
+		const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
+		const type = {
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name),
+			file: resolver.resolveFile({
+				name: node.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			})
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: type.file.baseName,
+			path: type.file.path,
+			meta: type.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+				root: type.file.path,
+				path: imp.path,
+				name: imp.name,
+				isTypeOnly: true
+			}, [
+				node.name,
+				imp.path,
+				imp.isTypeOnly
+			].join("-"))), /* @__PURE__ */ jsx(Type, {
+				name: type.name,
+				node: transformedNode,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				optionalType,
+				arrayType,
+				syntaxType,
+				resolver
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/presets.ts
+/**
+* Built-in preset registry for `@kubb/plugin-ts`.
+*
+* - `default` — uses `resolverTs` and `typeGenerator` (current naming conventions).
+* - `kubbV4` — uses `resolverTsLegacy` and `typeGeneratorLegacy` (Kubb v4 naming conventions).
+*/
+const presets = definePresets({
+	default: {
+		name: "default",
+		resolvers: [resolverTs],
+		generators: [typeGenerator]
+	},
+	kubbV4: {
+		name: "kubbV4",
+		resolvers: [resolverTsLegacy],
+		generators: [typeGeneratorLegacy]
+	}
+});
 //#endregion
 //#region src/plugin.ts
 /**
@@ -69,7 +1549,9 @@ const pluginTs = createPlugin((options) => {
 		path: "types",
 		barrelType: "named"
 	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
-	const { resolver, transformers, generators } = getPreset$1(compatibilityPreset, {
+	const preset = getPreset({
+		preset: compatibilityPreset,
+		presets,
 		resolvers: userResolvers,
 		transformers: userTransformers,
 		generators: userGenerators
@@ -78,25 +1560,35 @@ const pluginTs = createPlugin((options) => {
 	let resolvePathWarning = false;
 	return {
 		name: pluginTsName,
-		options: {
-			output,
-			optionalType,
-			group,
-			arrayType,
-			enumType,
-			enumTypeSuffix,
-			enumKeyCasing,
-			syntaxType,
-			paramsCasing,
-			resolver,
-			transformers
+		get resolver() {
+			return preset.resolver;
+		},
+		get options() {
+			return {
+				output,
+				optionalType,
+				group: group ? {
+					...options.group,
+					name: (ctx) => {
+						if (options.group?.type === "path") return `${ctx.group.split("/")[1]}`;
+						return `${camelCase(ctx.group)}Controller`;
+					}
+				} : void 0,
+				arrayType,
+				enumType,
+				enumTypeSuffix,
+				enumKeyCasing,
+				syntaxType,
+				paramsCasing,
+				transformers: preset.transformers
+			};
 		},
 		resolvePath(baseName, pathMode, options) {
 			if (!resolvePathWarning) {
-				this.driver.events.emit("warn", "Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead");
+				this.events.emit("warn", "Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead");
 				resolvePathWarning = true;
 			}
-			return resolver.resolvePath({
+			return this.plugin.resolver.resolvePath({
 				baseName,
 				pathMode,
 				tag: options?.group?.tag,
@@ -104,25 +1596,25 @@ const pluginTs = createPlugin((options) => {
 			}, {
 				root: path.resolve(this.config.root, this.config.output.path),
 				output,
-				group
+				group: this.plugin.options.group
 			});
 		},
 		resolveName(name, type) {
 			if (!resolveNameWarning) {
-				this.driver.events.emit("warn", "Do not use resolveName for pluginTs, use resolverTs.default instead");
+				this.events.emit("warn", "Do not use resolveName for pluginTs, use resolverTs.default instead");
 				resolveNameWarning = true;
 			}
-			return resolver.default(name, type);
+			return this.plugin.resolver.default(name, type);
 		},
 		async install() {
-			const { config, fabric, plugin, adapter, rootNode, driver, openInStudio } = this;
+			const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this;
 			const root = path.resolve(config.root, config.output.path);
 			if (!adapter) throw new Error("Plugin cannot work without adapter being set");
 			await openInStudio({ ast: true });
 			await walk(rootNode, {
 				depth: "shallow",
 				async schema(schemaNode) {
-					const writeTasks = generators.map(async (generator) => {
+					const writeTasks = preset.generators.map(async (generator) => {
 						if (generator.type === "react" && generator.version === "2") {
 							const options = resolver.resolveOptions(schemaNode, {
 								options: plugin.options,
@@ -133,6 +1625,7 @@ const pluginTs = createPlugin((options) => {
 							if (options === null) return;
 							await renderSchema(schemaNode, {
 								options,
+								resolver,
 								adapter,
 								config,
 								fabric,
@@ -145,7 +1638,7 @@ const pluginTs = createPlugin((options) => {
 					await Promise.all(writeTasks);
 				},
 				async operation(operationNode) {
-					const writeTasks = generators.map(async (generator) => {
+					const writeTasks = preset.generators.map(async (generator) => {
 						if (generator.type === "react" && generator.version === "2") {
 							const options = resolver.resolveOptions(operationNode, {
 								options: plugin.options,
@@ -156,6 +1649,7 @@ const pluginTs = createPlugin((options) => {
 							if (options === null) return;
 							await renderOperation(operationNode, {
 								options,
+								resolver,
 								adapter,
 								config,
 								fabric,
@@ -179,6 +1673,113 @@ const pluginTs = createPlugin((options) => {
 	};
 });
 //#endregion
-export { pluginTs, pluginTsName };
+//#region src/printers/functionPrinter.ts
+const kindToHandlerKey = {
+	FunctionParameter: "functionParameter",
+	ParameterGroup: "parameterGroup",
+	FunctionParameters: "functionParameters",
+	Type: "type"
+};
+/**
+* Creates a function-parameter printer factory.
+*
+* Uses `createPrinterFactory` and dispatches handlers by `node.kind`
+* (for function nodes) rather than by `node.type` (for schema nodes).
+*/
+const defineFunctionPrinter = createPrinterFactory((node) => kindToHandlerKey[node.kind]);
+function rank(param) {
+	if (param.kind === "ParameterGroup") {
+		if (param.default) return 2;
+		return param.optional ?? param.properties.every((p) => p.optional || p.default !== void 0) ? 1 : 0;
+	}
+	if (param.rest) return 3;
+	if (param.default) return 2;
+	return param.optional ? 1 : 0;
+}
+function sortParams(params) {
+	return [...params].sort((a, b) => rank(a) - rank(b));
+}
+function sortChildParams(params) {
+	return [...params].sort((a, b) => rank(a) - rank(b));
+}
+/**
+* Default function-signature printer.
+* Covers the four standard output modes used across Kubb plugins.
+*
+* @example
+* ```ts
+* const printer = functionPrinter({ mode: 'declaration' })
+*
+* const sig = createFunctionParameters({
+*   params: [
+*     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
+*     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),
+*   ],
+* })
+*
+* printer.print(sig)  // → "petId: string, config: Config = {}"
+* ```
+*/
+const functionPrinter = defineFunctionPrinter((options) => ({
+	name: "functionParameters",
+	options,
+	nodes: {
+		type(node) {
+			if (node.variant === "member") return `${node.base}['${node.key}']`;
+			if (node.variant === "struct") return `{ ${node.properties.map((p) => {
+				const typeStr = this.transform(p.type);
+				return p.optional ? `${p.name}?: ${typeStr}` : `${p.name}: ${typeStr}`;
+			}).join("; ")} }`;
+			if (node.variant === "reference") return node.name;
+			return null;
+		},
+		functionParameter(node) {
+			const { mode, transformName, transformType } = this.options;
+			const name = transformName ? transformName(node.name) : node.name;
+			const rawType = node.type ? this.transform(node.type) : void 0;
+			const type = rawType != null && transformType ? transformType(rawType) : rawType;
+			if (mode === "keys" || mode === "values") return node.rest ? `...${name}` : name;
+			if (mode === "call") return node.rest ? `...${name}` : name;
+			if (node.rest) return type ? `...${name}: ${type}` : `...${name}`;
+			if (type) {
+				if (node.optional) return `${name}?: ${type}`;
+				return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
+			}
+			return node.default ? `${name} = ${node.default}` : name;
+		},
+		parameterGroup(node) {
+			const { mode, transformName, transformType } = this.options;
+			const sorted = sortChildParams(node.properties);
+			const isOptional = node.optional ?? sorted.every((p) => p.optional || p.default !== void 0);
+			if (node.inline) return sorted.map((p) => this.transform(p)).filter(Boolean).join(", ");
+			if (mode === "keys" || mode === "values") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
+			if (mode === "call") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
+			const names = sorted.map((p) => {
+				return transformName ? transformName(p.name) : p.name;
+			});
+			const nameStr = names.length ? `{ ${names.join(", ")} }` : void 0;
+			if (!nameStr) return null;
+			let typeAnnotation = node.type ? this.transform(node.type) ?? void 0 : void 0;
+			if (!typeAnnotation) {
+				const typeParts = sorted.filter((p) => p.type).map((p) => {
+					const rawT = p.type ? this.transform(p.type) : void 0;
+					const t = rawT != null && transformType ? transformType(rawT) : rawT;
+					return p.optional || p.default !== void 0 ? `${p.name}?: ${t}` : `${p.name}: ${t}`;
+				});
+				typeAnnotation = typeParts.length ? `{ ${typeParts.join("; ")} }` : void 0;
+			}
+			if (typeAnnotation) {
+				if (isOptional) return `${nameStr}: ${typeAnnotation} = ${node.default ?? "{}"}`;
+				return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`;
+			}
+			return node.default ? `${nameStr} = ${node.default}` : nameStr;
+		},
+		functionParameters(node) {
+			return sortParams(node.params).map((p) => this.transform(p)).filter(Boolean).join(", ");
+		}
+	}
+}));
+//#endregion
+export { Enum, Type, functionPrinter, pluginTs, pluginTsName, printerTs, resolverTs, resolverTsLegacy, typeGenerator };
 
 //# sourceMappingURL=index.js.map