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

package/dist/index.js

@@ -1,5 +1,5 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
-import { caseParams, extractRefName, isStringType, jsStringEscape, mapSchemaItems, mapSchemaProperties, stringify, syncSchemaRef, trimQuotes } from "@kubb/ast/utils";
+import { n as __name, t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
+import { 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 ts from "typescript";
@@ -258,7 +258,59 @@ const PARAM_RANK = {
 };
 //#endregion
 //#region src/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	SyntaxKind: () => SyntaxKind,
+	appendJSDocToNode: () => appendJSDocToNode,
+	buildIndexSignatures: () => buildIndexSignatures,
+	buildMemberNodes: () => buildMemberNodes,
+	buildPropertyType: () => buildPropertyType,
+	buildTupleNode: () => buildTupleNode,
+	constToTypeNode: () => constToTypeNode,
+	createArrayDeclaration: () => createArrayDeclaration,
+	createArrayTypeNode: () => createArrayTypeNode,
+	createEnumDeclaration: () => createEnumDeclaration,
+	createExportDeclaration: () => createExportDeclaration,
+	createFalse: () => createFalse,
+	createIdentifier: () => createIdentifier,
+	createImportDeclaration: () => createImportDeclaration,
+	createIndexSignature: () => createIndexSignature,
+	createInterfaceDeclaration: () => createInterfaceDeclaration,
+	createIntersectionDeclaration: () => createIntersectionDeclaration,
+	createJSDoc: () => createJSDoc,
+	createLiteralTypeNode: () => createLiteralTypeNode,
+	createNumericLiteral: () => createNumericLiteral,
+	createOmitDeclaration: () => createOmitDeclaration,
+	createOptionalTypeNode: () => createOptionalTypeNode,
+	createParameterSignature: () => createParameterSignature,
+	createPrefixUnaryExpression: () => createPrefixUnaryExpression,
+	createPropertySignature: () => createPropertySignature,
+	createQuestionToken: () => createQuestionToken,
+	createRestTypeNode: () => createRestTypeNode,
+	createStringLiteral: () => createStringLiteral,
+	createTrue: () => createTrue,
+	createTupleTypeNode: () => createTupleTypeNode,
+	createTypeAliasDeclaration: () => createTypeAliasDeclaration,
+	createTypeDeclaration: () => createTypeDeclaration,
+	createTypeLiteralNode: () => createTypeLiteralNode,
+	createTypeReferenceNode: () => createTypeReferenceNode,
+	createUnionDeclaration: () => createUnionDeclaration,
+	createUrlTemplateType: () => createUrlTemplateType,
+	dateOrStringNode: () => dateOrStringNode,
+	isNonNullable: () => isNonNullable$1,
+	keywordTypeNodes: () => keywordTypeNodes,
+	modifiers: () => modifiers,
+	syntaxKind: () => syntaxKind
+});
 const { SyntaxKind, factory } = ts;
