@kubb/plugin-ts 5.0.0-beta.42 → 5.0.0-beta.64

package/dist/index.js

@@ -1,9 +1,10 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
+import { caseParams, extractRefName, isStringType, jsStringEscape, mapSchemaItems, mapSchemaProperties, stringify, syncSchemaRef, trimQuotes } from "@kubb/ast/utils";
 import { parserTs } from "@kubb/parser-ts";
-import { File, jsxRendererSync } from "@kubb/renderer-jsx";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { File, jsxRenderer } from "@kubb/renderer-jsx";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -15,58 +16,41 @@ import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 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);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : 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'
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
+function camelCase(text, { 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'
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 /**
 * Converts `text` to snake_case.
 *
-* @example
-* snakeCase('helloWorld')  // 'hello_world'
-* snakeCase('Hello-World') // 'hello_world'
+* @example From camelCase
+* `snakeCase('helloWorld') // 'hello_world'`
+*
+* @example From mixed separators
+* `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("_");
@@ -74,8 +58,8 @@ function snakeCase(text, { prefix = "", suffix = "" } = {}) {
 /**
 * Converts `text` to SCREAMING_SNAKE_CASE.
 *
-* @example
-* screamingSnakeCase('helloWorld') // 'HELLO_WORLD'
+* @example From camelCase
+* `screamingSnakeCase('helloWorld') // 'HELLO_WORLD'`
 */
 function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
 	return snakeCase(text, {
@@ -84,60 +68,29 @@ function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
 	}).toUpperCase();
 }
 //#endregion
-//#region ../../internals/utils/src/string.ts
+//#region ../../internals/utils/src/fs.ts
 /**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
 *
-* @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).
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
 *
-* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
 *
-* @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 PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
 *
-* @example
-* stringify('hello')   // '"hello"'
-* stringify('"hello"') // '"hello"'
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-function stringify(value) {
-	if (value === void 0 || value === null) return "\"\"";
-	return JSON.stringify(trimQuotes(value.toString()));
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
 //#region ../../internals/utils/src/reserved.ts
@@ -273,26 +226,24 @@ const OPTIONAL_ADDS_UNDEFINED = new Set(["undefined", "questionTokenAndUndefined
 */
 const OPTIONAL_ADDS_QUESTION_TOKEN = new Set(["questionToken", "questionTokenAndUndefined"]);
 /**
-* `enumType` values that append a `Key` suffix to the generated enum type alias.
+* `enum.type` values that append a `typeSuffix` to the generated enum type alias.
 */
-const ENUM_TYPES_WITH_KEY_SUFFIX = new Set(["asConst", "asPascalConst"]);
+const ENUM_TYPES_WITH_KEY_SUFFIX = new Set(["asConst"]);
 /**
-* `enumType` values that require a runtime value declaration (object, enum, or literal).
+* `enum.type` 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).
+* `enum.type` 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
 ]);
@@ -503,7 +454,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 			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()));
+		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(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
@@ -514,7 +465,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 			const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing);
 			return factory.createEnumMember(propertyName(casingKey), initializer);
 		}
-		if (key) {
+		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
 			return factory.createEnumMember(propertyName(casingKey), initializer);
 		}
@@ -526,7 +477,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		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) {
+		if (key !== null && key !== void 0) {
 			const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing);
 			return factory.createPropertyAssignment(propertyName(casingKey), initializer);
 		}
@@ -612,12 +563,10 @@ const createStringLiteral = factory.createStringLiteral;
 * Creates an array type node (e.g., `T[]`).
 */
 const createArrayTypeNode = factory.createArrayTypeNode;
-factory.createParenthesizedType;
 /**
 * Creates a literal type node (e.g., `'hello'`, `42`, `true`).
 */
 const createLiteralTypeNode = factory.createLiteralTypeNode;
-factory.createNull;
 /**
 * Creates an identifier node.
 */
@@ -642,8 +591,6 @@ const createTrue = factory.createTrue;
 * Creates a boolean false literal type node.
 */
 const createFalse = factory.createFalse;
-factory.createIndexedAccessTypeNode;
-factory.createTypeOperatorNode;
 /**
 * Creates a prefix unary expression (e.g., negative numbers, logical not).
 */
@@ -691,12 +638,12 @@ function buildTupleNode(node, print) {
 /**
 * Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.
 */
-function buildPropertyType(schema, baseType, optionalType) {
+function buildPropertyType(schema, baseType, optionalType, optional) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	const meta = ast.syncSchemaRef(schema);
+	const meta = syncSchemaRef(schema);
 	let type = baseType;
 	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-	if ((meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
 	return type;
 }
 /**
@@ -724,41 +671,44 @@ function buildIndexSignatures(node, propertyCount, print) {
 * 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.
+* 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.
+*
+* When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type
+* resolve to the same name, which TypeScript merges into a single value+type declaration.
 */
-function getEnumNames({ node, enumType, enumTypeSuffix, resolver }) {
+function getEnumNames({ node, enum: enumOptions, 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
+		enumName: enumOptions.constCasing === "pascalCase" ? resolved : camelCase(node.name),
+		typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : 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
+* Depending on `enum.type` this may emit:
+* - A runtime object (`asConst`) 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 }) {
+function Enum({ node, enum: enumOptions, resolver }) {
 	const { enumName, typeName } = getEnumNames({
 		node,
-		enumType,
-		enumTypeSuffix,
+		enum: enumOptions,
 		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
+		type: enumOptions.type,
+		enumKeyCasing: enumOptions.keyCasing
 	});
+	const namesMerge = !!nameNode && enumName === typeName;
 	return /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
 		name: enumName,
 		isExportable: true,
@@ -767,15 +717,15 @@ function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
 		children: parserTs.print(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),
+		isIndexable: !namesMerge,
+		isExportable: !namesMerge && ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumOptions.type),
+		isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumOptions.type),
 		children: parserTs.print(typeNode)
 	})] });
 }
 //#endregion
 //#region src/components/Type.tsx
