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

package/dist/index.js

@@ -10,8 +10,22 @@ const nodeKinds = {
 	schema: "Schema",
 	property: "Property",
 	parameter: "Parameter",
-	response: "Response"
+	response: "Response",
+	functionParameter: "FunctionParameter",
+	objectBindingParameter: "ObjectBindingParameter",
+	functionParameters: "FunctionParameters"
 };
+/**
+* Canonical schema type strings used by AST schema nodes.
+*
+* These values are used across the AST as stable discriminators
+* (for example `schema.type === schemaTypes.object`).
+*
+* The map is grouped by intent:
+* - primitives (`string`, `number`, `boolean`, ...)
+* - structural/composite (`object`, `array`, `union`, ...)
+* - special OpenAPI-oriented types (`ref`, `datetime`, `uuid`, ...)
+*/
 const schemaTypes = {
 	string: "string",
 	number: "number",
@@ -35,8 +49,19 @@ const schemaTypes = {
 	uuid: "uuid",
 	email: "email",
 	url: "url",
-	blob: "blob"
+	blob: "blob",
+	never: "never"
 };
+/**
+* Primitive scalar schema types used when simplifying union members.
+*/
+const SCALAR_PRIMITIVE_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
 const httpMethods = {
 	get: "GET",
 	post: "POST",
@@ -69,9 +94,241 @@ 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
+		};
+	});
+}
+/**
+* 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) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+//#endregion
 //#region src/factory.ts
 /**
-* Creates a `RootNode`.
+* Creates a `RootNode` with stable defaults for `schemas` and `operations`.
+*
+* @example
+* ```ts
+* const root = createRoot()
+* // { kind: 'Root', schemas: [], operations: [] }
+* ```
+*
+* @example
+* ```ts
+* const root = createRoot({ schemas: [petSchema] })
+* // keeps default operations: []
+* ```
 */
 function createRoot(overrides = {}) {
 	return {
@@ -82,7 +339,27 @@ function createRoot(overrides = {}) {
 	};
 }
 /**
-* Creates an `OperationNode`.
+* Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+*
+* @example
+* ```ts
+* const operation = createOperation({
+*   operationId: 'getPetById',
+*   method: 'GET',
+*   path: '/pet/{petId}',
+* })
+* // tags, parameters, and responses are []
+* ```
+*
+* @example
+* ```ts
+* const operation = createOperation({
+*   operationId: 'findPets',
+*   method: 'GET',
+*   path: '/pet/findByStatus',
+*   tags: ['pet'],
+* })
+* ```
 */
 function createOperation(props) {
 	return {
@@ -105,27 +382,85 @@ function createSchema(props) {
 	};
 }
 /**
-* Creates a `PropertyNode`. `required` defaults to `false`.
+* Creates a `PropertyNode`.
+*
+* `required` defaults to `false`.
+* `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
+*
+* @example
+* ```ts
+* const property = createProperty({
+*   name: 'status',
+*   schema: createSchema({ type: 'string' }),
+* })
+* // required=false, schema.optional=true
+* ```
+*
+* @example
+* ```ts
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
+* ```
 */
 function createProperty(props) {
+	const required = props.required ?? false;
 	return {
-		required: false,
 		...props,
-		kind: "Property"
+		kind: "Property",
+		required,
+		schema: syncOptionality(required, props.schema)
 	};
 }
 /**
-* Creates a `ParameterNode`. `required` defaults to `false`.
+* Creates a `ParameterNode`.
+*
+* `required` defaults to `false`.
+* Nested schema flags are set from `required` and `schema.nullable`.
+*
+* @example
+* ```ts
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
+* ```
+*
+* @example
+* ```ts
+* const param = createParameter({
+*   name: 'status',
+*   in: 'query',
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=false, schema.nullish=true
+* ```
 */
 function createParameter(props) {
+	const required = props.required ?? false;
 	return {
-		required: false,
 		...props,
-		kind: "Parameter"
+		kind: "Parameter",
+		required,
+		schema: syncOptionality(required, props.schema)
 	};
 }
 /**
 * Creates a `ResponseNode`.
+*
+* @example
+* ```ts
+* const response = createResponse({
+*   statusCode: '200',
+*   description: 'Success',
+*   schema: createSchema({ type: 'object', properties: [] }),
+* })
+* ```
 */
 function createResponse(props) {
 	return {
@@ -133,99 +468,330 @@ function createResponse(props) {
 		kind: "Response"
 	};
 }
-//#endregion
-//#region src/guards.ts
 /**
-* Narrows a `SchemaNode` to the specific variant matching `type`.
+* 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 narrowSchema(node, type) {
-	return node?.type === type ? node : void 0;
-}
-function isKind(kind) {
-	return (node) => node.kind === kind;
+function createDiscriminantNode({ propertyName, value }) {
+	return createSchema({
+		type: "object",
+		primitive: "object",
+		properties: [createProperty({
+			name: propertyName,
+			schema: createSchema({
+				type: "enum",
+				primitive: "string",
+				enumValues: [value]
+			}),
+			required: true
+		})]
+	});
 }
 /**
-* Type guard for `RootNode`.
-*/
-const isRootNode = isKind("Root");
-/**
-* Type guard for `OperationNode`.
+* 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 = {}
+* ```
 */
-const isOperationNode = isKind("Operation");
+function createFunctionParameter(props) {
+	return {
+		optional: false,
+		...props,
+		kind: "FunctionParameter"
+	};
+}
 /**
-* Type guard for `SchemaNode`.
+* Creates an `ObjectBindingParameterNode` for object-destructured parameter groups.
+*
+* @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 mode — children emitted as individual top-level parameters
+* ```ts
+* createObjectBindingParameter({
+*   properties: [createFunctionParameter({ name: 'petId', type: 'string', optional: false })],
+*   inline: true,
+* })
+* // declaration → petId: string
+* // call        → petId
+* ```
 */
-const isSchemaNode = isKind("Schema");
+function createObjectBindingParameter(props) {
+	return {
+		...props,
+		kind: "ObjectBindingParameter"
+	};
+}
 /**
-* Type guard for `PropertyNode`.
+* Creates a `FunctionParametersNode` from an ordered list of parameters.
+*
+* @example
+* ```ts
+* createFunctionParameters({
+*   params: [
+*     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
+*     createFunctionParameter({ name: 'config', type: 'RequestConfig', optional: false, default: '{}' }),
+*   ],
+* })
+* ```
+*
+* @example
+* ```ts
+* const empty = createFunctionParameters()
+* // { kind: 'FunctionParameters', params: [] }
+* ```
 */
-const isPropertyNode = isKind("Property");
+function createFunctionParameters(props = {}) {
+	return {
+		params: [],
+		...props,
+		kind: "FunctionParameters"
+	};
+}
+//#endregion
+//#region src/printers/printer.ts
 /**
-* Type guard for `ParameterNode`.
+* Creates a schema printer factory.
+*
+* This function wraps a builder and makes options optional at call sites.
+*
+* 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)_ — top-level override exposed as `printer.print`
+*   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
+*   - This keeps recursion safe and avoids self-calls
+*
+* When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+*
+* @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.transform(p.schema)}`).join(', ')
+*       return `z.object({ ${props} })`
+*     },
+*   },
+* }))
+* ```
 */
-const isParameterNode = isKind("Parameter");
+function definePrinter(build) {
+	return createPrinterFactory((node) => node.type)(build);
+}
 /**
-* Type guard for `ResponseNode`.
+* Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
+**
+* @example
+* ```ts
+* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
+*   (node) => kindToHandlerKey[node.kind],
+* )
+* ```
 */
-const isResponseNode = isKind("Response");
+function createPrinterFactory(getKey) {
+	return function(build) {
+		return (options) => {
+			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
+			const context = {
+				options: resolvedOptions,
+				transform: (node) => {
+					const key = getKey(node);
+					if (key === void 0) return null;
+					const handler = nodes[key];
+					if (!handler) return null;
+					return handler.call(context, node);
+				}
+			};
+			return {
+				name,
+				options: resolvedOptions,
+				transform: context.transform,
+				print: printOverride ? printOverride.bind(context) : context.transform
+			};
+		};
+	};
+}
 //#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} })`
-*       },
+//#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: '{}' }),
+*   ],
 * })
 *
