@kubb/ast 5.0.0-alpha.21 → 5.0.0-alpha.23

package/dist/index.js

@@ -4,17 +4,6 @@ const visitorDepths = {
 	shallow: "shallow",
 	deep: "deep"
 };
-const nodeKinds = {
-	root: "Root",
-	operation: "Operation",
-	schema: "Schema",
-	property: "Property",
-	parameter: "Parameter",
-	response: "Response",
-	functionParameter: "FunctionParameter",
-	objectBindingParameter: "ObjectBindingParameter",
-	functionParameters: "FunctionParameters"
-};
 /**
 * Canonical schema type strings used by AST schema nodes.
 *
@@ -62,6 +51,12 @@ const SCALAR_PRIMITIVE_TYPES = new Set([
 	"bigint",
 	"boolean"
 ]);
+/**
+* Returns `true` when `type` is a scalar primitive schema type.
+*/
+function isScalarPrimitive(type) {
+	return SCALAR_PRIMITIVE_TYPES.has(type);
+}
 const httpMethods = {
 	get: "GET",
 	post: "POST",
@@ -94,218 +89,14 @@ const mediaTypes = {
 	videoMp4: "video/mp4"
 };
 //#endregion
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-/**
-* Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
-*
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
-*/
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	try {
-		new Function(`var ${name}`);
-	} catch {
-		return false;
-	}
-	return true;
-}
-//#endregion
-//#region src/guards.ts
-/**
-* Narrows a `SchemaNode` to the variant that matches `type`.
-*
-* @example
-* ```ts
-* const schema = createSchema({ type: 'string' })
-* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
-* ```
-*/
-function narrowSchema(node, type) {
-	return node?.type === type ? node : void 0;
-}
-function isKind(kind) {
-	return (node) => node.kind === kind;
-}
-/**
-* Returns `true` when the input is a `RootNode`.
-*
-* @example
-* ```ts
-* if (isRootNode(node)) {
-*   console.log(node.schemas.length)
-* }
-* ```
-*/
-const isRootNode = isKind("Root");
-/**
-* Returns `true` when the input is an `OperationNode`.
-*
-* @example
-* ```ts
-* if (isOperationNode(node)) {
-*   console.log(node.operationId)
-* }
-* ```
-*/
-const isOperationNode = isKind("Operation");
-/**
-* Returns `true` when the input is a `SchemaNode`.
-*
-* @example
-* ```ts
-* if (isSchemaNode(node)) {
-*   console.log(node.type)
-* }
-* ```
-*/
-const isSchemaNode = isKind("Schema");
-/**
-* Returns `true` when the input is a `PropertyNode`.
-*/
-const isPropertyNode = isKind("Property");
-/**
-* Returns `true` when the input is a `ParameterNode`.
-*/
-const isParameterNode = isKind("Parameter");
-/**
-* Returns `true` when the input is a `ResponseNode`.
-*/
-const isResponseNode = isKind("Response");
-/**
-* Returns `true` when the input is a `FunctionParameterNode`.
-*/
-const isFunctionParameterNode = isKind("FunctionParameter");
-/**
-* Returns `true` when the input is an `ObjectBindingParameterNode`.
-*/
-const isObjectBindingParameterNode = isKind("ObjectBindingParameter");
-/**
-* Returns `true` when the input is a `FunctionParametersNode`.
-*/
-const isFunctionParametersNode = isKind("FunctionParameters");
-//#endregion
-//#region src/utils.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
-/**
-* Returns `true` when a schema is emitted as a plain TypeScript `string`.
-*
-* - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
-* - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
-*
-* @example
-* ```ts
-* isStringType(createSchema({ type: 'uuid' })) // true
-* isStringType(createSchema({ type: 'date', representation: 'date' })) // false
-* ```
-*/
-function isStringType(node) {
-	if (plainStringTypes.has(node.type)) return true;
-	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
-	if (temporal) return temporal.representation !== "date";
-	return false;
-}
-/**
-* Applies casing rules to parameter names and returns a new parameter array.
-*
-* The input array is not mutated.
-* If `casing` is not set, the original array is returned unchanged.
-*
-* Use this before passing parameters to schema builders so that property keys
-* in generated output match the desired casing while preserving
-* `OperationNode.parameters` for other consumers.
-*
-* @example
-* ```ts
-* const params = [createParameter({ name: 'pet_id', in: 'query', schema: createSchema({ type: 'string' }) })]
-* const cased = caseParams(params, 'camelcase')
-* // cased[0].name === 'petId'
-* ```
-*/
-function caseParams(params, casing) {
-	if (!casing) return params;
-	return params.map((param) => {
-		const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
-		return {
-			...param,
-			name: transformed
-		};
-	});
-}
+//#region src/factory.ts
 /**
 * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
 *
 * - `optional` is set for non-required, non-nullable schemas.
 * - `nullish` is set for non-required, nullable schemas.
 */
