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

package/dist/index.cjs

@@ -13,6 +13,15 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -31,10 +40,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.
@@ -288,7 +297,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 } = typescript.default;
+/**
+* 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);
 }
@@ -396,6 +457,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.
 *
@@ -453,6 +525,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") {
@@ -484,7 +600,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 +611,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 +623,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 +784,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;
 }
 /**
@@ -787,6 +903,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
@@ -837,7 +974,7 @@ function resolveContentTypeVariants(entries, baseName) {
 	});
 }
 function getOperationParameters(node, options = {}) {
-	const params = _kubb_core.ast.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"),
@@ -885,11 +1022,15 @@ 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}\``] : [];
+	const exampleValues = meta?.examples ?? [];
 	return [
 		hasDescription ? `@description ${(0, _kubb_ast_utils.jsStringEscape)(meta.description)}` : null,
 		...formatComment,
@@ -898,99 +1039,102 @@ function buildPropertyJSDocComments(schema) {
 		!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" ? (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
+		...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);
 }
 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({
+	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 _kubb_core.ast.factory.createSchema({
 		type: "object",
 		deprecated: node.deprecated,
 		properties: [
-			_kubb_core.ast.createProperty({
-				name: "data",
-				schema: node.requestBody?.content?.[0]?.schema ? _kubb_core.ast.createSchema({
+			_kubb_core.ast.factory.createProperty({
+				name: "body",
+				required: hasBody,
+				schema: hasBody ? _kubb_core.ast.factory.createSchema({
 					type: "ref",
-					name: resolver.resolveDataName(node),
-					optional: true
-				}) : _kubb_core.ast.createSchema({
+					name: resolver.resolveDataName(node)
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.createProperty({
-				name: "pathParams",
-				required: pathParams.length > 0,
-				schema: pathParams.length > 0 ? buildParams(node, {
-					params: pathParams,
-					resolver
-				}) : _kubb_core.ast.createSchema({
+			_kubb_core.ast.factory.createProperty({
+				name: "path",
+				required: hasRequiredPath,
+				schema: pathParams.length > 0 ? _kubb_core.ast.factory.createSchema({
+					...buildParams(node, {
+						params: pathParams,
+						resolver
+					}),
+					optional: !hasRequiredPath
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
-					primitive: void 0
+					primitive: void 0,
+					optional: true
 				})
 			}),
-			_kubb_core.ast.createProperty({
-				name: "queryParams",
-				schema: queryParams.length > 0 ? _kubb_core.ast.createSchema({
+			_kubb_core.ast.factory.createProperty({
+				name: "query",
+				required: hasRequiredQuery,
+				schema: queryParams.length > 0 ? _kubb_core.ast.factory.createSchema({
 					...buildParams(node, {
 						params: queryParams,
 						resolver
 					}),
-					optional: true
-				}) : _kubb_core.ast.createSchema({
+					optional: !hasRequiredQuery
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
 			}),
-			_kubb_core.ast.createProperty({
-				name: "headerParams",
-				schema: headerParams.length > 0 ? _kubb_core.ast.createSchema({
+			_kubb_core.ast.factory.createProperty({
+				name: "headers",
+				required: hasRequiredHeader,
+				schema: headerParams.length > 0 ? _kubb_core.ast.factory.createSchema({
 					...buildParams(node, {
 						params: headerParams,
 						resolver
 					}),
-					optional: true
-				}) : _kubb_core.ast.createSchema({
+					optional: !hasRequiredHeader
+				}) : _kubb_core.ast.factory.createSchema({
 					type: "never",
 					primitive: void 0,
 					optional: true
 				})
-			}),
-			_kubb_core.ast.createProperty({
-				name: "url",
-				required: true,
-				schema: _kubb_core.ast.createSchema({
-					type: "url",
-					path: node.path
-				})
 			})
 		]
 	});
 }
 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 +1144,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)
 		}))
@@ -1010,9 +1154,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`.
 *
@@ -1036,7 +1178,7 @@ function isNonNullable(value) {
 * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration
 * ```
 */
