@kubb/ast 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 Object.defineProperty;
 //#endregion
+let node_util = require("node:util");
 //#region src/constants.ts
 const visitorDepths = {
 	shallow: "shallow",
@@ -12,7 +13,10 @@ const nodeKinds = {
 	schema: "Schema",
 	property: "Property",
 	parameter: "Parameter",
-	response: "Response"
+	response: "Response",
+	functionParameter: "FunctionParameter",
+	objectBindingParameter: "ObjectBindingParameter",
+	functionParameters: "FunctionParameters"
 };
 const schemaTypes = {
 	string: "string",
@@ -37,7 +41,8 @@ const schemaTypes = {
 	uuid: "uuid",
 	email: "email",
 	url: "url",
-	blob: "blob"
+	blob: "blob",
+	never: "never"
 };
 const httpMethods = {
 	get: "GET",
@@ -135,6 +140,288 @@ function createResponse(props) {
 		kind: "Response"
 	};
 }
+/**
+* Creates a `FunctionParameterNode`. `optional` defaults to `false`.
+*
+* @example Required typed param
+* ```ts
+* createFunctionParameter({ name: 'petId', type: 'string' })
+* // → petId: string
+* ```
+*
+* @example Optional param
+* ```ts
+* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+* // → params?: QueryParams
+* ```
+*
+* @example Param with default (implicitly optional — cannot combine with `optional: true`)
+* ```ts
+* createFunctionParameter({ name: 'config', type: 'RequestConfig', default: '{}' })
+* // → config: RequestConfig = {}
+* ```
+*/
+function createFunctionParameter(props) {
+	return {
+		optional: false,
+		...props,
+		kind: "FunctionParameter"
+	};
+}
+/**
+* Creates an `ObjectBindingParameterNode` — an object-destructured parameter group.
+*
+* @example Destructured object param
+* ```ts
+* createObjectBindingParameter({
+*   properties: [
+*     createFunctionParameter({ name: 'id', type: 'string', optional: false }),
+*     createFunctionParameter({ name: 'name', type: 'string', optional: true }),
+*   ],
+*   default: '{}',
+* })
+* // declaration → { id, name? }: { id: string; name?: string } = {}
+* // call        → { id, name }
+* ```
+*
+* @example Inline — children emitted as individual top-level params
+* ```ts
+* createObjectBindingParameter({
+*   properties: [createFunctionParameter({ name: 'petId', type: 'string', optional: false })],
+*   inline: true,
+* })
+* // declaration → petId: string
+* // call        → petId
+* ```
+*/
+function createObjectBindingParameter(props) {
+	return {
+		...props,
+		kind: "ObjectBindingParameter"
+	};
+}
+/**
+* Creates a `FunctionParametersNode` from an ordered list of params.
+*
+* @example
+* ```ts
+* createFunctionParameters({
+*   params: [
+*     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
+*     createFunctionParameter({ name: 'config', type: 'RequestConfig', optional: false, default: '{}' }),
+*   ],
+* })
+* ```
+*/
+function createFunctionParameters(props = {}) {
+	return {
+		params: [],
+		...props,
+		kind: "FunctionParameters"
+	};
+}
+//#endregion
+//#region src/printer.ts
+/**
+* Creates a named printer factory. Mirrors the `createPlugin` / `createAdapter` pattern
+* from `@kubb/core` — wraps a builder to make options optional and separates raw options
+* from resolved options.
+*
+* The builder receives resolved options and returns:
+* - `name` — a unique identifier for the printer
+* - `options` — options stored on the returned printer instance
+* - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
+* - `print` _(optional)_ — a root-level override that becomes the public `printer.print`.
+*   Inside it, `this.print(node)` still dispatches to the `nodes` map — safe recursion, no infinite loop.
+*
+* When no `print` override is provided, `printer.print` is the node-level dispatcher directly.
+*
+* @example Basic usage — Zod schema printer
+* ```ts
+* type ZodPrinter = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+*
+* export const zodPrinter = definePrinter<ZodPrinter>((options) => ({
+*   name: 'zod',
+*   options: { strict: options.strict ?? true },
+*   nodes: {
+*     string: () => 'z.string()',
+*     object(node) {
+*       const props = node.properties.map(p => `${p.name}: ${this.print(p.schema)}`).join(', ')
+*       return `z.object({ ${props} })`
+*     },
+*   },
+* }))
+* ```
+*
+* @example With a root-level `print` override to wrap output in a full declaration
+* ```ts
+* type TsPrinter = PrinterFactoryOptions<'ts', { typeName?: string }, ts.TypeNode, ts.Node>
+*
+* export const printerTs = definePrinter<TsPrinter>((options) => ({
+*   name: 'ts',
+*   options,
+*   nodes: { string: () => factory.keywordTypeNodes.string },
+*   print(node) {
+*     const type = this.print(node) // calls the node-level dispatcher
+*     if (!type || !this.options.typeName) return type
+*     return factory.createTypeAliasDeclaration(this.options.typeName, type)
+*   },
+* }))
+* ```
+*/
+function definePrinter(build) {
+	return createPrinterFactory((node) => node.type)(build);
+}
+/**
+* Generic printer factory. Extracts the core dispatch + context logic so it can be reused
+* for any node type — not just `SchemaNode`. `definePrinter` is built on top of this.
+*
+* @param getKey — derives the handler-map key from a node. Return `undefined` to skip.
+*
+* @example
+* ```ts
+* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
+*   (node) => kindToHandlerKey[node.kind],
+* )
+* ```
+*/
+function createPrinterFactory(getKey) {
+	return function(build) {
+		return (options) => {
+			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
+			const context = {
+				options: resolvedOptions,
+				print: (node) => {
+					const key = getKey(node);
+					if (key === void 0) return void 0;
+					const handler = nodes[key];
+					if (!handler) return void 0;
+					return handler.call(context, node);
+				}
+			};
+			return {
+				name,
+				options: resolvedOptions,
+				print: printOverride ? printOverride.bind(context) : context.print
+			};
+		};
+	};
+}
+//#endregion
+//#region src/functionPrinter.ts
+const kindToHandlerKey = {
+	FunctionParameter: "functionParameter",
+	ObjectBindingParameter: "objectBindingParameter",
+	FunctionParameters: "functionParameters"
+};
+/**
+* Creates a named function-signature printer factory.
+* Built on `createPrinterFactory` — dispatches on `node.kind` instead of `node.type`.
+*
+* @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.print(p)).filter(Boolean).join(', ')
+*       return `{ ${inner} }`
+*     },
+*     functionParameters(node) {
+*       return node.params.map(p => this.print(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 throughout Kubb plugins.
+*
+* @example
+* ```ts
+* const printer = functionSignaturePrinter({ 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.print(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.print(p)).filter(Boolean).join(", ");
+		}
+	}
+}));
 //#endregion
 //#region src/guards.ts
 /**
@@ -170,60 +457,18 @@ const isParameterNode = isKind("Parameter");
 * Type guard for `ResponseNode`.
 */
 const isResponseNode = isKind("Response");
-//#endregion
-//#region src/printer.ts
 /**
-* Creates a named printer factory. Mirrors the `definePlugin` / `defineAdapter` pattern
-* from `@kubb/core` — wraps a builder to make options optional and separates raw options
-* from resolved options.
-*
-* @example
-* ```ts
-* type ZodPrinter = PrinterFactoryOptions<'zod', { strict?: boolean }, { strict: boolean }, string>
-*
-* export const zodPrinter = definePrinter<ZodPrinter>((options) => {
-*   const { strict = true } = options
-*   return {
-*     name: 'zod',
-*     options: { strict },
-*     nodes: {
-*       string(node) {
-*         return `z.string()`
-*       },
-*       object(node) {
-*         const props = node.properties
-*           ?.map(p => `${p.name}: ${this.print(p)}`)
-*           .join(', ') ?? ''
-*         return `z.object({ ${props} })`
-*       },
-*     },
-*   }
-* })
-*
-* const printer = zodPrinter({ strict: false })
-* printer.name            // 'zod'
-* printer.options         // { strict: false }
-* printer.print(node)     // 'z.string()'
-* ```
+* Type guard for `FunctionParameterNode`.
 */
-function definePrinter(build) {
-	return (options) => {
-		const { name, options: resolvedOptions, nodes } = build(options ?? {});
-		const context = {
-			options: resolvedOptions,
-			print: (node) => {
-				const handler = nodes[node.type];
-				return handler ? handler.call(context, node) : void 0;
-			}
-		};
-		return {
-			name,
-			options: resolvedOptions,
-			print: context.print,
-			for: (nodes) => nodes.map(context.print)
-		};
-	};
-}
+const isFunctionParameterNode = isKind("FunctionParameter");
+/**
+* Type guard for `ObjectBindingParameterNode`.
+*/
+const isObjectBindingParameterNode = isKind("ObjectBindingParameter");
+/**
+* Type guard for `FunctionParametersNode`.
+*/
+const isFunctionParametersNode = isKind("FunctionParameters");
 //#endregion
 //#region src/refs.ts
 /**
@@ -247,7 +492,309 @@ function refMapToObject(refMap) {
 	return Object.fromEntries(refMap);
 }
 //#endregion
+//#region ../../internals/utils/dist/index.js
+/**
+* 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.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	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);
+}
+/** Returns a `CLIAdapter` with type inference. Pass a different adapter to `createCLI` to swap the CLI engine. */
+function defineCLIAdapter(adapter) {
+	return adapter;
+}
+/**
+* Serializes `CommandDefinition[]` to a plain, JSON-serializable structure.
+* Use to expose CLI capabilities to AI agents or MCP tools.
+*/
+function getCommandSchema(defs) {
+	return defs.map(serializeCommand);
+}
+function serializeCommand(def) {
+	return {
+		name: def.name,
+		description: def.description,
+		arguments: def.arguments,
+		options: serializeOptions(def.options ?? {}),
+		subCommands: def.subCommands ? def.subCommands.map(serializeCommand) : []
+	};
+}
+function serializeOptions(options) {
+	return Object.entries(options).map(([name, opt]) => {
+		return {
+			name,
+			flags: `${opt.short ? `-${opt.short}, ` : ""}--${name}${opt.type === "string" ? ` <${opt.hint ?? name}>` : ""}`,
+			type: opt.type,
+			description: opt.description,
+			...opt.default !== void 0 ? { default: opt.default } : {},
+			...opt.hint ? { hint: opt.hint } : {},
+			...opt.enum ? { enum: opt.enum } : {},
+			...opt.required ? { required: opt.required } : {}
+		};
+	});
+}
+/** Prints formatted help output for a command using its `CommandDefinition`. */
+function renderHelp(def, parentName) {
+	const schema = getCommandSchema([def])[0];
+	const programName = parentName ? `${parentName} ${schema.name}` : schema.name;
+	const argsPart = schema.arguments?.length ? ` ${schema.arguments.join(" ")}` : "";
+	const subCmdPart = schema.subCommands.length ? " <command>" : "";
+	console.log(`\n${(0, node_util.styleText)("bold", "Usage:")} ${programName}${argsPart}${subCmdPart} [options]\n`);
+	if (schema.description) console.log(`  ${schema.description}\n`);
+	if (schema.subCommands.length) {
+		console.log((0, node_util.styleText)("bold", "Commands:"));
+		for (const sub of schema.subCommands) console.log(`  ${(0, node_util.styleText)("cyan", sub.name.padEnd(16))}${sub.description}`);
+		console.log();
+	}
+	const options = [...schema.options, {
+		name: "help",
+		flags: "-h, --help",
+		type: "boolean",
+		description: "Show help"
+	}];
+	console.log((0, node_util.styleText)("bold", "Options:"));
+	for (const opt of options) {
+		const flags = (0, node_util.styleText)("cyan", opt.flags.padEnd(30));
+		const defaultPart = opt.default !== void 0 ? (0, node_util.styleText)("dim", ` (default: ${opt.default})`) : "";
+		console.log(`  ${flags}${opt.description}${defaultPart}`);
+	}
+	console.log();
+}
+function buildParseOptions(def) {
+	const result = { help: {
+		type: "boolean",
+		short: "h"
+	} };
+	for (const [name, opt] of Object.entries(def.options ?? {})) result[name] = {
+		type: opt.type,
+		...opt.short ? { short: opt.short } : {},
+		...opt.default !== void 0 ? { default: opt.default } : {}
+	};
+	return result;
+}
+async function runCommand(def, argv, parentName) {
+	const parseOptions = buildParseOptions(def);
+	let parsed;
+	try {
+		const result = (0, node_util.parseArgs)({
+			args: argv,
+			options: parseOptions,
+			allowPositionals: true,
+			strict: false
+		});
+		parsed = {
+			values: result.values,
+			positionals: result.positionals
+		};
+	} catch {
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+	if (parsed.values["help"]) {
+		renderHelp(def, parentName);
+		process.exit(0);
+	}
+	for (const [name, opt] of Object.entries(def.options ?? {})) if (opt.required && parsed.values[name] === void 0) {
+		console.error((0, node_util.styleText)("red", `Error: --${name} is required`));
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+	if (!def.run) {
+		renderHelp(def, parentName);
+		process.exit(0);
+	}
+	try {
+		await def.run(parsed);
+	} catch (err) {
+		console.error((0, node_util.styleText)("red", `Error: ${err instanceof Error ? err.message : String(err)}`));
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+}
+function printRootHelp(programName, version, defs) {
+	console.log(`\n${(0, node_util.styleText)("bold", "Usage:")} ${programName} <command> [options]\n`);
+	console.log(`  Kubb generation — v${version}\n`);
+	console.log((0, node_util.styleText)("bold", "Commands:"));
+	for (const def of defs) console.log(`  ${(0, node_util.styleText)("cyan", def.name.padEnd(16))}${def.description}`);
+	console.log();
+	console.log((0, node_util.styleText)("bold", "Options:"));
+	console.log(`  ${(0, node_util.styleText)("cyan", "-v, --version".padEnd(30))}Show version number`);
+	console.log(`  ${(0, node_util.styleText)("cyan", "-h, --help".padEnd(30))}Show help`);
+	console.log();
+	console.log(`Run ${(0, node_util.styleText)("cyan", `${programName} <command> --help`)} for command-specific help.\n`);
+}
+defineCLIAdapter({
+	renderHelp(def, parentName) {
+		renderHelp(def, parentName);
+	},
+	async run(defs, argv, opts) {
+		const { programName, defaultCommandName, version } = opts;
+		const args = argv.length >= 2 && argv[0]?.includes("node") ? argv.slice(2) : argv;
+		if (args[0] === "--version" || args[0] === "-v") {
+			console.log(version);
+			process.exit(0);
+		}
+		if (args[0] === "--help" || args[0] === "-h") {
+			printRootHelp(programName, version, defs);
+			process.exit(0);
+		}
+		if (args.length === 0) {
+			const defaultDef = defs.find((d) => d.name === defaultCommandName);
+			if (defaultDef?.run) await runCommand(defaultDef, [], programName);
+			else printRootHelp(programName, version, defs);
+			return;
+		}
+		const [first, ...rest] = args;
+		const isKnownSubcommand = defs.some((d) => d.name === first);
+		let def;
+		let commandArgv;
+		let parentName;
+		if (isKnownSubcommand) {
+			def = defs.find((d) => d.name === first);
+			commandArgv = rest;
+			parentName = programName;
+		} else {
+			def = defs.find((d) => d.name === defaultCommandName);
+			commandArgv = args;
+			parentName = programName;
+		}
+		if (!def) {
+			console.error(`Unknown command: ${first}`);
+			printRootHelp(programName, version, defs);
+			process.exit(1);
+		}
+		if (def.subCommands?.length) {
+			const [subName, ...subRest] = commandArgv;
+			const subDef = def.subCommands.find((s) => s.name === subName);
+			if (subName === "--help" || subName === "-h") {
+				renderHelp(def, parentName);
+				process.exit(0);
+			}
+			if (!subDef) {
+				renderHelp(def, parentName);
+				process.exit(subName ? 1 : 0);
+			}
+			await runCommand(subDef, subRest, `${parentName} ${def.name}`);
+			return;
+		}
+		await runCommand(def, commandArgv, parentName);
+	}
+});
+/**
+* Parses a CSS hex color string (`#RGB`) into its RGB channels.
+* Falls back to `255` for any channel that cannot be parsed.
+*/
+function parseHex(color) {
+	const int = Number.parseInt(color.replace("#", ""), 16);
+	return Number.isNaN(int) ? {
+		r: 255,
+		g: 255,
+		b: 255
+	} : {
+		r: int >> 16 & 255,
+		g: int >> 8 & 255,
+		b: int & 255
+	};
+}
+/**
+* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
+* for the given hex color.
+*/
+function hex(color) {
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*/
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/utils.ts
+const plainStringTypes = new Set([
+	"string",
+	"uuid",
+	"email",
+	"url",
+	"datetime"
+]);
+/**
+* Returns `true` when a schema node will be represented as a plain string in generated code.
+*
+* - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
+* - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
+*/
+function isPlainStringType(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
+	if (temporal) return temporal.representation !== "date";
+	return false;
+}
+/**
+* Transforms the `name` field of each parameter node according to the given casing strategy.
+*
+* The original `params` array is never mutated — a new array of cloned nodes is returned.
+* When no `casing` is provided the original array is returned as-is.
+*
+* Use this before passing parameters to schema builders so that property keys
+* in the generated output match the desired casing while the original
+* `OperationNode.parameters` array remains untouched for other consumers.
+*/
+function applyParamsCasing(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
+		};
+	});
+}
+//#endregion
 //#region src/visitor.ts
+/**
+* Creates a concurrency-limiting wrapper. At most `concurrency` promises may be
+* in-flight simultaneously; additional calls are queued and dispatched as slots free.
+*/
 function createLimit(concurrency) {
 	let active = 0;
 	const queue = [];
@@ -270,7 +817,10 @@ function createLimit(concurrency) {
 	};
 }
 /**
-* Traversable children of `node`, respecting `recurse` for schema nodes.
+* Returns the immediate traversable children of `node`.
+*
+* For `Schema` nodes, children (properties, items, members) are only included
+* when `recurse` is `true`; shallow traversal omits them entirely.
 */
 function getChildren(node, recurse) {
 	switch (node.kind) {
@@ -286,11 +836,15 @@ function getChildren(node, recurse) {
 			if ("properties" in node && node.properties.length > 0) children.push(...node.properties);
 			if ("items" in node && node.items) children.push(...node.items);
 			if ("members" in node && node.members) children.push(...node.members);
+			if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
 			return children;
 		}
 		case "Property": return [node.schema];
 		case "Parameter": return [node.schema];
 		case "Response": return node.schema ? [node.schema] : [];
+		case "FunctionParameter":
+		case "ObjectBindingParameter":
+		case "FunctionParameters": return [];
 	}
 }
 /**
@@ -300,6 +854,9 @@ function getChildren(node, recurse) {
 async function walk(node, visitor, options = {}) {
 	return _walk(node, visitor, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30));
 }
+/**
+* Internal recursive walk implementation — calls visitor then recurses into children.
+*/
 async function _walk(node, visitor, recurse, limit) {
 	switch (node.kind) {
 		case "Root":
@@ -320,6 +877,9 @@ async function _walk(node, visitor, recurse, limit) {
 		case "Response":
 			await limit(() => visitor.response?.(node));
 			break;
+		case "FunctionParameter":
+		case "ObjectBindingParameter":
+		case "FunctionParameters": break;
 	}
 	const children = getChildren(node, recurse);
 	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
@@ -356,7 +916,8 @@ function transform(node, visitor, options = {}) {
 				...schema,
 				..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, visitor, options)) } : {},
 				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, visitor, options)) } : {},