+/**
+* Compares two strings by UTF-16 code unit, keeping sorted output identical across platforms
+* regardless of locale.
+*/
+function compareStrings(a, b) {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
 function isNumber(value) {
 	return typeof value === "number" && !Number.isNaN(value);
 }
@@ -366,6 +418,17 @@ function createParameterSignature(name, { modifiers, dotDotDotToken, questionTok
 	return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer);
 }
 /**
+* Creates a JSDoc comment node from an array of comment strings.
+* Returns null if no comments are provided.
+*/
+function createJSDoc({ comments }) {
+	if (!comments.length) return null;
+	return factory.createJSDocComment(factory.createNodeArray(comments.map((comment, i) => {
+		if (i === comments.length - 1) return factory.createJSDocText(comment);
+		return factory.createJSDocText(`${comment}\n`);
+	})));
+}
+/**
 * Attaches JSDoc comments to an AST node as synthetic leading comments.
 * Filters out undefined comments before attaching.
 *
@@ -423,6 +486,50 @@ function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
 	});
 }
 /**
+* Creates an import declaration with support for default imports, named imports, namespace imports, and type-only imports.
+* Optionally rename imported members with `propertyName` and `name` pairs.
+*
+* @example Default import
+* `import Pet from './Pet'`
+*
+* @example Named imports with rename
+* `import { Pet as Cat } from './Pet'`
+*
+* @example Namespace import
+* `import * as Pet from './Pet'`
+*/
+function createImportDeclaration({ name, path, isTypeOnly = false, isNameSpace = false }) {
+	if (!Array.isArray(name)) {
+		const importPropertyName = isNameSpace ? void 0 : factory.createIdentifier(name);
+		const importName = isNameSpace ? factory.createNamespaceImport(factory.createIdentifier(name)) : void 0;
+		return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, importPropertyName, importName), factory.createStringLiteral(path), void 0);
+	}
+	const sortedName = name.toSorted((a, b) => compareStrings(typeof a === "object" ? a.propertyName : a, typeof b === "object" ? b.propertyName : b));
+	return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamedImports(sortedName.map((item) => {
+		if (typeof item === "object") {
+			const obj = item;
+			if (obj.name) return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name));
+			return factory.createImportSpecifier(false, void 0, factory.createIdentifier(obj.propertyName));
+		}
+		return factory.createImportSpecifier(false, void 0, factory.createIdentifier(item));
+	}))), factory.createStringLiteral(path), void 0);
+}
+/**
+* Creates an export declaration with support for named exports, namespace exports, and type-only exports.
+* Sorts export names alphabetically for consistent output across platforms.
+*/
+function createExportDeclaration({ path, asAlias, isTypeOnly = false, name }) {
+	if (name && !Array.isArray(name) && !asAlias) console.warn(`When using name as string, asAlias should be true ${name}`);
+	if (!Array.isArray(name)) {
+		const parsedName = name?.match(/^\d/) ? `_${name?.slice(1)}` : name;
+		return factory.createExportDeclaration(void 0, isTypeOnly, asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : void 0, factory.createStringLiteral(path), void 0);
+	}
+	const sortedName = name.toSorted((a, b) => compareStrings(typeof a === "string" ? a : a.text, typeof b === "string" ? b : b.text));
+	return factory.createExportDeclaration(void 0, isTypeOnly, factory.createNamedExports(sortedName.map((propertyName) => {
+		return factory.createExportSpecifier(false, void 0, typeof propertyName === "string" ? factory.createIdentifier(propertyName) : propertyName);
+	})), factory.createStringLiteral(path), void 0);
+}
+/**
 * Apply casing transformation to enum keys
 */
 function applyEnumKeyCasing(key, casing = "none") {
@@ -757,6 +864,27 @@ function Type({ name, node, printer, enum: enumOptions, resolver }) {
 	})] });
 }
 //#endregion
+//#region ../../internals/shared/src/params.ts
+const caseParamsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Applies camelCase to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged. Results are cached per input array.
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	const cached = caseParamsCache.get(params);
+	if (cached) return cached;
+	const result = params.map((param) => ({
+		...param,
+		name: camelCase(param.name)
+	}));
+	caseParamsCache.set(params, result);
+	return result;
+}
+//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Maps a content type to the PascalCase suffix used to name per-content-type variants
@@ -807,7 +935,7 @@ function resolveContentTypeVariants(entries, baseName) {
 	});
 }
 function getOperationParameters(node, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -863,6 +991,7 @@ function buildPropertyJSDocComments(schema, optional) {
 	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}\``] : [];
+	const exampleValues = meta?.examples ?? [];
 	return [
 		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
 		...formatComment,
@@ -871,7 +1000,7 @@ function buildPropertyJSDocComments(schema, optional) {
 		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
 		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,
+		...exampleValues.map((example) => `@example ${example}`),
 		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null
 	].filter(Boolean);
 }