-const printerTs = _kubb_core.ast.definePrinter((options) => {
+const printerTs = _kubb_core.ast.createPrinter((options) => {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
 	return {
 		name: "typescript",
@@ -1082,11 +1224,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 +1248,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 +1258,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 +1283,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;
@@ -1262,9 +1405,9 @@ const typeGenerator = (0, _kubb_core.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 = _kubb_core.ast.caseParams(node.parameters, paramsCasing);
+		const params = caseParams(node.parameters, "camelcase");
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1328,9 +1471,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 +1488,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 +1687,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", printer, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	const resolvedEnum = {
 		type: enumOptions.type ?? "asConst",
@@ -1563,52 +1709,237 @@ const pluginTs = (0, _kubb_core.definePlugin)((options) => {
 				arrayType,
 				enum: resolvedEnum,
 				syntaxType,
-				paramsCasing,
 				printer
 			});
 			ctx.setResolver(userResolver ? {
 				...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);
 		} }
 	};
 });
 //#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
-const kindToHandlerKey = {
-	FunctionParameter: "functionParameter",
-	ParameterGroup: "parameterGroup",
-	FunctionParameters: "functionParameters",
-	ParamsType: "paramsType"
-};
 /**
-* Creates a function-parameter printer factory.
+* Renders a {@link 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.
+*/
+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.
 */
-const defineFunctionPrinter = _kubb_core.ast.createPrinterFactory((node) => kindToHandlerKey[node.kind]);
+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 (isIndexedAccessType(type)) return `${type.target}['${type.key}']`;
+	return `{ ${type.members.map((member) => {
+		const value = renderTypeExpression(member.type);
+		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 && isTypeLiteral(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));
+function sortedGroupMembers(name, type) {
+	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));
 }
 /**
-* Default function-signature printer.
-* Covers the four standard output modes used across Kubb plugins.
+* 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 (!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 = 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.
 *
 * @example
 * ```ts
@@ -1624,75 +1955,212 @@ function sortChildParams(params) {
 * printer.print(sig)  // → "petId: string, config: Config = {}"
 * ```
 */
-const functionPrinter = defineFunctionPrinter((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) {
-			const { mode, transformName, transformType } = this.options;
-			const name = transformName ? transformName(node.name) : node.name;
-			const rawType = node.type ? this.transform(node.type) : void 0;
-			const type = rawType != null && transformType ? transformType(rawType) : rawType;
-			if (mode === "keys" || mode === "values") return node.rest ? `...${name}` : name;
-			if (mode === "call") return node.rest ? `...${name}` : name;
-			if (node.rest) return type ? `...${name}: ${type}` : `...${name}`;
-			if (type) {
-				if (node.optional) return `${name}?: ${type}`;
-				return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
-			}
-			return node.default ? `${name} = ${node.default}` : name;
-		},
-		parameterGroup(node) {
-			const { mode, transformName, transformType } = this.options;
-			const sorted = sortChildParams(node.properties);
-			const isOptional = node.optional ?? sorted.every((p) => p.optional || p.default !== void 0);
-			if (node.inline) return sorted.map((p) => this.transform(p)).filter(Boolean).join(", ");
-			if (mode === "keys" || mode === "values") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
-			if (mode === "call") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
-			const names = sorted.map((p) => {
-				return transformName ? transformName(p.name) : p.name;
-			});
-			const nameStr = names.length ? `{ ${names.join(", ")} }` : void 0;
-			if (!nameStr) return null;
-			let typeAnnotation = node.type ? this.transform(node.type) ?? void 0 : void 0;
-			if (!typeAnnotation) {
-				const typeParts = sorted.filter((p) => p.type).map((p) => {
-					const rawT = p.type ? this.transform(p.type) : void 0;
-					const t = rawT != null && transformType ? transformType(rawT) : rawT;
-					return p.optional || p.default !== void 0 ? `${p.name}?: ${t}` : `${p.name}: ${t}`;
-				});
-				typeAnnotation = typeParts.length ? `{ ${typeParts.join("; ")} }` : void 0;
-			}
-			if (typeAnnotation) {
-				if (isOptional) return `${nameStr}: ${typeAnnotation} = ${node.default ?? "{}"}`;
-				return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`;
-			}
-			return node.default ? `${nameStr} = ${node.default}` : nameStr;
-		},
-		functionParameters(node) {
-			return sortParams(node.params).map((p) => this.transform(p)).filter(Boolean).join(", ");
+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
 exports.Enum = Enum;
 exports.Type = Type;
+exports.createFunctionParameter = createFunctionParameter;
+exports.createFunctionParameters = createFunctionParameters;
+exports.createIndexedAccessType = createIndexedAccessType;
+exports.createObjectBindingPattern = createObjectBindingPattern;
+exports.createOperationParams = createOperationParams;
+exports.createTypeLiteral = createTypeLiteral;
 exports.default = pluginTs;
 exports.functionPrinter = functionPrinter;
 exports.pluginTs = pluginTs;
 exports.pluginTsName = pluginTsName;
 exports.printerTs = printerTs;
+exports.renderType = renderType;
 exports.resolverTs = resolverTs;
 exports.typeGenerator = typeGenerator;