-function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
+function Type({ name, node, printer, enum: enumOptions, resolver }) {
 	const enumSchemaNodes = ast.collect(node, { schema(n) {
 		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
 		if (enumNode?.name) return enumNode;
@@ -787,19 +737,16 @@ function Type({ name, node, printer, enumType, enumTypeSuffix, enumKeyCasing, re
 			node,
 			...getEnumNames({
 				node,
-				enumType,
-				enumTypeSuffix,
+				enum: enumOptions,
 				resolver
 			})
 		};
 	});
-	const shouldExportEnums = enumType !== "inlineLiteral";
-	const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
 	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
 		node,
-		enumType,
-		enumTypeSuffix,
-		enumKeyCasing,
+		enum: enumOptions,
 		resolver
 	}, node.name)), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -860,7 +807,7 @@ function resolveContentTypeVariants(entries, baseName) {
 	});
 }
 function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -875,26 +822,24 @@ function getOperationParameters(node, options = {}) {
 * shared default naming so every plugin groups output consistently:
 *
 * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
 *
 * A user-provided `group.name` always wins over the default namer, so callers stay in
 * control of their output folders. Returns `null` when grouping is disabled, matching the
 * per-plugin convention.
 *
 * @param group - The user-supplied group option, or `undefined` to disable grouping.
-* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
 *
 * @example
 * ```ts
-* createGroupConfig(group, { suffix: 'Controller' }) // plugin-ts, plugin-client, …
-* createGroupConfig(group, { suffix: 'Requests' })   // plugin-cypress, plugin-mcp
+* createGroupConfig(group) // shared across every plugin
 * ```
 */
-function createGroupConfig(group, options) {
+function createGroupConfig(group) {
 	if (!group) return null;
 	const defaultName = (ctx) => {
 		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return `${camelCase(ctx.group)}${options.suffix}`;
+		return camelCase(ctx.group);
 	};
 	return {
 		...group,
@@ -910,8 +855,11 @@ function createGroupConfig(group, options) {
 * Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
 
 */
-function buildPropertyJSDocComments(schema) {
-	const meta = ast.syncSchemaRef(schema);
+function isSchemaOptional(schema) {
+	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
+}
+function buildPropertyJSDocComments(schema, optional) {
+	const meta = syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
 	const hasDescription = meta && "description" in meta && meta.description;
 	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
@@ -924,83 +872,85 @@ function buildPropertyJSDocComments(schema) {
 		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
 		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" ? stringify(meta.default) : meta.default}` : null,
 		meta && "example" in meta && meta.example !== void 0 ? `@example ${meta.example}` : null,
-		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, "optional" in schema && schema.optional ? " | undefined" : null].filter(Boolean).join("") : null
+		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null
 	].filter(Boolean);
 }
 function buildParams(node, { params, resolver }) {
-	return ast.createSchema({
+	return ast.factory.createSchema({
 		type: "object",
-		properties: params.map((param) => ast.createProperty({
+		properties: params.map((param) => ast.factory.createProperty({
 			name: param.name,
 			required: param.required,
-			schema: ast.createSchema({
+			schema: ast.factory.createSchema({
 				type: "ref",
-				name: resolver.resolveParamName(node, param)
+				name: resolver.resolveParamName(node, param),
+				optional: !param.required
 			})
 		}))
 	});
 }
 function buildData(node, { resolver }) {
 	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
-	return ast.createSchema({
+	return ast.factory.createSchema({
 		type: "object",
 		deprecated: node.deprecated,
 		properties: [
-			ast.createProperty({
+			ast.factory.createProperty({
 				name: "data",
-				schema: node.requestBody?.content?.[0]?.schema ? ast.createSchema({
+				schema: node.requestBody?.content?.[0]?.schema ? ast.factory.createSchema({
 					type: "ref",
 					name: resolver.resolveDataName(node),
 					optional: true
-				}) : ast.createSchema({
+				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			ast.createProperty({
+			ast.factory.createProperty({
 				name: "pathParams",
 				required: pathParams.length > 0,
 				schema: pathParams.length > 0 ? buildParams(node, {
 					params: pathParams,
 					resolver
-				}) : ast.createSchema({
+				}) : ast.factory.createSchema({
 					type: "never",
-					primitive: void 0
+					primitive: void 0,
+					optional: true
 				})
 			}),
-			ast.createProperty({
+			ast.factory.createProperty({
 				name: "queryParams",
-				schema: queryParams.length > 0 ? ast.createSchema({
+				schema: queryParams.length > 0 ? ast.factory.createSchema({
 					...buildParams(node, {
 						params: queryParams,
 						resolver
 					}),
 					optional: true
-				}) : ast.createSchema({
+				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			ast.createProperty({
+			ast.factory.createProperty({
 				name: "headerParams",
-				schema: headerParams.length > 0 ? ast.createSchema({
+				schema: headerParams.length > 0 ? ast.factory.createSchema({
 					...buildParams(node, {
 						params: headerParams,
 						resolver
 					}),
 					optional: true
-				}) : ast.createSchema({
+				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			ast.createProperty({
+			ast.factory.createProperty({
 				name: "url",
 				required: true,
-				schema: ast.createSchema({
+				schema: ast.factory.createSchema({
 					type: "url",
 					path: node.path
 				})
@@ -1010,12 +960,12 @@ function buildData(node, { resolver }) {
 }
 function buildResponses(node, { resolver }) {
 	if (node.responses.length === 0) return null;
-	return ast.createSchema({
+	return ast.factory.createSchema({
 		type: "object",
-		properties: node.responses.map((res) => ast.createProperty({
+		properties: node.responses.map((res) => ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
-			schema: ast.createSchema({
+			schema: ast.factory.createSchema({
 				type: "ref",
 				name: resolver.resolveResponseStatusName(node, res.statusCode)
 			})
@@ -1025,9 +975,9 @@ function buildResponses(node, { resolver }) {
 function buildResponseUnion(node, { resolver }) {
 	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
 	if (responsesWithSchema.length === 0) return null;
-	return ast.createSchema({
+	return ast.factory.createSchema({
 		type: "union",
-		members: responsesWithSchema.map((res) => ast.createSchema({
+		members: responsesWithSchema.map((res) => ast.factory.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
@@ -1051,13 +1001,13 @@ function isNonNullable(value) {
 *
 * @example Raw type node (no `typeName`)
 * ```ts
-* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enumType: 'inlineLiteral' })
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: '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 printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })
 * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
 * ```
 */
@@ -1091,27 +1041,27 @@ const printerTs = ast.definePrinter((options) => {
 			time: dateOrStringNode,
 			ref(node) {
 				if (!node.name) return null;
-				const refName = node.ref ? ast.extractRefName(node.ref) ?? 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);
+				const refName = node.ref ? extractRefName(node.ref) ?? node.name : node.name;
+				return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix && this.options.enumSchemaNames?.has(refName) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enum.typeSuffix) : 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({
+				if (this.options.enum.type === "inlineLiteral" || !node.name) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable)
 				}) ?? 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);
+				return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enum.type) && this.options.enum.typeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enum.typeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
 			},
 			union(node) {
 				const members = node.members ?? [];
 				const hasStringLiteral = members.some((m) => {
 					return ast.narrowSchema(m, ast.schemaTypes.enum)?.primitive === "string";
 				});
-				const hasPlainString = members.some((m) => ast.isStringType(m));
+				const hasPlainString = members.some((m) => isStringType(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if (ast.isStringType(m)) return createIntersectionDeclaration({
+						if (isStringType(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -1131,7 +1081,7 @@ const printerTs = ast.definePrinter((options) => {
 			},
 			array(node) {
 				return createArrayDeclaration({
-					nodes: (node.items ?? []).map((item) => this.transform(item)).filter(isNonNullable),
+					nodes: mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
 				}) ?? null;
 			},
@@ -1141,18 +1091,19 @@ const printerTs = ast.definePrinter((options) => {
 			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);
-					const propMeta = ast.syncSchemaRef(prop.schema);
+				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;
+					const type = buildPropertyType(property.schema, baseType, options.optionalType, optional);
+					const propMeta = syncSchemaRef(property.schema);
 					return appendJSDocToNode({
 						node: createPropertySignature({
-							questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
-							name: prop.name,
+							questionToken: optional ? addsQuestionToken : false,
+							name,
 							type,
 							readOnly: propMeta?.readOnly
 						}),
-						comments: buildPropertyJSDocComments(prop.schema)
+						comments: buildPropertyJSDocComments(property.schema, optional)
 					});
 				});
 				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)];
@@ -1165,7 +1116,7 @@ const printerTs = ast.definePrinter((options) => {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			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;
@@ -1204,15 +1155,14 @@ const printerTs = ast.definePrinter((options) => {
 */
 const typeGenerator = defineGenerator({
 	name: "typescript",
-	renderer: jsxRendererSync,
+	renderer: jsxRenderer,
 	schema(node, ctx) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
+		const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
 		if (!node.name) return;
-		const mode = ctx.getMode(output);
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix);
 			return resolver.resolveTypeName(schemaName);
 		}
 		const imports = adapter.getImports(node, (schemaName) => ({
@@ -1228,7 +1178,7 @@ const typeGenerator = defineGenerator({
 		}));
 		const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum);
 		const meta = {
-			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
+			name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumOptions.typeSuffix) : resolver.resolveTypeName(node.name),
 			file: resolver.resolveFile({
 				name: node.name,
 				extname: ".ts"
@@ -1241,8 +1191,7 @@ const typeGenerator = defineGenerator({
 		const schemaPrinter = printerTs({
 			optionalType,
 			arrayType,
-			enumType,
-			enumTypeSuffix,
+			enum: enumOptions,
 			name: meta.name,
 			syntaxType,
 			description: node.description,
@@ -1270,7 +1219,7 @@ const typeGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1282,19 +1231,16 @@ const typeGenerator = defineGenerator({
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name: meta.name,
 				node,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: enumOptions,
 				resolver,
 				printer: schemaPrinter
 			})]
 		});
 	},
 	operation(node, ctx) {
-		const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
+		const { enum: enumOptions, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
-		const mode = ctx.getMode(output);
-		const params = ast.caseParams(node.parameters, paramsCasing);
+		const params = caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1307,7 +1253,7 @@ const typeGenerator = defineGenerator({
 		}) };
 		const enumSchemaNames = new Set(ctx.meta.enumNames);
 		function resolveImportName(schemaName) {
-			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+			if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumOptions.type) && enumOptions.typeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumOptions.typeSuffix);
 			return resolver.resolveTypeName(schemaName);
 		}
 		function renderSchemaType({ schema, name, keysToOmit }) {
@@ -1326,8 +1272,7 @@ const typeGenerator = defineGenerator({
 			const schemaPrinter = printerTs({
 				optionalType,
 				arrayType,
-				enumType,
-				enumTypeSuffix,
+				enum: enumOptions,
 				name,
 				syntaxType,
 				description: schema.description,
@@ -1336,7 +1281,7 @@ const typeGenerator = defineGenerator({
 				enumSchemaNames,
 				nodes: printer?.nodes
 			});
-			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+			return /* @__PURE__ */ jsxs(Fragment, { children: [imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name,
@@ -1348,9 +1293,7 @@ const typeGenerator = defineGenerator({
 			].join("-"))), /* @__PURE__ */ jsx(Type, {
 				name,
 				node: schema,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: enumOptions,
 				resolver,
 				printer: schemaPrinter
 			})] });
@@ -1361,9 +1304,9 @@ const typeGenerator = defineGenerator({
 		*/
 		function buildContentTypeVariants(entries, baseName, decorate) {
 			const variants = resolveContentTypeVariants(entries, baseName);
-			const unionSchema = ast.createSchema({
+			const unionSchema = ast.factory.createSchema({
 				type: "union",
-				members: variants.map((variant) => ast.createSchema({
+				members: variants.map((variant) => ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				}))
@@ -1378,7 +1321,10 @@ const typeGenerator = defineGenerator({
 			})] });
 		}
 		const paramTypes = params.map((param) => renderSchemaType({
-			schema: param.schema,
+			schema: {
+				...param.schema,
+				optional: !param.required
+			},
 			name: resolver.resolveParamName(node, param)
 		}));
 		const requestBodyContent = node.requestBody?.content ?? [];
@@ -1481,7 +1427,7 @@ const typeGenerator = defineGenerator({
 * casing/file-layout rules.
 *
 * The `default` method is supplied by `defineResolver`. It uses PascalCase for
-* type names and PascalCase-with-isFile for files.
+* type names and PascalCase file paths (dotted names become `/`-joined) for files.
 *
 * @example Resolve a type and file name
 * ```ts
@@ -1497,15 +1443,15 @@ const resolverTs = defineResolver(() => {
 		name: "default",
 		pluginName: "plugin-ts",
 		default(name, type) {
-			const resolved = pascalCase(name, { isFile: type === "file" });
-			return type === "file" ? resolved : ensureValidVarName(resolved);
+			if (type === "file") return toFilePath(name, pascalCase);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolveTypeName(name) {
 			return ensureValidVarName(pascalCase(name));
 		},
 		resolvePathName(name, type) {
-			const resolved = pascalCase(name, { isFile: type === "file" });
-			return type === "file" ? resolved : ensureValidVarName(resolved);
+			if (type === "file") return toFilePath(name, pascalCase);
+			return ensureValidVarName(pascalCase(name));
 		},
 		resolveParamName(node, param) {
 			return this.resolveTypeName(`${node.operationId} ${param.in} ${param.name}`);
@@ -1563,7 +1509,7 @@ const pluginTsName = "plugin-ts";
 *   plugins: [
 *     pluginTs({
 *       output: { path: './types' },
-*       enumType: 'asConst',
+*       enum: { type: 'asConst' },
 *       optionalType: 'questionTokenAndUndefined',
 *     }),
 *   ],
@@ -1573,9 +1519,15 @@ const pluginTsName = "plugin-ts";
 const pluginTs = definePlugin((options) => {
 	const { output = {
 		path: "types",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = createGroupConfig(group, { suffix: "Controller" });
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], enum: enumOptions = {}, optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
+	const groupConfig = createGroupConfig(group);
+	const resolvedEnum = {
+		type: enumOptions.type ?? "asConst",
+		constCasing: enumOptions.constCasing ?? "camelCase",
+		typeSuffix: enumOptions.typeSuffix ?? "Key",
+		keyCasing: enumOptions.keyCasing ?? "none"
+	};
 	return {
 		name: pluginTsName,
 		options,
@@ -1588,9 +1540,7 @@ const pluginTs = definePlugin((options) => {
 				optionalType,
 				group: groupConfig,
 				arrayType,
-				enumType,
-				enumTypeSuffix,
-				enumKeyCasing,
+				enum: resolvedEnum,
 				syntaxType,
 				paramsCasing,
 				printer
@@ -1599,7 +1549,7 @@ const pluginTs = definePlugin((options) => {
 				...resolverTs,
 				...userResolver
 			} : resolverTs);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(typeGenerator);
 			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }
@@ -1607,37 +1557,75 @@ const pluginTs = definePlugin((options) => {
 });
 //#endregion
 //#region src/printers/functionPrinter.ts
-const kindToHandlerKey = {
-	FunctionParameter: "functionParameter",
-	ParameterGroup: "parameterGroup",
-	FunctionParameters: "functionParameters",
-	ParamsType: "paramsType"
-};
 /**
-* Creates a function-parameter printer factory.
+* Renders a {@link ast.TypeExpression} to its TypeScript source.
+*
+* - a `string` is a type reference, returned as-is
+* - an `IndexedAccessType` becomes `objectType['indexType']`
+* - a `TypeLiteral` becomes `{ key: Type; key?: Type }`
 *
-* Uses `createPrinterFactory` and dispatches handlers by `node.kind`
-* (for function nodes) rather than by `node.type` (for schema nodes).
+* `transformType` is applied once to the fully rendered type, matching how the
+* printer wrapped reference types before the `ts.factory` model.
 */
-const defineFunctionPrinter = ast.createPrinterFactory((node) => kindToHandlerKey[node.kind]);
+function renderType(type, transformType) {
+	const rendered = renderTypeExpression(type);
+	return transformType ? transformType(rendered) : rendered;
+}
+function renderTypeExpression(type) {
+	if (typeof type === "string") return type;
+	if (ast.indexedAccessTypeDef.is(type)) return `${type.target}['${type.key}']`;
+	return `{ ${type.members.map((member) => {
+		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(member.name) ? member.name : JSON.stringify(member.name);
+		const value = renderTypeExpression(member.type);
+		return member.optional ? `${key}?: ${value}` : `${key}: ${value}`;
+	}).join("; ")} }`;
+}
+function groupMembers(param) {
+	if (typeof param.name === "string") return null;
+	return param.type && ast.typeLiteralDef.is(param.type) ? param.type.members : [];
+}
 function rank(param) {
-	if (param.kind === "ParameterGroup") {
-		if (param.default) return PARAM_RANK.withDefault;
-		return param.optional ?? param.properties.every((p) => p.optional || p.default !== void 0) ? PARAM_RANK.optional : PARAM_RANK.required;
-	}
 	if (param.rest) return PARAM_RANK.rest;
 	if (param.default) return PARAM_RANK.withDefault;
+	const members = groupMembers(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 sortChildParams(params) {
-	return params.toSorted((a, b) => rank(a) - rank(b));
+/**
+* Orders a destructured group's binding elements and type members together,
+* required fields first, matching how grouped children were sorted before.
+*/
+function sortedGroupMembers(name, type) {
+	const members = type && ast.typeLiteralDef.is(type) ? type.members : [];
+	const memberRank = (optional) => optional ? PARAM_RANK.optional : PARAM_RANK.required;
+	return name.elements.map((element, index) => ({
+		name: element.name,
+		type: members[index]?.type,
+		optional: members[index]?.optional
+	})).toSorted((a, b) => memberRank(a.optional) - memberRank(b.optional));
+}
+/**
+* Renders the type annotation of a destructured group. An inline object type is
+* rendered from the already-sorted members so its key order matches the binding;
+* a reference type is rendered as-is.
+*/
+function renderGroupType(type, sorted, transformType) {
+	if (!type) return void 0;
+	if (!ast.typeLiteralDef.is(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 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(member.name) ? member.name : JSON.stringify(member.name);
+		const value = renderType(member.type, transformType);
+		return member.optional ? `${key}?: ${value}` : `${key}: ${value}`;
+	}).join("; ")} }`;
 }
 /**
-* Default function-signature printer.
-* Covers the four standard output modes used across Kubb plugins.
+* Default function-signature printer. Renders a parameter list in one of two modes:
+* `declaration` for the function signature and `call` for the call arguments.
 *
 * @example
 * ```ts
@@ -1653,28 +1641,31 @@ function sortChildParams(params) {
 * printer.print(sig)  // → "petId: string, config: Config = {}"
 * ```
 */
-const functionPrinter = defineFunctionPrinter((options) => ({
+const functionPrinter = ast.createPrinterFactory((node) => node.kind)((options) => ({
 	name: "functionParameters",
 	options,
 	nodes: {
-		paramsType(node) {
-			if (node.kind !== "ParamsType") return null;
-			if (node.variant === "member") return `${node.base}['${node.key}']`;
-			if (node.variant === "struct") return `{ ${node.properties.map((p) => {
-				const typeStr = this.transform(p.type);
-				const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-				return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-			}).join("; ")} }`;
-			if (node.variant === "reference") return node.name;
-			return null;
-		},
-		functionParameter(node) {
+		FunctionParameter(node) {
 			const { mode, transformName, transformType } = this.options;
+			const isGroup = typeof node.name !== "string";
+			if (mode === "call") {
+				if (isGroup) return `{ ${sortedGroupMembers(node.name, node.type).map((member) => member.name).join(", ")} }`;
+				const name = transformName ? transformName(node.name) : node.name;
+				return node.rest ? `...${name}` : name;
+			}
+			if (isGroup) {
+				const sorted = sortedGroupMembers(node.name, node.type);
+				const binding = `{ ${sorted.map((member) => transformName ? transformName(member.name) : member.name).join(", ")} }`;
+				const allOptional = sorted.every((member) => member.optional);
+				const type = renderGroupType(node.type, sorted, transformType);
+				if (type) {
+					if (allOptional) return `${binding}: ${type} = ${node.default ?? "{}"}`;
+					return node.default ? `${binding}: ${type} = ${node.default}` : `${binding}: ${type}`;
+				}
+				return node.default ? `${binding} = ${node.default}` : binding;
+			}
 			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;
+			const type = node.type ? renderType(node.type, transformType) : void 0;
 			if (node.rest) return type ? `...${name}: ${type}` : `...${name}`;
 			if (type) {
 				if (node.optional) return `${name}?: ${type}`;
@@ -1682,39 +1673,12 @@ const functionPrinter = defineFunctionPrinter((options) => ({
 			}
 			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) {
+		FunctionParameters(node) {
 			return sortParams(node.params).map((p) => this.transform(p)).filter(Boolean).join(", ");
 		}
 	}
 }));
 //#endregion
-export { Enum, Type, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, resolverTs, typeGenerator };
+export { Enum, Type, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
 
 //# sourceMappingURL=index.js.map