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

package/dist/index.cjs

@@ -31,10 +31,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let _kubb_ast_utils = require("@kubb/ast/utils");
 let _kubb_parser_ts = require("@kubb/parser-ts");
 let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
-let _kubb_core = require("@kubb/core");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
+let _kubb_core = require("@kubb/core");
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -484,7 +484,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(typescript.default.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(typescript.default.SyntaxKind.ConstKeyword) : void 0].filter((modifier) => modifier !== void 0), factory.createIdentifier(typeName), enums.map(([key, value]) => {
 		let initializer = factory.createStringLiteral(value?.toString());
@@ -495,7 +495,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);
 		}
@@ -507,7 +507,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(typescript.default.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);
 		}
@@ -668,12 +668,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 = _kubb_core.ast.syncSchemaRef(schema);
+	const meta = (0, _kubb_ast_utils.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;
 }
 /**
@@ -837,7 +837,7 @@ function resolveContentTypeVariants(entries, baseName) {
 	});
 }
 function getOperationParameters(node, options = {}) {
-	const params = _kubb_core.ast.caseParams(node.parameters, options.paramsCasing);
+	const params = (0, _kubb_ast_utils.caseParams)(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -885,8 +885,11 @@ function createGroupConfig(group) {
 * Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
 
 */
-function buildPropertyJSDocComments(schema) {
-	const meta = _kubb_core.ast.syncSchemaRef(schema);
+function isSchemaOptional(schema) {
+	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
+}
+function buildPropertyJSDocComments(schema, optional) {
+	const meta = (0, _kubb_ast_utils.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}\``] : [];
@@ -899,83 +902,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" ? (0, _kubb_ast_utils.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 _kubb_core.ast.createSchema({
+	return _kubb_core.ast.factory.createSchema({
 		type: "object",
-		properties: params.map((param) => _kubb_core.ast.createProperty({
+		properties: params.map((param) => _kubb_core.ast.factory.createProperty({
 			name: param.name,
 			required: param.required,
-			schema: _kubb_core.ast.createSchema({
+			schema: _kubb_core.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 _kubb_core.ast.createSchema({
+	return _kubb_core.ast.factory.createSchema({
 		type: "object",
 		deprecated: node.deprecated,
 		properties: [
-			_kubb_core.ast.createProperty({
+			_kubb_core.ast.factory.createProperty({
 				name: "data",
-				schema: node.requestBody?.content?.[0]?.schema ? _kubb_core.ast.createSchema({
+				schema: node.requestBody?.content?.[0]?.schema ? _kubb_core.ast.factory.createSchema({
 					type: "ref",
 					name: resolver.resolveDataName(node),
 					optional: true
-				}) : _kubb_core.ast.createSchema({
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.createProperty({
+			_kubb_core.ast.factory.createProperty({
 				name: "pathParams",
 				required: pathParams.length > 0,
 				schema: pathParams.length > 0 ? buildParams(node, {
 					params: pathParams,
 					resolver
-				}) : _kubb_core.ast.createSchema({
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
-					primitive: void 0
+					primitive: void 0,
+					optional: true
 				})
 			}),
-			_kubb_core.ast.createProperty({
+			_kubb_core.ast.factory.createProperty({
 				name: "queryParams",
-				schema: queryParams.length > 0 ? _kubb_core.ast.createSchema({
+				schema: queryParams.length > 0 ? _kubb_core.ast.factory.createSchema({
 					...buildParams(node, {
 						params: queryParams,
 						resolver
 					}),
 					optional: true
-				}) : _kubb_core.ast.createSchema({
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.createProperty({
+			_kubb_core.ast.factory.createProperty({
 				name: "headerParams",
-				schema: headerParams.length > 0 ? _kubb_core.ast.createSchema({
+				schema: headerParams.length > 0 ? _kubb_core.ast.factory.createSchema({
 					...buildParams(node, {
 						params: headerParams,
 						resolver
 					}),
 					optional: true
-				}) : _kubb_core.ast.createSchema({
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.createProperty({
+			_kubb_core.ast.factory.createProperty({
 				name: "url",
 				required: true,
-				schema: _kubb_core.ast.createSchema({
+				schema: _kubb_core.ast.factory.createSchema({
 					type: "url",
 					path: node.path
 				})
@@ -985,12 +990,12 @@ function buildData(node, { resolver }) {
 }
 function buildResponses(node, { resolver }) {
 	if (node.responses.length === 0) return null;
-	return _kubb_core.ast.createSchema({
+	return _kubb_core.ast.factory.createSchema({
 		type: "object",
-		properties: node.responses.map((res) => _kubb_core.ast.createProperty({
+		properties: node.responses.map((res) => _kubb_core.ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
-			schema: _kubb_core.ast.createSchema({
+			schema: _kubb_core.ast.factory.createSchema({
 				type: "ref",
 				name: resolver.resolveResponseStatusName(node, res.statusCode)
 			})
@@ -1000,9 +1005,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 _kubb_core.ast.createSchema({
+	return _kubb_core.ast.factory.createSchema({
 		type: "union",
-		members: responsesWithSchema.map((res) => _kubb_core.ast.createSchema({
+		members: responsesWithSchema.map((res) => _kubb_core.ast.factory.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
@@ -1082,11 +1087,11 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 				const hasStringLiteral = members.some((m) => {
 					return _kubb_core.ast.narrowSchema(m, _kubb_core.ast.schemaTypes.enum)?.primitive === "string";
 				});
-				const hasPlainString = members.some((m) => _kubb_core.ast.isStringType(m));
+				const hasPlainString = members.some((m) => (0, _kubb_ast_utils.isStringType)(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if (_kubb_core.ast.isStringType(m)) return createIntersectionDeclaration({
+						if ((0, _kubb_ast_utils.isStringType)(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -1106,7 +1111,7 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 			},
 			array(node) {
 				return createArrayDeclaration({
-					nodes: (node.items ?? []).map((item) => this.transform(item)).filter(isNonNullable),
+					nodes: (0, _kubb_ast_utils.mapSchemaItems)(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
 				}) ?? null;
 			},
@@ -1116,18 +1121,19 @@ const printerTs = _kubb_core.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 = _kubb_core.ast.syncSchemaRef(prop.schema);
+				const propertyNodes = (0, _kubb_ast_utils.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 = (0, _kubb_ast_utils.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)];
@@ -1140,7 +1146,7 @@ const printerTs = _kubb_core.ast.definePrinter((options) => {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = _kubb_core.ast.syncSchemaRef(node);
+			const meta = (0, _kubb_ast_utils.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;
@@ -1264,7 +1270,7 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 	operation(node, ctx) {
 		const { enum: enumOptions, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
-		const params = _kubb_core.ast.caseParams(node.parameters, paramsCasing);
+		const params = (0, _kubb_ast_utils.caseParams)(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1328,9 +1334,9 @@ const typeGenerator = (0, _kubb_core.defineGenerator)({
 		*/
 		function buildContentTypeVariants(entries, baseName, decorate) {
 			const variants = resolveContentTypeVariants(entries, baseName);
-			const unionSchema = _kubb_core.ast.createSchema({
+			const unionSchema = _kubb_core.ast.factory.createSchema({
 				type: "union",
-				members: variants.map((variant) => _kubb_core.ast.createSchema({
+				members: variants.map((variant) => _kubb_core.ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				}))
@@ -1345,7 +1351,10 @@ const typeGenerator = (0, _kubb_core.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 ?? [];
@@ -1541,7 +1550,7 @@ const pluginTs = (0, _kubb_core.definePlugin)((options) => {
 	const { output = {
 		path: "types",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], enum: enumOptions = {}, optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
+	}, 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",
@@ -1570,7 +1579,7 @@ const pluginTs = (0, _kubb_core.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);
 		} }
@@ -1578,37 +1587,75 @@ const pluginTs = (0, _kubb_core.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.
 *
-* Uses `createPrinterFactory` and dispatches handlers by `node.kind`
-* (for function nodes) rather than by `node.type` (for schema nodes).
+* - a `string` is a type reference, returned as-is
+* - an `IndexedAccessType` becomes `objectType['indexType']`
+* - a `TypeLiteral` becomes `{ key: Type; key?: Type }`
+*
+* `transformType` is applied once to the fully rendered type, matching how the
+* printer wrapped reference types before the `ts.factory` model.
 */
-const defineFunctionPrinter = _kubb_core.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 (_kubb_core.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 && _kubb_core.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 && _kubb_core.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 (!_kubb_core.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
@@ -1624,28 +1671,31 @@ function sortChildParams(params) {
 * printer.print(sig)  // → "petId: string, config: Config = {}"
 * ```
 */
-const functionPrinter = defineFunctionPrinter((options) => ({
+const functionPrinter = _kubb_core.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}`;
@@ -1653,34 +1703,7 @@ 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(", ");
 		}
 	}
@@ -1693,6 +1716,7 @@ exports.functionPrinter = functionPrinter;
 exports.pluginTs = pluginTs;
 exports.pluginTsName = pluginTsName;
 exports.printerTs = printerTs;
+exports.renderType = renderType;
 exports.resolverTs = resolverTs;
 exports.typeGenerator = typeGenerator;