-				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, visitor, options)) } : {}
+				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, visitor, options)) } : {},
+				..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, visitor, options) } : {}
 			};
 		}
 		case "Property": {
@@ -383,9 +944,12 @@ function transform(node, visitor, options = {}) {
 			if (replaced) response = replaced;
 			return {
 				...response,
-				schema: response.schema ? transform(response.schema, visitor, options) : void 0
+				schema: transform(response.schema, visitor, options)
 			};
 		}
+		case "FunctionParameter":
+		case "ObjectBindingParameter":
+		case "FunctionParameters": return node;
 	}
 }
 /**
@@ -414,14 +978,21 @@ function collect(node, visitor, options = {}) {
 		case "Response":
 			v = visitor.response?.(node);
 			break;
+		case "FunctionParameter":
+		case "ObjectBindingParameter":
+		case "FunctionParameters": break;
 	}
 	if (v !== void 0) results.push(v);
 	for (const child of getChildren(node, recurse)) for (const item of collect(child, visitor, options)) results.push(item);
 	return results;
 }
 //#endregion
+exports.applyParamsCasing = applyParamsCasing;
 exports.buildRefMap = buildRefMap;
 exports.collect = collect;
+exports.createFunctionParameter = createFunctionParameter;
+exports.createFunctionParameters = createFunctionParameters;
+exports.createObjectBindingParameter = createObjectBindingParameter;
 exports.createOperation = createOperation;
 exports.createParameter = createParameter;
 exports.createProperty = createProperty;
@@ -429,9 +1000,14 @@ exports.createResponse = createResponse;
 exports.createRoot = createRoot;
 exports.createSchema = createSchema;
 exports.definePrinter = definePrinter;
+exports.functionPrinter = functionPrinter;
 exports.httpMethods = httpMethods;
+exports.isFunctionParameterNode = isFunctionParameterNode;
+exports.isFunctionParametersNode = isFunctionParametersNode;
+exports.isObjectBindingParameterNode = isObjectBindingParameterNode;
 exports.isOperationNode = isOperationNode;
 exports.isParameterNode = isParameterNode;
+exports.isPlainStringType = isPlainStringType;
 exports.isPropertyNode = isPropertyNode;
 exports.isResponseNode = isResponseNode;
 exports.isRootNode = isRootNode;