-* const printer = zodPrinter({ strict: false })
-* printer.name            // 'zod'
-* printer.options         // { strict: false }
-* printer.print(node)     // 'z.string()'
+* printer.print(sig)  // → "petId: string, config: Config = {}"
 * ```
 */
-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;
+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 {
-			name,
-			options: resolvedOptions,
-			print: context.print,
-			for: (nodes) => nodes.map(context.print)
-		};
-	};
-}
+			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
 /**
-* Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.
+* Returns the last path segment of a reference string.
+*
+* Example: `#/components/schemas/Pet` becomes `Pet`.
+*
+* @example
+* ```ts
+* extractRefName('#/components/schemas/Pet') // 'Pet'
+* ```
+*/
+function extractRefName(ref) {
+	return ref.split("/").at(-1) ?? ref;
+}
+/**
+* Builds a `RefMap` from `root.schemas` using each schema's `name`.
+*
+* Unnamed schemas are skipped.
+*
+* @example
+* ```ts
+* const refMap = buildRefMap(root)
+* const pet = refMap.get('Pet')
+* ```
 */
 function buildRefMap(root) {
 	const map = /* @__PURE__ */ new Map();
@@ -233,19 +799,45 @@ function buildRefMap(root) {
 	return map;
 }
 /**
-* Looks up a schema by name. Prefer over `RefMap.get()` to keep the resolution strategy swappable.
+* Resolves a schema by name from a `RefMap`.
+*
+* @example
+* ```ts
+* const petSchema = resolveRef(refMap, 'Pet')
+* ```
 */
 function resolveRef(refMap, ref) {
 	return refMap.get(ref);
 }
 /**
-* Converts a `RefMap` to a plain object.
+* Converts a `RefMap` into a plain object.
+*
+* @example
+* ```ts
+* const refsObject = refMapToObject(refMap)
+* ```
 */
 function refMapToObject(refMap) {
 	return Object.fromEntries(refMap);
 }
 //#endregion
 //#region src/visitor.ts
+/**
+* Creates a small async concurrency limiter.
+*
+* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
+*
+* @example
+* ```ts
+* const limit = createLimit(2)
+* await Promise.all([
+*   limit(() => taskA()),
+*   limit(() => taskB()),
+*   limit(() => taskC()),
+* ])
+* // only 2 tasks run at the same time
+* ```
+*/
 function createLimit(concurrency) {
 	let active = 0;
 	const queue = [];
@@ -268,14 +860,24 @@ 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`, and non-boolean
+* `additionalProperties`) are only included
+* when `recurse` is `true`; shallow mode skips them.
+*
+* @example
+* ```ts
+* const children = getChildren(operationNode, true)
+* // returns parameters, requestBody schema (if present), and responses
+* ```
 */
 function getChildren(node, recurse) {
 	switch (node.kind) {
 		case "Root": return [...node.schemas, ...node.operations];
 		case "Operation": return [
 			...node.parameters,
-			...node.requestBody ? [node.requestBody] : [],
+			...node.requestBody?.schema ? [node.requestBody.schema] : [],
 			...node.responses
 		];
 		case "Schema": {
@@ -284,140 +886,418 @@ 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 [];
 	}
 }
 /**
 * Depth-first traversal for side effects. Visitor return values are ignored.
-* Sibling nodes at each level are visited concurrently up to `options.concurrency` (default: 30).
+* Sibling nodes at each level are visited concurrently up to `options.concurrency`
+* (default: `WALK_CONCURRENCY`).
+*
+* @example
+* ```ts
+* await walk(root, {
+*   operation(node) {
+*     console.log(node.operationId)
+*   },
+* })
+* ```
+*
+* @example
+* ```ts
+* // Visit only the current node
+* await walk(root, { depth: 'shallow', root: () => {} })
+* ```
 */
-async function walk(node, visitor, options = {}) {
-	return _walk(node, visitor, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30));
+async function walk(node, options) {
+	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
 }
-async function _walk(node, visitor, recurse, limit) {
+async function _walk(node, visitor, recurse, limit, parent) {
 	switch (node.kind) {
 		case "Root":
-			await limit(() => visitor.root?.(node));
+			await limit(() => visitor.root?.(node, { parent }));
 			break;
 		case "Operation":
-			await limit(() => visitor.operation?.(node));
+			await limit(() => visitor.operation?.(node, { parent }));
 			break;
 		case "Schema":
-			await limit(() => visitor.schema?.(node));
+			await limit(() => visitor.schema?.(node, { parent }));
 			break;
 		case "Property":
-			await limit(() => visitor.property?.(node));
+			await limit(() => visitor.property?.(node, { parent }));
 			break;
 		case "Parameter":
-			await limit(() => visitor.parameter?.(node));
+			await limit(() => visitor.parameter?.(node, { parent }));
 			break;
 		case "Response":
-			await limit(() => visitor.response?.(node));
+			await limit(() => visitor.response?.(node, { parent }));
 			break;
+		case "FunctionParameter":
+		case "ObjectBindingParameter":
+		case "FunctionParameters": break;
 	}
 	const children = getChildren(node, recurse);
-	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
+	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
 }
-function transform(node, visitor, options = {}) {
-	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+function transform(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
 	switch (node.kind) {
 		case "Root": {
 			let root = node;
-			const replaced = visitor.root?.(root);
+			const replaced = visitor.root?.(root, { parent });
 			if (replaced) root = replaced;
 			return {
 				...root,
-				schemas: root.schemas.map((s) => transform(s, visitor, options)),
-				operations: root.operations.map((op) => transform(op, visitor, options))
+				schemas: root.schemas.map((s) => transform(s, {
+					...options,
+					parent: root
+				})),
+				operations: root.operations.map((op) => transform(op, {
+					...options,
+					parent: root
+				}))
 			};
 		}
 		case "Operation": {
 			let op = node;
-			const replaced = visitor.operation?.(op);
+			const replaced = visitor.operation?.(op, { parent });
 			if (replaced) op = replaced;
 			return {
 				...op,
-				parameters: op.parameters.map((p) => transform(p, visitor, options)),
-				requestBody: op.requestBody ? transform(op.requestBody, visitor, options) : void 0,
-				responses: op.responses.map((r) => transform(r, visitor, options))
+				parameters: op.parameters.map((p) => transform(p, {
+					...options,
+					parent: op
+				})),
+				requestBody: op.requestBody ? {
+					...op.requestBody,
+					schema: op.requestBody.schema ? transform(op.requestBody.schema, {
+						...options,
+						parent: op
+					}) : void 0
+				} : void 0,
+				responses: op.responses.map((r) => transform(r, {
+					...options,
+					parent: op
+				}))
 			};
 		}
 		case "Schema": {
 			let schema = node;
-			const replaced = visitor.schema?.(schema);
+			const replaced = visitor.schema?.(schema, { parent });
 			if (replaced) schema = replaced;
+			const childOptions = {
+				...options,
+				parent: schema
+			};
 			return {
 				...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)) } : {}
+				..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
+				..."items" in schema && recurse ? { items: schema.items?.map((i) => transform(i, childOptions)) } : {},
+				..."members" in schema && recurse ? { members: schema.members?.map((m) => transform(m, childOptions)) } : {},
+				..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
 			};
 		}
 		case "Property": {
 			let prop = node;
-			const replaced = visitor.property?.(prop);
+			const replaced = visitor.property?.(prop, { parent });
 			if (replaced) prop = replaced;
-			return {
+			return createProperty({
 				...prop,
-				schema: transform(prop.schema, visitor, options)
-			};
+				schema: transform(prop.schema, {
+					...options,
+					parent: prop
+				})
+			});
 		}
 		case "Parameter": {
 			let param = node;
-			const replaced = visitor.parameter?.(param);
+			const replaced = visitor.parameter?.(param, { parent });
 			if (replaced) param = replaced;
-			return {
+			return createParameter({
 				...param,
-				schema: transform(param.schema, visitor, options)
-			};
+				schema: transform(param.schema, {
+					...options,
+					parent: param
+				})
+			});
 		}
 		case "Response": {
 			let response = node;
-			const replaced = visitor.response?.(response);
+			const replaced = visitor.response?.(response, { parent });
 			if (replaced) response = replaced;
 			return {
 				...response,
-				schema: response.schema ? transform(response.schema, visitor, options) : void 0
+				schema: transform(response.schema, {
+					...options,
+					parent: response
+				})
 			};
 		}
+		case "FunctionParameter":
+		case "ObjectBindingParameter":
+		case "FunctionParameters": return node;
 	}
 }
 /**
-* Depth-first synchronous reduction. Collects non-`undefined` visitor return values into an array.
+* Composes multiple visitors into one visitor, applied left to right.
+*
+* For each node kind, output from one visitor is input to the next.
+* If a visitor returns `undefined`, the previous node value is kept.
+*
+* @example
+* ```ts
+* const visitor = composeTransformers(
+*   { operation: (node) => ({ ...node, operationId: `a_${node.operationId}` }) },
+*   { operation: (node) => ({ ...node, operationId: `b_${node.operationId}` }) },
+* )
+* ```
 */
-function collect(node, visitor, options = {}) {
-	const recurse = (options.depth ?? visitorDepths.deep) === visitorDepths.deep;
+function composeTransformers(...visitors) {
+	return {
+		root(node, context) {
+			return visitors.reduce((acc, v) => v.root?.(acc, context) ?? acc, node);
+		},
+		operation(node, context) {
+			return visitors.reduce((acc, v) => v.operation?.(acc, context) ?? acc, node);
+		},
+		schema(node, context) {
+			return visitors.reduce((acc, v) => v.schema?.(acc, context) ?? acc, node);
+		},
+		property(node, context) {
+			return visitors.reduce((acc, v) => v.property?.(acc, context) ?? acc, node);
+		},
+		parameter(node, context) {
+			return visitors.reduce((acc, v) => v.parameter?.(acc, context) ?? acc, node);
+		},
+		response(node, context) {
+			return visitors.reduce((acc, v) => v.response?.(acc, context) ?? acc, node);
+		}
+	};
+}
+/**
+* Runs a depth-first synchronous collection pass.
+*
+* Non-`undefined` values returned by visitor callbacks are appended to the result.
+*
+* @example
+* ```ts
+* const ids = collect(root, {
+*   operation(node) {
+*     return node.operationId
+*   },
+* })
+* ```
+*
+* @example
+* ```ts
+* // Collect from only the current node
+* const values = collect(root, { depth: 'shallow', root: () => 'root' })
+* ```
+*/
+function collect(node, options) {
+	const { depth, parent, ...visitor } = options;
+	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
 	const results = [];
 	let v;
 	switch (node.kind) {
 		case "Root":
-			v = visitor.root?.(node);
+			v = visitor.root?.(node, { parent });
 			break;
 		case "Operation":
-			v = visitor.operation?.(node);
+			v = visitor.operation?.(node, { parent });
 			break;
 		case "Schema":
-			v = visitor.schema?.(node);
+			v = visitor.schema?.(node, { parent });
 			break;
 		case "Property":
-			v = visitor.property?.(node);
+			v = visitor.property?.(node, { parent });
 			break;
 		case "Parameter":
-			v = visitor.parameter?.(node);
+			v = visitor.parameter?.(node, { parent });
 			break;
 		case "Response":
-			v = visitor.response?.(node);
+			v = visitor.response?.(node, { parent });
 			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);
+	for (const child of getChildren(node, recurse)) for (const item of collect(child, {
+		...options,
+		parent: node
+	})) results.push(item);
 	return results;
 }
 //#endregion
-export { buildRefMap, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, definePrinter, httpMethods, isOperationNode, isParameterNode, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, transform, walk };
+//#region src/resolvers.ts
+function findDiscriminator(mapping, ref) {
+	if (!mapping || !ref) return null;
+	return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null;
+}
+function childName(parentName, propName) {
+	return parentName ? pascalCase([parentName, propName].join(" ")) : null;
+}
+function enumPropName(parentName, propName, enumSuffix) {
+	return pascalCase([
+		parentName,
+		propName,
+		enumSuffix
+	].filter(Boolean).join(" "));
+}
+/**
+* Collects import entries for all `ref` schema nodes in `node`.
+*/
+function collectImports({ node, nameMapping, resolve }) {
+	return collect(node, { schema(schemaNode) {
+		const schemaRef = narrowSchema(schemaNode, "ref");
+		if (!schemaRef?.ref) return;
+		const rawName = extractRefName(schemaRef.ref);
+		const result = resolve(nameMapping.get(rawName) ?? rawName);
+		if (!result) return;
+		return result;
+	} });
+}
+//#endregion
+//#region src/transformers.ts
+/**
+* Replaces a discriminator property's schema with a string enum of allowed values.
+*
+* If `node` is not an object schema, or if the property does not exist, the input
+* node is returned as-is.
+*
+* @example
+* ```ts
+* const schema = createSchema({
+*   type: 'object',
+*   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
+* })
+* const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
+* ```
+*/
+function setDiscriminatorEnum({ node, propertyName, values, enumName }) {
+	const objectNode = narrowSchema(node, "object");
+	if (!objectNode?.properties?.length) return node;
+	if (!objectNode.properties.some((prop) => prop.name === propertyName)) return node;
+	return createSchema({
+		...objectNode,
+		properties: objectNode.properties.map((prop) => {
+			if (prop.name !== propertyName) return prop;
+			return createProperty({
+				...prop,
+				schema: createSchema({
+					type: "enum",
+					primitive: "string",
+					enumValues: values,
+					name: enumName,
+					readOnly: prop.schema.readOnly,
+					writeOnly: prop.schema.writeOnly
+				})
+			});
+		})
+	});
+}
+/**
+* Merges adjacent anonymous object members into a single anonymous object member.
+*
+* @example
+* ```ts
+* const merged = mergeAdjacentObjects([
+*   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
+*   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
+* ])
+* ```
+*/
+function mergeAdjacentObjects(members) {
+	return members.reduce((acc, member) => {
+		const objectMember = narrowSchema(member, "object");
+		if (objectMember && !objectMember.name) {
+			const previous = acc.at(-1);
+			const previousObject = previous ? narrowSchema(previous, "object") : void 0;
+			if (previousObject && !previousObject.name) {
+				acc[acc.length - 1] = createSchema({
+					...previousObject,
+					properties: [...previousObject.properties ?? [], ...objectMember.properties ?? []]
+				});
+				return acc;
+			}
+		}
+		acc.push(member);
+		return acc;
+	}, []);
+}
+/**
+* Removes enum members that are covered by broader scalar primitives in the same union.
+*
+* @example
+* ```ts
+* const simplified = simplifyUnion([
+*   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
+*   createSchema({ type: 'string' }),
+* ])
+* // keeps only string member
+* ```
+*/
+function simplifyUnion(members) {
+	const scalarPrimitives = new Set(members.filter((member) => SCALAR_PRIMITIVE_TYPES.has(member.type)).map((m) => m.type));
+	if (!scalarPrimitives.size) return members;
+	return members.filter((member) => {
+		const enumNode = narrowSchema(member, "enum");
+		if (!enumNode) return true;
+		const primitive = enumNode.primitive;
+		if (!primitive) return true;
+		if ((enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0) <= 1) return true;
+		if (scalarPrimitives.has(primitive)) return false;
+		if ((primitive === "integer" || primitive === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
+		return true;
+	});
+}
+function setEnumName(propNode, parentName, propName, enumSuffix) {
+	const enumNode = narrowSchema(propNode, "enum");
+	if (enumNode?.primitive === "boolean") return {
+		...propNode,
+		name: void 0
+	};
+	if (enumNode) return {
+		...propNode,
+		name: enumPropName(parentName, propName, enumSuffix)
+	};
+	return propNode;
+}
+/**
+* Walks a schema tree and resolves `ref`/`enum` names through callbacks.
+*/
+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
+			};
+		}
+	} });
+}
+//#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 };
 
 //# sourceMappingURL=index.js.map