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

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
-import { Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
 import ts from "typescript";
+import { Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
 import { KubbReactNode } from "@kubb/renderer-jsx/types";
 
 //#region src/printers/printerTs.d.ts
@@ -368,19 +368,22 @@ type Options = OutputOptions & {
    */
   resolver?: Partial<ResolverTs> & ThisType<ResolverTs>;
   /**
-   * AST visitor applied to each schema or operation node before printing.
-   * Methods you omit fall back to the preset transformer.
+   * Macros applied to each schema or operation node before printing.
+   * Callbacks you omit fall back to the preset behavior.
    *
    * @example Drop writeOnly properties from response types
    * ```ts
-   * transformer: {
-   *   property(node) {
-   *     if (node.schema.writeOnly) return undefined
-   *   }
-   * }
+   * macros: [
+   *   {
+   *     name: 'drop-write-only',
+   *     property(node) {
+   *       if (node.schema.writeOnly) return undefined
+   *     },
+   *   },
+   * ]
    * ```
    */
-  transformer?: ast.Visitor;
+  macros?: Array<ast.Macro>;
   /**
    * Replace the TypeScript handler for a specific schema type (`'integer'`, `'date'`, ...).
    * Each handler returns a TypeScript AST node for that schema type. Use `this.transform`
@@ -533,18 +536,27 @@ declare const pluginTsName = "plugin-ts";
 declare const pluginTs: (options?: Options | undefined) => import("@kubb/core").Plugin<PluginTs>;
 //#endregion
 //#region src/printers/functionPrinter.d.ts
+/**
+ * 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 }`
+ *
+ * `transformType` is applied once to the fully rendered type, matching how the
+ * printer wrapped reference types before the `ts.factory` model.
+ */
+declare function renderType(type: ast.TypeExpression, transformType?: (type: string) => string): string;
 type FunctionPrinterOptions = {
   /**
    * Rendering modes supported by `functionPrinter`.
    *
-   * | Mode          | Output example                              | Use case                        |
-   * |---------------|---------------------------------------------|---------------------------------|
-   * | `declaration` | `id: string, config: Config = {}`           | Function parameter declaration |
-   * | `call`        | `id, { method, url }`                       | Function call arguments |
-   * | `keys`        | `{ id, config }`                            | Key names only (destructuring) |
-   * | `values`      | `{ id: id, config: config }`                | Key/value object entries |
+   * | Mode          | Output example                    | Use case                       |
+   * |---------------|-----------------------------------|--------------------------------|
+   * | `declaration` | `id: string, config: Config = {}` | Function parameter declaration |
+   * | `call`        | `id, { method, url }`             | Function call arguments        |
    */
-  mode: 'declaration' | 'call' | 'keys' | 'values';
+  mode: 'declaration' | 'call';
   /**
    * Optional transformation applied to every parameter name before printing.
    */
@@ -555,8 +567,8 @@ type FunctionPrinterOptions = {
   transformType?: (type: string) => string;
 };
 /**
- * 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
@@ -600,5 +612,5 @@ declare const functionPrinter: (options?: FunctionPrinterOptions | undefined) =>
  */
 declare const resolverTs: ResolverTs;
 //#endregion
-export { Enum, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, resolverTs, typeGenerator };
+export { Enum, type PluginTs, type PrinterTsFactory, type PrinterTsNodes, type PrinterTsOptions, type ResolverTs, Type, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,10 +1,10 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
-import { extractRefName, jsStringEscape, stringify, trimQuotes } from "@kubb/ast/utils";
+import { caseParams, extractRefName, isStringType, jsStringEscape, mapSchemaItems, mapSchemaProperties, stringify, syncSchemaRef, trimQuotes } from "@kubb/ast/utils";
 import { parserTs } from "@kubb/parser-ts";
 import { File, jsxRenderer } from "@kubb/renderer-jsx";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
 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.
@@ -454,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());
@@ -465,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);
 		}
@@ -477,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);
 		}
@@ -638,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;
 }
 /**
@@ -807,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"),
@@ -855,8 +855,11 @@ function createGroupConfig(group) {
 * 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}\``] : [];
@@ -869,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
 				})
@@ -955,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)
 			})
@@ -970,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)
 		}))
@@ -1052,11 +1057,11 @@ const printerTs = ast.definePrinter((options) => {
 				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
 						});
@@ -1076,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;
 			},
@@ -1086,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)];
@@ -1110,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;
@@ -1234,7 +1240,7 @@ const typeGenerator = defineGenerator({
 	operation(node, ctx) {
 		const { enum: enumOptions, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
-		const params = ast.caseParams(node.parameters, paramsCasing);
+		const params = caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1298,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
 				}))
@@ -1315,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 ?? [];
@@ -1511,7 +1520,7 @@ const pluginTs = 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",
@@ -1540,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);
 		} }
@@ -1548,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.
 *
-* 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 = 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
@@ -1594,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}`;
@@ -1623,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