@@ -890,17 +1019,21 @@ function buildParams(node, { params, resolver }) {
 	});
 }
 function buildData(node, { resolver }) {
-	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing: "original" });
+	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const hasRequiredPath = pathParams.some((param) => param.required);
+	const hasRequiredQuery = queryParams.some((param) => param.required);
+	const hasRequiredHeader = headerParams.some((param) => param.required);
 	return ast.factory.createSchema({
 		type: "object",
 		deprecated: node.deprecated,
 		properties: [
 			ast.factory.createProperty({
-				name: "data",
-				schema: node.requestBody?.content?.[0]?.schema ? ast.factory.createSchema({
+				name: "body",
+				required: hasBody,
+				schema: hasBody ? ast.factory.createSchema({
 					type: "ref",
-					name: resolver.resolveDataName(node),
-					optional: true
+					name: resolver.resolveDataName(node)
 				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
@@ -908,11 +1041,14 @@ function buildData(node, { resolver }) {
 				})
 			}),
 			ast.factory.createProperty({
-				name: "pathParams",
-				required: pathParams.length > 0,
-				schema: pathParams.length > 0 ? buildParams(node, {
-					params: pathParams,
-					resolver
+				name: "path",
+				required: hasRequiredPath,
+				schema: pathParams.length > 0 ? ast.factory.createSchema({
+					...buildParams(node, {
+						params: pathParams,
+						resolver
+					}),
+					optional: !hasRequiredPath
 				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
@@ -920,13 +1056,14 @@ function buildData(node, { resolver }) {
 				})
 			}),
 			ast.factory.createProperty({
-				name: "queryParams",
+				name: "query",
+				required: hasRequiredQuery,
 				schema: queryParams.length > 0 ? ast.factory.createSchema({
 					...buildParams(node, {
 						params: queryParams,
 						resolver
 					}),
-					optional: true
+					optional: !hasRequiredQuery
 				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
@@ -934,26 +1071,19 @@ function buildData(node, { resolver }) {
 				})
 			}),
 			ast.factory.createProperty({
-				name: "headerParams",
+				name: "headers",
+				required: hasRequiredHeader,
 				schema: headerParams.length > 0 ? ast.factory.createSchema({
 					...buildParams(node, {
 						params: headerParams,
 						resolver
 					}),
-					optional: true
+					optional: !hasRequiredHeader
 				}) : ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
-			}),
-			ast.factory.createProperty({
-				name: "url",
-				required: true,
-				schema: ast.factory.createSchema({
-					type: "url",
-					path: node.path
-				})
 			})
 		]
 	});
@@ -985,9 +1115,7 @@ function buildResponseUnion(node, { resolver }) {
 }
 //#endregion
 //#region src/printers/printerTs.ts
-function isNonNullable(value) {
-	return value !== null && value !== void 0;
-}
+const { isNonNullable } = factory_exports;
 /**
 * TypeScript type printer built with `definePrinter`.
 *
@@ -1011,7 +1139,7 @@ function isNonNullable(value) {
 * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
 * ```
 */
-const printerTs = ast.definePrinter((options) => {
+const printerTs = ast.createPrinter((options) => {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
 	return {
 		name: "typescript",
@@ -1238,9 +1366,9 @@ const typeGenerator = defineGenerator({
 		});
 	},
 	operation(node, ctx) {
-		const { enum: enumOptions, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = ctx.options;
+		const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options;
 		const { adapter, config, resolver, root } = ctx;
-		const params = caseParams(node.parameters, paramsCasing);
+		const params = caseParams(node.parameters, "camelcase");
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1520,7 +1648,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, macros: userMacros, generators: userGenerators = [] } = options;
+	}, group, exclude = [], include, override = [], enum: enumOptions = {}, optionalType = "questionToken", arrayType = "array", syntaxType = "type", printer, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	const resolvedEnum = {
 		type: enumOptions.type ?? "asConst",
@@ -1542,7 +1670,6 @@ const pluginTs = definePlugin((options) => {
 				arrayType,
 				enum: resolvedEnum,
 				syntaxType,
-				paramsCasing,
 				printer
 			});
 			ctx.setResolver(userResolver ? {
@@ -1551,14 +1678,123 @@ const pluginTs = definePlugin((options) => {
 			} : resolverTs);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(typeGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }
 	};
 });
 //#endregion
+//#region src/printers/functionParams.ts
+/**
+* Narrows a {@link TypeExpression} to a {@link TypeLiteralNode}.
+*/
+function isTypeLiteral(type) {
+	return typeof type !== "string" && type.kind === "TypeLiteral";
+}
+/**
+* Narrows a {@link TypeExpression} to an {@link IndexedAccessTypeNode}.
+*/
+function isIndexedAccessType(type) {
+	return typeof type !== "string" && type.kind === "IndexedAccessType";
+}
+/**
+* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
+*
+* @example
+* ```ts
+* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+* // { petId: string }
+* ```
+*/
+function createTypeLiteral(props) {
+	return {
+		kind: "TypeLiteral",
+		...props
+	};
+}
+/**
+* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+*
+* @example
+* ```ts
+* createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })
+* // DeletePetPathParams['petId']
+* ```
+*/
+function createIndexedAccessType(props) {
+	return {
+		kind: "IndexedAccessType",
+		...props
+	};
+}
+/**
+* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+*
+* @example
+* ```ts
+* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+* // { id, name }
+* ```
+*/
+function createObjectBindingPattern(props) {
+	return {
+		kind: "ObjectBindingPattern",
+		...props
+	};
+}
+/**
+* Creates a {@link FunctionParameterNode}. `optional` defaults to `false`.
+* Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+* paired with a {@link TypeLiteralNode} type.
+*
+* @example Optional param
+* ```ts
+* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+* // → params?: QueryParams
+* ```
+*
+* @example Destructured group
+* ```ts
+* createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+* // → { id, name }: { id: string; name?: string } = {}
+* ```
+*/
+function createFunctionParameter(input) {
+	if ("properties" in input) return {
+		kind: "FunctionParameter",
+		name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),
+		type: createTypeLiteral({ members: input.properties.map((p) => ({
+			name: p.name,
+			type: p.type,
+			optional: p.optional ?? false
+		})) }),
+		optional: input.optional ?? false,
+		...input.default !== void 0 ? { default: input.default } : {}
+	};
+	return {
+		kind: "FunctionParameter",
+		optional: false,
+		...input
+	};
+}
+/**
+* Creates a {@link FunctionParametersNode} from an ordered list of parameters.
+*
+* @example
+* ```ts
+* const empty = createFunctionParameters()
+* // { params: [] }
+* ```
+*/
+function createFunctionParameters(props = {}) {
+	return {
+		kind: "FunctionParameters",
+		params: [],
+		...props
+	};
+}
+//#endregion
 //#region src/printers/functionPrinter.ts
 /**
-* Renders a {@link ast.TypeExpression} to its TypeScript source.
+* Renders a {@link TypeExpression} to its TypeScript source.
 *
 * - a `string` is a type reference, returned as-is
 * - an `IndexedAccessType` becomes `objectType['indexType']`
@@ -1571,18 +1807,24 @@ function renderType(type, transformType) {
 	const rendered = renderTypeExpression(type);
 	return transformType ? transformType(rendered) : rendered;
 }
+/**
+* Renders an object-type key, quoting it as a string literal when it is not a valid
+* identifier so `{ 'content-type': string }` stays valid TypeScript.
+*/
+function renderKey(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
 function renderTypeExpression(type) {
 	if (typeof type === "string") return type;
-	if (ast.indexedAccessTypeDef.is(type)) return `${type.target}['${type.key}']`;
+	if (isIndexedAccessType(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}`;
+		return member.optional ? `${renderKey(member.name)}?: ${value}` : `${renderKey(member.name)}: ${value}`;
 	}).join("; ")} }`;
 }
 function groupMembers(param) {
 	if (typeof param.name === "string") return null;
-	return param.type && ast.typeLiteralDef.is(param.type) ? param.type.members : [];
+	return param.type && isTypeLiteral(param.type) ? param.type.members : [];
 }
 function rank(param) {
 	if (param.rest) return PARAM_RANK.rest;
@@ -1594,35 +1836,68 @@ function rank(param) {
 function sortParams(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 members = type && isTypeLiteral(type) ? type.members : [];
 	const memberRank = (optional) => optional ? PARAM_RANK.optional : PARAM_RANK.required;
 	return name.elements.map((element, index) => ({
 		name: element.name,
+		propertyName: element.propertyName,
 		type: members[index]?.type,
 		optional: members[index]?.optional
 	})).toSorted((a, b) => memberRank(a.optional) - memberRank(b.optional));
 }
 /**
+* Renders one binding element: the local name, prefixed with its source key when the
+* binding renames the property, as in `{ petId: id }`.
+*/
+function renderBindingMember(member, transformName) {
+	const local = transformName ? transformName(member.name) : member.name;
+	return member.propertyName ? `${member.propertyName}: ${local}` : local;
+}
+/**
 * 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);
+	if (!isTypeLiteral(type)) return renderType(type);
 	const typed = sorted.filter((member) => member.type !== void 0);
 	if (!typed.length) return void 0;
 	return `{ ${typed.map((member) => {
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(member.name) ? member.name : JSON.stringify(member.name);
+		const key = renderKey(member.propertyName ?? member.name);
 		const value = renderType(member.type, transformType);
 		return member.optional ? `${key}?: ${value}` : `${key}: ${value}`;
 	}).join("; ")} }`;
 }
+function printParameter(node, options) {
+	const { mode, transformName, transformType } = options;
+	const isGroup = typeof node.name !== "string";
+	if (mode === "call") {
+		if (isGroup) return `{ ${sortedGroupMembers(node.name, node.type).map((member) => renderBindingMember(member)).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) => renderBindingMember(member, transformName)).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 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}`;
+		return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
+	}
+	return node.default ? `${name} = ${node.default}` : name;
+}
 /**
 * Default function-signature printer. Renders a parameter list in one of two modes:
 * `declaration` for the function signature and `call` for the call arguments.
@@ -1641,44 +1916,198 @@ function renderGroupType(type, sorted, transformType) {
 * printer.print(sig)  // → "petId: string, config: Config = {}"
 * ```
 */
-const functionPrinter = ast.createPrinterFactory((node) => node.kind)((options) => ({
-	name: "functionParameters",
-	options,
-	nodes: {
-		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 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}`;
-				return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
-			}
-			return node.default ? `${name} = ${node.default}` : name;
-		},
-		FunctionParameters(node) {
-			return sortParams(node.params).map((p) => this.transform(p)).filter(Boolean).join(", ");
+function functionPrinter(options) {
+	return {
+		name: "functionParameters",
+		options,
+		print(node) {
+			return sortParams(node.params).map((p) => printParameter(p, options)).filter(Boolean).join(", ");
+		}
+	};
+}
+//#endregion
+//#region src/printers/operationParams.ts
+/**
+* Resolves the {@link TypeExpression} for an individual parameter.
+*
+* Without a resolver, it falls back to the schema primitive (a plain type-name string). When the
+* parameter belongs to a named group, it emits an `IndexedAccessType` like `GroupParams['petId']`,
+* otherwise the resolved individual name.
+*/
+function resolveParamType({ node, param, resolver }) {
+	if (!resolver) return param.schema.primitive ?? "unknown";
+	const individualName = resolver.resolveParamName(node, param);
+	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
+	const groupResolvers = {
+		path: resolver.resolvePathParamsName,
+		query: resolver.resolveQueryParamsName,
+		header: resolver.resolveHeaderParamsName
+	};
+	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
+	if (groupName && groupName !== individualName) return createIndexedAccessType({
+		target: groupName,
+		key: param.name
+	});
+	return individualName;
+}
+/**
+* Derives a {@link ParamGroupType} for a query or header group from the resolver.
+*
+* Returns `null` when there is no resolver, no params, or the group name equals the
+* individual param name (so there is no real group to emit).
+*/
+function resolveGroupType({ node, params, group, resolver }) {
+	if (!resolver || !params.length) return null;
+	const firstParam = params[0];
+	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
+	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
+	return {
+		type: groupName,
+		optional: params.every((p) => !p.required)
+	};
+}
+/**
+* Converts an `OperationNode` into function parameters for code generation.
+*
+* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
+* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
+* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
+* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
+*/
+function createOperationParams(node, options) {
+	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const dataName = paramNames?.data ?? "data";
+	const paramsName = paramNames?.params ?? "params";
+	const headersName = paramNames?.headers ?? "headers";
+	const pathName = paramNames?.path ?? "pathParams";
+	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
+	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
+	const casedParams = caseParams(node.parameters, paramsCasing);
+	const pathParams = casedParams.filter((p) => p.in === "path");
+	const queryParams = casedParams.filter((p) => p.in === "query");
+	const headerParams = casedParams.filter((p) => p.in === "header");
+	const toProperty = (param) => ({
+		name: param.name,
+		type: wrapTypeExpression(resolveParamType({
+			node,
+			param,
+			resolver
+		})),
+		optional: !param.required
+	});
+	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
+	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
+	const bodyProperty = bodyType ? [{
+		name: dataName,
+		type: bodyType,
+		optional: !(node.requestBody?.required ?? false)
+	}] : [];
+	const trailingGroups = [{
+		name: paramsName,
+		node,
+		params: queryParams,
+		groupType: resolveGroupType({
+			node,
+			params: queryParams,
+			group: "query",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}, {
+		name: headersName,
+		node,
+		params: headerParams,
+		groupType: resolveGroupType({
+			node,
+			params: headerParams,
+			group: "header",
+			resolver
+		}),
+		resolver,
+		wrapType
+	}];
+	const params = [];
+	if (paramsType === "object") {
+		const children = [
+			...pathParams.map(toProperty),
+			...bodyProperty,
+			...trailingGroups.flatMap(buildGroupProperty)
+		];
+		if (children.length) params.push(createFunctionParameter({
+			properties: children,
+			default: emptyObjectDefault(children)
+		}));
+	} else {
+		if (pathParamsType === "inlineSpread" && pathParams.length) {
+			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
+			params.push(createFunctionParameter({
+				name: pathName,
+				type: spreadType ? wrapType(spreadType) : void 0,
+				rest: true
+			}));
+		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))));
+		else if (pathParams.length) {
+			const pathChildren = pathParams.map(toProperty);
+			params.push(createFunctionParameter({
+				properties: pathChildren,
+				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
+			}));
 		}
+		params.push(...bodyProperty.map((p) => createFunctionParameter(p)));
+		params.push(...trailingGroups.flatMap(buildGroupParam));
 	}
-}));
+	params.push(...extraParams);
+	return createFunctionParameters({ params });
+}
+/**
+* Builds the property descriptor for a query or header group.
+* Returns an empty array when there are no params to emit.
+*
+* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+* {@link TypeLiteralNode} from the individual params.
+*/
+function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
+	if (groupType) return [{
+		name,
+		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
+		optional: groupType.optional
+	}];
+	if (params.length) return [{
+		name,
+		type: buildTypeLiteral({
+			node,
+			params,
+			resolver
+		}),
+		optional: params.every((p) => !p.required)
+	}];
+	return [];
+}
+/**
+* Builds a single {@link FunctionParameterNode} for a query or header group.
+* Returns an empty array when there are no params to emit.
+*/
+function buildGroupParam(args) {
+	return buildGroupProperty(args).map((p) => createFunctionParameter(p));
+}
+/**
+* Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
+*
+* Used when query or header parameters have no dedicated group type name.
+*/
+function buildTypeLiteral({ node, params, resolver }) {
+	return createTypeLiteral({ members: params.map((p) => ({
+		name: p.name,
+		type: resolveParamType({
+			node,
+			param: p,
+			resolver
+		}),
+		optional: !p.required
+	})) });
+}
 //#endregion
-export { Enum, Type, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
+export { Enum, Type, createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createOperationParams, createTypeLiteral, pluginTs as default, pluginTs, functionPrinter, pluginTsName, printerTs, renderType, resolverTs, typeGenerator };
 
 //# sourceMappingURL=index.js.map