-function syncOptionality(required, schema) {
+function syncOptionality(schema, required) {
 	const nullable = schema.nullable ?? false;
 	return {
 		...schema,
@@ -313,8 +104,6 @@ function syncOptionality(required, schema) {
 		nullish: !required && nullable ? true : void 0
 	};
 }
-//#endregion
-//#region src/factory.ts
 /**
 * Creates a `RootNode` with stable defaults for `schemas` and `operations`.
 *
@@ -412,7 +201,7 @@ function createProperty(props) {
 		...props,
 		kind: "Property",
 		required,
-		schema: syncOptionality(required, props.schema)
+		schema: syncOptionality(props.schema, required)
 	};
 }
 /**
@@ -447,7 +236,7 @@ function createParameter(props) {
 		...props,
 		kind: "Parameter",
 		required,
-		schema: syncOptionality(required, props.schema)
+		schema: syncOptionality(props.schema, required)
 	};
 }
 /**
@@ -469,49 +258,25 @@ function createResponse(props) {
 	};
 }
 /**
-* Creates a single-property object schema used as a discriminator literal.
-*
-* @example
-* ```ts
-* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
-* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
-* ```
-*/
-function createDiscriminantNode({ propertyName, value }) {
-	return createSchema({
-		type: "object",
-		primitive: "object",
-		properties: [createProperty({
-			name: propertyName,
-			schema: createSchema({
-				type: "enum",
-				primitive: "string",
-				enumValues: [value]
-			}),
-			required: true
-		})]
-	});
-}
-/**
 * Creates a `FunctionParameterNode`.
 *
 * `optional` defaults to `false`.
 *
 * @example Required typed param
 * ```ts
-* createFunctionParameter({ name: 'petId', type: 'string' })
+* createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }) })
 * // → petId: string
 * ```
 *
 * @example Optional param
 * ```ts
-* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+* createFunctionParameter({ name: 'params', type: createTypeNode({ variant: 'reference', name: 'QueryParams' }), optional: true })
 * // → params?: QueryParams
 * ```
 *
 * @example Param with default (implicitly optional; cannot combine with `optional: true`)
 * ```ts
-* createFunctionParameter({ name: 'config', type: 'RequestConfig', default: '{}' })
+* createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
 * // → config: RequestConfig = {}
 * ```
 */
@@ -523,14 +288,42 @@ function createFunctionParameter(props) {
 	};
 }
 /**
-* Creates an `ObjectBindingParameterNode` for object-destructured parameter groups.
+* Creates a {@link TypeNode} representing a language-agnostic structured type expression.
+*
+* Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
+* named field accessed from a group type. Each language's printer renders the variant
+* into its own syntax (TypeScript, Python, C#, Kotlin, …).
+*
+* @example Reference type (TypeScript: `QueryParams`)
+* ```ts
+* createTypeNode({ variant: 'reference', name: 'QueryParams' })
+* ```
+*
+* @example Struct type (TypeScript: `{ petId: string }`)
+* ```ts
+* createTypeNode({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createTypeNode({ variant: 'reference', name: 'string' }) }] })
+* ```
+*
+* @example Member type (TypeScript: `DeletePetPathParams['petId']`)
+* ```ts
+* createTypeNode({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
+* ```
+*/
+function createTypeNode(props) {
+	return {
+		...props,
+		kind: "Type"
+	};
+}
+/**
+* Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
 *
-* @example Destructured object param
+* @example Grouped param (TypeScript declaration)
 * ```ts
-* createObjectBindingParameter({
+* createParameterGroup({
 *   properties: [
-*     createFunctionParameter({ name: 'id', type: 'string', optional: false }),
-*     createFunctionParameter({ name: 'name', type: 'string', optional: true }),
+*     createFunctionParameter({ name: 'id', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
+*     createFunctionParameter({ name: 'name', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: true }),
 *   ],
 *   default: '{}',
 * })
@@ -538,20 +331,20 @@ function createFunctionParameter(props) {
 * // call        → { id, name }
 * ```
 *
-* @example Inline mode — children emitted as individual top-level parameters
+* @example Inline (spread) — children emitted as individual top-level parameters
 * ```ts
-* createObjectBindingParameter({
-*   properties: [createFunctionParameter({ name: 'petId', type: 'string', optional: false })],
+* createParameterGroup({
+*   properties: [createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false })],
 *   inline: true,
 * })
 * // declaration → petId: string
 * // call        → petId
 * ```
 */
-function createObjectBindingParameter(props) {
+function createParameterGroup(props) {
 	return {
 		...props,
-		kind: "ObjectBindingParameter"
+		kind: "ParameterGroup"
 	};
 }
 /**
@@ -561,8 +354,8 @@ function createObjectBindingParameter(props) {
 * ```ts
 * createFunctionParameters({
 *   params: [
-*     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
-*     createFunctionParameter({ name: 'config', type: 'RequestConfig', optional: false, default: '{}' }),
+*     createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
+*     createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
 *   ],
 * })
 * ```
@@ -581,7 +374,53 @@ function createFunctionParameters(props = {}) {
 	};
 }
 //#endregion
-//#region src/printers/printer.ts
+//#region src/guards.ts
+/**
+* Narrows a `SchemaNode` to the variant that matches `type`.
+*
+* @example
+* ```ts
+* const schema = createSchema({ type: 'string' })
+* const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+* ```
+*/
+function narrowSchema(node, type) {
+	return node?.type === type ? node : void 0;
+}
+function isKind(kind) {
+	return (node) => node.kind === kind;
+}
+isKind("Root");
+/**
+* Returns `true` when the input is an `OperationNode`.
+*
+* @example
+* ```ts
+* if (isOperationNode(node)) {
+*   console.log(node.operationId)
+* }
+* ```
+*/
+const isOperationNode = isKind("Operation");
+/**
+* Returns `true` when the input is a `SchemaNode`.
+*
+* @example
+* ```ts
+* if (isSchemaNode(node)) {
+*   console.log(node.type)
+* }
+* ```
+*/
+const isSchemaNode = isKind("Schema");
+isKind("Property");
+isKind("Parameter");
+isKind("Response");
+isKind("FunctionParameter");
+isKind("ParameterGroup");
+isKind("FunctionParameters");
+//#endregion
+//#region src/printer.ts
 /**
 * Creates a schema printer factory.
 *
@@ -651,123 +490,6 @@ function createPrinterFactory(getKey) {
 	};
 }
 //#endregion
-//#region src/printers/functionPrinter.ts
-const kindToHandlerKey = {
-	FunctionParameter: "functionParameter",
-	ObjectBindingParameter: "objectBindingParameter",
-	FunctionParameters: "functionParameters"
-};
-/**
-* Creates a function-parameter printer factory.
-*
-* This wrapper uses `createPrinterFactory` and dispatches handlers by `node.kind`
-* (for function nodes) rather than by `node.type` (for schema nodes).
-*
-* @example
-* ```ts
-* type MyPrinter = PrinterFactoryOptions<'my', { mode: 'declaration' | 'call' }, string>
-*
-* export const myPrinter = defineFunctionPrinter<MyPrinter>((options) => ({
-*   name: 'my',
-*   options,
-*   nodes: {
-*     functionParameter(node) {
-*       return options.mode === 'declaration' && node.type ? `${node.name}: ${node.type}` : node.name
-*     },
-*     objectBindingParameter(node) {
-*       const inner = node.properties.map(p => this.transform(p)).filter(Boolean).join(', ')
-*       return `{ ${inner} }`
-*     },
-*     functionParameters(node) {
-*       return node.params.map(p => this.transform(p)).filter(Boolean).join(', ')
-*     },
-*   },
-* }))
-* ```
-*/
-const defineFunctionPrinter = createPrinterFactory((node) => kindToHandlerKey[node.kind]);
-function rank(param) {
-	if (param.kind === "ObjectBindingParameter") {
-		if (param.default) return 2;
-		return param.optional ?? param.properties.every((p) => p.optional || p.default !== void 0) ? 1 : 0;
-	}
-	if (param.rest) return 3;
-	if (param.default) return 2;
-	return param.optional ? 1 : 0;
-}
-function sortParams(params) {
-	return [...params].sort((a, b) => rank(a) - rank(b));
-}
-function sortChildParams(params) {
-	return [...params].sort((a, b) => rank(a) - rank(b));
-}
-/**
-* Default function-signature printer.
-* Covers the four standard output modes used across Kubb plugins.
-*
-* @example
-* ```ts
-* const printer = functionPrinter({ mode: 'declaration' })
-*
-* const sig = createFunctionParameters({
-*   params: [
-*     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
-*     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),
-*   ],
-* })
-*
-* printer.print(sig)  // → "petId: string, config: Config = {}"
-* ```
-*/
-const functionPrinter = defineFunctionPrinter((options) => ({
-	name: "functionParameters",
-	options,
-	nodes: {
-		functionParameter(node) {
-			const { mode, transformName, transformType } = this.options;
-			const name = transformName ? transformName(node.name) : node.name;
-			const type = node.type && transformType ? transformType(node.type) : node.type;
-			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;
-		},
-		objectBindingParameter(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;
-			if (!typeAnnotation) {
-				const typeParts = sorted.filter((p) => p.type).map((p) => {
-					const t = transformType && p.type ? transformType(p.type) : p.type;
-					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(", ");
-		}
-	}
-}));
-//#endregion
 //#region src/refs.ts
 /**
 * Returns the last path segment of a reference string.
@@ -782,43 +504,83 @@ const functionPrinter = defineFunctionPrinter((options) => ({
 function extractRefName(ref) {
 	return ref.split("/").at(-1) ?? ref;
 }
+//#endregion
+//#region ../../internals/utils/src/casing.ts
 /**
-* Builds a `RefMap` from `root.schemas` using each schema's `name`.
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
 *
-* Unnamed schemas are skipped.
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
 *
 * @example
-* ```ts
-* const refMap = buildRefMap(root)
-* const pet = refMap.get('Pet')
-* ```
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
 */
-function buildRefMap(root) {
-	const map = /* @__PURE__ */ new Map();
-	for (const schema of root.schemas) if (schema.name) map.set(schema.name, schema);
-	return map;
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
-* Resolves a schema by name from a `RefMap`.
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
 *
 * @example
-* ```ts
-* const petSchema = resolveRef(refMap, 'Pet')
-* ```
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
 */
-function resolveRef(refMap, ref) {
-	return refMap.get(ref);
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
 /**
-* Converts a `RefMap` into a plain object.
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
 *
 * @example
 * ```ts
-* const refsObject = refMapToObject(refMap)
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
 * ```
 */
-function refMapToObject(refMap) {
-	return Object.fromEntries(refMap);
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
 }
 //#endregion
 //#region src/visitor.ts
@@ -893,8 +655,9 @@ function getChildren(node, recurse) {
 		case "Parameter": return [node.schema];
 		case "Response": return node.schema ? [node.schema] : [];
 		case "FunctionParameter":
-		case "ObjectBindingParameter":
-		case "FunctionParameters": return [];
+		case "ParameterGroup":
+		case "FunctionParameters":
+		case "Type": return [];
 	}
 }
 /**
@@ -941,7 +704,7 @@ async function _walk(node, visitor, recurse, limit, parent) {
 			await limit(() => visitor.response?.(node, { parent }));
 			break;
 		case "FunctionParameter":
-		case "ObjectBindingParameter":
+		case "ParameterGroup":
 		case "FunctionParameters": break;
 	}
 	const children = getChildren(node, recurse);
@@ -1043,8 +806,9 @@ function transform(node, options) {
 			};
 		}
 		case "FunctionParameter":
-		case "ObjectBindingParameter":
-		case "FunctionParameters": return node;
+		case "ParameterGroup":
+		case "FunctionParameters":
+		case "Type": return node;
 	}
 }
 /**
@@ -1128,7 +892,7 @@ function collect(node, options) {
 			v = visitor.response?.(node, { parent });
 			break;
 		case "FunctionParameter":
-		case "ObjectBindingParameter":
+		case "ParameterGroup":
 		case "FunctionParameters": break;
 	}
 	if (v !== void 0) results.push(v);
@@ -1248,7 +1012,7 @@ function mergeAdjacentObjects(members) {
 * ```
 */
 function simplifyUnion(members) {
-	const scalarPrimitives = new Set(members.filter((member) => SCALAR_PRIMITIVE_TYPES.has(member.type)).map((m) => m.type));
+	const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type));
 	if (!scalarPrimitives.size) return members;
 	return members.filter((member) => {
 		const enumNode = narrowSchema(member, "enum");
@@ -1273,31 +1037,308 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 	};
 	return propNode;
 }
+//#endregion
+//#region src/utils.ts
+const plainStringTypes = new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
 /**
-* Walks a schema tree and resolves `ref`/`enum` names through callbacks.
+* Returns `true` when a schema is emitted as a plain `string` type.
+*
+* - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
+* - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
+*
+* @example
+* ```ts
+* isStringType(createSchema({ type: 'uuid' }))                          // true
+* isStringType(createSchema({ type: 'date', representation: 'date' }))  // false
+* ```
 */
-function resolveNames({ node, nameMapping, resolveName, resolveEnumName }) {
-	return transform(node, { schema(schemaNode) {
-		const schemaRef = narrowSchema(schemaNode, "ref");
-		if (schemaRef && (schemaRef.ref || schemaRef.name)) {
-			const rawRef = schemaRef.ref ?? schemaRef.name;
-			const resolved = resolveName(nameMapping.get(rawRef) ?? rawRef);
-			if (resolved) return {
-				...schemaNode,
-				name: resolved
-			};
-		}
-		const schemaEnum = narrowSchema(schemaNode, "enum");
-		if (schemaEnum?.name) {
-			const resolved = (resolveEnumName ?? resolveName)(schemaEnum.name);
-			if (resolved) return {
-				...schemaNode,
-				name: resolved
-			};
+function isStringType(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
+	if (temporal) return temporal.representation !== "date";
+	return false;
+}
+/**
+* Applies casing rules to parameter names and returns a new parameter array.
+*
+* The input array is not mutated.
+* If `casing` is not set, the original array is returned unchanged.
+*
+* Use this before passing parameters to schema builders so that property keys
+* in generated output match the desired casing while preserving
+* `OperationNode.parameters` for other consumers.
+*
+* @example
+* ```ts
+* const params = [createParameter({ name: 'pet_id', in: 'query', schema: createSchema({ type: 'string' }) })]
+* const cased = caseParams(params, 'camelcase')
+* // cased[0].name === 'petId'
+* ```
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	return params.map((param) => {
+		const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
+		return {
+			...param,
+			name: transformed
+		};
+	});
+}
+/**
+* Creates a single-property object schema used as a discriminator literal.
+*
+* @example
+* ```ts
+* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+* ```
+*/
+function createDiscriminantNode({ propertyName, value }) {
+	return createSchema({
+		type: "object",
+		primitive: "object",
+		properties: [createProperty({
+			name: propertyName,
+			schema: createSchema({
+				type: "enum",
+				primitive: "string",
+				enumValues: [value]
+			}),
+			required: true
+		})]
+	});
+}
+function resolveType({ node, param, resolver }) {
+	if (!resolver) return createTypeNode({
+		variant: "reference",
+		name: 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 createTypeNode({
+		variant: "member",
+		base: groupName,
+		key: param.name
+	});
+	return createTypeNode({
+		variant: "reference",
+		name: individualName
+	});
+}
+/**
+* Converts an {@link OperationNode} into a {@link FunctionParametersNode}.
+*
+* Centralizes the per-plugin `getParams()` pattern. Provide a `resolver` for
+* type resolution and `extraParams` for plugin-specific trailing parameters.
+*
+* @example
+* ```ts
+* const params = createOperationParams(node, {
+*   paramsType: 'inline',
+*   pathParamsType: 'inline',
+*   resolver: tsResolver,
+*   extraParams: [createFunctionParameter({ name: 'options', type: createTypeNode({ variant: 'reference', name: 'Partial<RequestOptions>' }), default: '{}' })],
+* })
+* ```
+*/
+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) => createTypeNode({
+		variant: "reference",
+		name: typeWrapper ? typeWrapper(type) : type
+	});
+	const wrapTypeNode = (type) => type.variant === "reference" ? wrapType(type.name) : 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 bodyType = node.requestBody?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
+	const bodyRequired = node.requestBody?.required ?? false;
+	const queryGroupType = resolver ? resolveGroupType({
+		node,
+		params: queryParams,
+		groupMethod: resolver.resolveQueryParamsName,
+		resolver
+	}) : void 0;
+	const headerGroupType = resolver ? resolveGroupType({
+		node,
+		params: headerParams,
+		groupMethod: resolver.resolveHeaderParamsName,
+		resolver
+	}) : void 0;
+	const params = [];
+	if (paramsType === "object") {
+		const children = [
+			...pathParams.map((p) => {
+				const type = resolveType({
+					node,
+					param: p,
+					resolver
+				});
+				return createFunctionParameter({
+					name: p.name,
+					type: wrapTypeNode(type),
+					optional: !p.required
+				});
+			}),
+			...bodyType ? [createFunctionParameter({
+				name: dataName,
+				type: bodyType,
+				optional: !bodyRequired
+			})] : [],
+			...buildGroupParam({
+				name: paramsName,
+				node,
+				params: queryParams,
+				groupType: queryGroupType,
+				resolver,
+				wrapType
+			}),
+			...buildGroupParam({
+				name: headersName,
+				node,
+				params: headerParams,
+				groupType: headerGroupType,
+				resolver,
+				wrapType
+			})
+		];
+		if (children.length) params.push(createParameterGroup({
+			properties: children,
+			default: children.every((c) => c.optional) ? "{}" : void 0
+		}));
+	} else {
+		if (pathParams.length) if (pathParamsType === "inlineSpread") {
+			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]) ?? void 0;
+			params.push(createFunctionParameter({
+				name: pathName,
+				type: spreadType ? wrapType(spreadType) : void 0,
+				rest: true
+			}));
+		} else {
+			const pathChildren = pathParams.map((p) => {
+				const type = resolveType({
+					node,
+					param: p,
+					resolver
+				});
+				return createFunctionParameter({
+					name: p.name,
+					type: wrapTypeNode(type),
+					optional: !p.required
+				});
+			});
+			params.push(createParameterGroup({
+				properties: pathChildren,
+				inline: pathParamsType === "inline",
+				default: pathParamsDefault ?? (pathChildren.every((c) => c.optional) ? "{}" : void 0)
+			}));
 		}
-	} });
+		if (bodyType) params.push(createFunctionParameter({
+			name: dataName,
+			type: bodyType,
+			optional: !bodyRequired
+		}));
+		params.push(...buildGroupParam({
+			name: paramsName,
+			node,
+			params: queryParams,
+			groupType: queryGroupType,
+			resolver,
+			wrapType
+		}));
+		params.push(...buildGroupParam({
+			name: headersName,
+			node,
+			params: headerParams,
+			groupType: headerGroupType,
+			resolver,
+			wrapType
+		}));
+	}
+	params.push(...extraParams);
+	return createFunctionParameters({ params });
+}
+/**
+* Builds a single {@link FunctionParameterNode} for a query or header group.
+* Returns an empty array when there are no params to emit.
+*
+* If a pre-resolved `groupType` is provided it emits `name: GroupType`.
+* Otherwise, it builds an inline struct from the individual params.
+*/
+function buildGroupParam({ name, node, params, groupType, resolver, wrapType }) {
+	if (groupType) return [createFunctionParameter({
+		name,
+		type: groupType.type.variant === "reference" ? wrapType(groupType.type.name) : groupType.type,
+		optional: groupType.optional
+	})];
+	if (params.length) return [createFunctionParameter({
+		name,
+		type: toStructType({
+			node,
+			params,
+			resolver
+		}),
+		optional: params.every((p) => !p.required)
+	})];
+	return [];
+}
+/**
+* Derives a {@link ParamGroupType} from the resolver's group method.
+* Returns `undefined` when the group name equals the individual param name (no real group).
+*/
+function resolveGroupType({ node, params, groupMethod, resolver }) {
+	if (!params.length) return;
+	const firstParam = params[0];
+	const groupName = groupMethod.call(resolver, node, firstParam);
+	if (groupName === resolver.resolveParamName(node, firstParam)) return;
+	const allOptional = params.every((p) => !p.required);
+	return {
+		type: createTypeNode({
+			variant: "reference",
+			name: groupName
+		}),
+		optional: allOptional
+	};
+}
+/**
+* Builds a {@link TypeNode} with `variant: 'struct'` for an inline anonymous type grouping named fields.
+*
+* Used when query or header parameters have no dedicated group type name.
+* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
+*/
+function toStructType({ node, params, resolver }) {
+	return createTypeNode({
+		variant: "struct",
+		properties: params.map((p) => ({
+			name: p.name,
+			optional: !p.required,
+			type: resolveType({
+				node,
+				param: p,
+				resolver
+			})
+		}))
+	});
 }
 //#endregion
-export { SCALAR_PRIMITIVE_TYPES, buildRefMap, caseParams, childName, collect, collectImports, composeTransformers, createDiscriminantNode, createFunctionParameter, createFunctionParameters, createObjectBindingParameter, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, defineFunctionPrinter, definePrinter, enumPropName, extractRefName, findDiscriminator, functionPrinter, httpMethods, isFunctionParameterNode, isFunctionParametersNode, isObjectBindingParameterNode, isOperationNode, isParameterNode, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, refMapToObject, resolveNames, resolveRef, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, transform, walk };
+export { caseParams, childName, collect, collectImports, composeTransformers, createDiscriminantNode, createFunctionParameter, createFunctionParameters, createOperation, createOperationParams, createParameter, createParameterGroup, createPrinterFactory, createProperty, createResponse, createRoot, createSchema, createTypeNode, definePrinter, enumPropName, extractRefName, findDiscriminator, httpMethods, isOperationNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, transform, walk };
 
 //# sourceMappingURL=index.js.map