@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.60

package/dist/index.js

@@ -1,2010 +1,434 @@
-import "./chunk--u3MIqq1.js";
-import { createHash } from "node:crypto";
-import path from "node:path";
-//#region src/constants.ts
-const visitorDepths = {
-	shallow: "shallow",
-	deep: "deep"
-};
-const nodeKinds = {
-	input: "Input",
-	output: "Output",
-	operation: "Operation",
-	schema: "Schema",
-	property: "Property",
-	parameter: "Parameter",
-	response: "Response",
-	functionParameter: "FunctionParameter",
-	parameterGroup: "ParameterGroup",
-	functionParameters: "FunctionParameters",
-	type: "Type",
-	file: "File",
-	import: "Import",
-	export: "Export",
-	source: "Source",
-	text: "Text",
-	break: "Break"
-};
-/**
-* Schema type discriminators used by all AST schema nodes.
-*
-* These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).
-* Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),
-* and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.
-*/
-const schemaTypes = {
-	/**
-	* Text value.
-	*/
-	string: "string",
-	/**
-	* Floating-point number (`float`, `double`).
-	*/
-	number: "number",
-	/**
-	* Whole number (`int32`). Use `bigint` for `int64`.
-	*/
-	integer: "integer",
-	/**
-	* 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
-	*/
-	bigint: "bigint",
-	/**
-	* Boolean value
-	*/
-	boolean: "boolean",
-	/**
-	* Explicit null value.
-	*/
-	null: "null",
-	/**
-	* Any value (no type restriction).
-	*/
-	any: "any",
-	/**
-	* Unknown value (must be narrowed before usage).
-	*/
-	unknown: "unknown",
-	/**
-	* No return value (`void`).
-	*/
-	void: "void",
-	/**
-	* Object with named properties.
-	*/
-	object: "object",
-	/**
-	* Sequential list of items.
-	*/
-	array: "array",
-	/**
-	* Fixed-length list with position-specific items.
-	*/
-	tuple: "tuple",
-	/**
-	* "One of" multiple schema members.
-	*/
-	union: "union",
-	/**
-	* "All of" multiple schema members.
-	*/
-	intersection: "intersection",
-	/**
-	* Enum schema.
-	*/
-	enum: "enum",
-	/**
-	* Reference to another schema.
-	*/
-	ref: "ref",
-	/**
-	* Calendar date (for example `2026-03-24`).
-	*/
-	date: "date",
-	/**
-	* Date-time value (for example `2026-03-24T09:00:00Z`).
-	*/
-	datetime: "datetime",
-	/**
-	* Time-only value (for example `09:00:00`).
-	*/
-	time: "time",
-	/**
-	* UUID value.
-	*/
-	uuid: "uuid",
-	/**
-	* Email address value.
-	*/
-	email: "email",
-	/**
-	* URL value.
-	*/
-	url: "url",
-	/**
-	* IPv4 address value.
-	*/
-	ipv4: "ipv4",
-	/**
-	* IPv6 address value.
-	*/
-	ipv6: "ipv6",
-	/**
-	* Binary/blob value.
-	*/
-	blob: "blob",
-	/**
-	* Impossible value (`never`).
-	*/
-	never: "never"
-};
-/**
-* Scalar primitive schema types used for union simplification and type narrowing.
-*
-* Use `isScalarPrimitive()` to safely check whether a type is a scalar primitive.
-*/
-const SCALAR_PRIMITIVE_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
-/**
-* Type guard that returns `true` when `type` is a scalar primitive schema type.
-*
-* Use this to check if a schema type can be directly assigned without wrapping (e.g., `string | number | boolean`).
-*/
-function isScalarPrimitive(type) {
-	return SCALAR_PRIMITIVE_TYPES.has(type);
-}
-/**
-* HTTP method identifiers used by operation nodes.
-*
-* Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).
-*/
-const httpMethods = {
-	get: "GET",
-	post: "POST",
-	put: "PUT",
-	patch: "PATCH",
-	delete: "DELETE",
-	head: "HEAD",
-	options: "OPTIONS",
-	trace: "TRACE"
-};
-/**
-* Common MIME types used in request/response content negotiation.
-*
-* Covers JSON, XML, form data, PDFs, images, audio, and video formats.
-* Use these as keys when serializing request/response bodies.
-*/
-const mediaTypes = {
-	applicationJson: "application/json",
-	applicationXml: "application/xml",
-	applicationFormUrlEncoded: "application/x-www-form-urlencoded",
-	applicationOctetStream: "application/octet-stream",
-	applicationPdf: "application/pdf",
-	applicationZip: "application/zip",
-	applicationGraphql: "application/graphql",
-	multipartFormData: "multipart/form-data",
-	textPlain: "text/plain",
-	textHtml: "text/html",
-	textCsv: "text/csv",
-	textXml: "text/xml",
-	imagePng: "image/png",
-	imageJpeg: "image/jpeg",
-	imageGif: "image/gif",
-	imageWebp: "image/webp",
-	imageSvgXml: "image/svg+xml",
-	audioMpeg: "audio/mpeg",
-	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.
-*
-* Empty segments are filtered before joining. They arise when the text starts with
-* a dot followed immediately by a letter (e.g. `..Schema` splits into `['..', 'Schema']`
-* and `'..'` transforms to an empty string). Without this filter the join would produce
-* a leading `/`, which `path.resolve` would interpret as an absolute path, allowing
-* generated files to escape the configured output directory.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).filter(Boolean).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
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* 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) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-//#endregion
-//#region ../../internals/utils/src/string.ts
-/**
-* Strips the file extension from a path or file name.
-* Only removes the last `.ext` segment when the dot is not part of a directory name.
-*
-* @example
-* trimExtName('petStore.ts')             // 'petStore'
-* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
-* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
-* trimExtName('noExtension')             // 'noExtension'
-*/
-function trimExtName(text) {
-	const dotIndex = text.lastIndexOf(".");
-	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
-	return text;
-}
-//#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 an `InputNode`.
-*
-* @example
-* ```ts
-* if (isInputNode(node)) {
-*   console.log(node.schemas.length)
-* }
-* ```
-*/
-const isInputNode = isKind("Input");
-/**
-* Returns `true` when the input is an `OutputNode`.
-*
-* @example
-* ```ts
-* if (isOutputNode(node)) {
-*   console.log(node.files.length)
-* }
-* ```
-*/
-const isOutputNode = isKind("Output");
-/**
-* 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");
-//#endregion
-//#region src/refs.ts
-/**
-* 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;
-}
-//#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)
-* for (const task of [taskA, taskB, taskC]) {
-*   await limit(() => task())
-* }
-* // only 2 tasks run at the same time
-* ```
-*/
-function createLimit(concurrency) {
-	let active = 0;
-	const queue = [];
-	function next() {
-		if (active < concurrency && queue.length > 0) {
-			active++;
-			queue.shift()();
-		}
-	}
-	return function limit(fn) {
-		return new Promise((resolve, reject) => {
-			queue.push(() => {
-				Promise.resolve(fn()).then(resolve, reject).finally(() => {
-					active--;
-					next();
-				});
-			});
-			next();
-		});
-	};
-}
-/**
-* 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 "Input": return [...node.schemas, ...node.operations];
-		case "Output": return [];
-		case "Operation": return [
-			...node.parameters,
-			...node.requestBody?.content?.flatMap((c) => c.schema ? [c.schema] : []) ?? [],
-			...node.responses
-		];
-		case "Schema": {
-			const children = [];
-			if (!recurse) return [];
-			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 "ParameterGroup":
-		case "FunctionParameters":
-		case "Type": return [];
-		default: 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: `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, options) {
-	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
-}
-async function _walk(node, visitor, recurse, limit, parent) {
-	switch (node.kind) {
-		case "Input":
-			await limit(() => visitor.input?.(node, { parent }));
-			break;
-		case "Output":
-			await limit(() => visitor.output?.(node, { parent }));
-			break;
-		case "Operation":
-			await limit(() => visitor.operation?.(node, { parent }));
-			break;
-		case "Schema":
-			await limit(() => visitor.schema?.(node, { parent }));
-			break;
-		case "Property":
-			await limit(() => visitor.property?.(node, { parent }));
-			break;
-		case "Parameter":
-			await limit(() => visitor.parameter?.(node, { parent }));
-			break;
-		case "Response":
-			await limit(() => visitor.response?.(node, { parent }));
-			break;
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters": break;
-	}
-	const children = getChildren(node, recurse);
-	for (const child of children) await _walk(child, visitor, recurse, limit, node);
-}
-function transform(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	switch (node.kind) {
-		case "Input": {
-			let input = node;
-			const replaced = visitor.input?.(input, { parent });
-			if (replaced) input = replaced;
-			return {
-				...input,
-				schemas: input.schemas.map((s) => transform(s, {
-					...options,
-					parent: input
-				})),
-				operations: input.operations.map((op) => transform(op, {
-					...options,
-					parent: input
-				}))
-			};
-		}
-		case "Output": {
-			let output = node;
-			const replaced = visitor.output?.(output, { parent });
-			if (replaced) output = replaced;
-			return output;
-		}
-		case "Operation": {
-			let op = node;
-			const replaced = visitor.operation?.(op, { parent });
-			if (replaced) op = replaced;
-			return {
-				...op,
-				parameters: op.parameters.map((p) => transform(p, {
-					...options,
-					parent: op
-				})),
-				requestBody: op.requestBody ? {
-					...op.requestBody,
-					content: op.requestBody.content?.map((c) => ({
-						...c,
-						schema: c.schema ? transform(c.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, { parent });
-			if (replaced) schema = replaced;
-			const childOptions = {
-				...options,
-				parent: schema
-			};
-			return {
-				...schema,
-				..."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, { parent });
-			if (replaced) prop = replaced;
-			return createProperty({
-				...prop,
-				schema: transform(prop.schema, {
-					...options,
-					parent: prop
-				})
-			});
-		}
-		case "Parameter": {
-			let param = node;
-			const replaced = visitor.parameter?.(param, { parent });
-			if (replaced) param = replaced;
-			return createParameter({
-				...param,
-				schema: transform(param.schema, {
-					...options,
-					parent: param
-				})
-			});
-		}
-		case "Response": {
-			let response = node;
-			const replaced = visitor.response?.(response, { parent });
-			if (replaced) response = replaced;
-			return {
-				...response,
-				schema: transform(response.schema, {
-					...options,
-					parent: response
-				})
-			};
-		}
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters":
-		case "Type": return node;
-		default: return 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 "Input":
-			v = visitor.input?.(node, { parent });
-			break;
-		case "Output":
-			v = visitor.output?.(node, { parent });
-			break;
-		case "Operation":
-			v = visitor.operation?.(node, { parent });
-			break;
-		case "Schema":
-			v = visitor.schema?.(node, { parent });
-			break;
-		case "Property":
-			v = visitor.property?.(node, { parent });
-			break;
-		case "Parameter":
-			v = visitor.parameter?.(node, { parent });
-			break;
-		case "Response":
-			v = visitor.response?.(node, { parent });
-			break;
-		case "FunctionParameter":
-		case "ParameterGroup":
-		case "FunctionParameters": break;
-	}
-	if (v !== void 0) results.push(v);
-	for (const child of getChildren(node, recurse)) for (const item of collect(child, {
-		...options,
-		parent: node
-	})) results.push(item);
-	return results;
-}
-//#endregion
-//#region src/utils.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
-/**
-* Merges a ref node with its resolved schema, giving usage-site fields precedence.
-*
-* Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node
-* override the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
-*
-* @example
-* ```ts
-* // Ref with description override
-* const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
-* const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
-* ```
-*/
-function syncSchemaRef(node) {
-	const ref = narrowSchema(node, "ref");
-	if (!ref) return node;
-	if (!ref.schema) return node;
-	const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref;
-	const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
-	return createSchema({
-		...ref.schema,
-		...definedOverrides
-	});
-}
-/**
-* Type guard that returns `true` when a schema emits as a plain `string` type.
-*
-* Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
-* types, returns `true` only when `representation` is `'string'` rather than `'date'`.
-*/
-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.
-*
-* Use this before passing parameters to schema builders so output property keys match
-* the desired casing while preserving `OperationNode.parameters` for other consumers.
-* The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
-*/
-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 resolveParamsType({ node, param, resolver }) {
-	if (!resolver) return createParamsType({
-		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 createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return createParamsType({
-		variant: "reference",
-		name: individualName
-	});
-}
-/**
-* Converts an `OperationNode` into function parameters for code generation.
-*
-* Centralizes parameter grouping logic for all plugins. Provide a `resolver` for type name resolution
-* and `extraParams` for plugin-specific trailing parameters (e.g., `options` objects).
-* Supports three grouping modes: `object` (single destructured param), `inline` (separate params),
-* and `inlineSpread` (rest parameter). Use `CreateOperationParamsOptions` to fine-tune output.
-*/
-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) => createParamsType({
-		variant: "reference",
-		name: typeWrapper ? typeWrapper(type) : type
-	});
-	const wrapTypeNode = (type) => type.kind === "ParamsType" && 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?.content?.[0]?.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 = resolveParamsType({
-					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 = resolveParamsType({
-					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.kind === "ParamsType" && 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: createParamsType({
-			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 createParamsType({
-		variant: "struct",
-		properties: params.map((p) => ({
-			name: p.name,
-			optional: !p.required,
-			type: resolveParamsType({
-				node,
-				param: p,
-				resolver
-			})
-		}))
-	});
-}
-function sourceKey(source) {
-	return `${source.name ?? extractStringsFromNodes(source.nodes)}:${source.isExportable ?? false}:${source.isTypeOnly ?? false}`;
-}
-function pathTypeKey(path, isTypeOnly) {
-	return `${path}:${isTypeOnly ?? false}`;
-}
-function exportKey(path, name, isTypeOnly, asAlias) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}:${asAlias ?? ""}`;
-}
-function importKey(path, name, isTypeOnly) {
-	return `${path}:${name ?? ""}:${isTypeOnly ?? false}`;
-}
-/**
-* Computes a multi-level sort key for exports and imports:
-* non-array names first (wildcards/namespace aliases); type-only before value; alphabetical path; unnamed before named.
-*/
-function sortKey(node) {
-	const isArray = Array.isArray(node.name) ? "1" : "0";
-	const typeOnly = node.isTypeOnly ? "0" : "1";
-	const hasName = node.name != null ? "1" : "0";
-	const name = Array.isArray(node.name) ? [...node.name].sort().join("\0") : node.name ?? "";
-	return `${isArray}:${typeOnly}:${node.path}:${hasName}:${name}`;
-}
-/**
-* Deduplicates and merges `SourceNode` objects by `name + isExportable + isTypeOnly`.
-*
-* Unnamed sources are deduplicated by object reference. Returns a deduplicated array in original order.
-*/
-function combineSources(sources) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		const key = sourceKey(source);
-		if (!seen.has(key)) seen.set(key, source);
-	}
-	return [...seen.values()];
-}
-/**
-* Deduplicates and merges `ExportNode` objects by path and type.
-*
-* Named exports with the same path and `isTypeOnly` flag have their names merged into a single export.
-* Non-array exports are deduplicated by exact identity. Returns a sorted, deduplicated array.
-*/
-function combineExports(exports) {
-	const result = [];
-	const namedByPath = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const keyed = exports.map((node) => ({
-		node,
-		key: sortKey(node)
-	}));
-	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-	for (const { node: curr } of keyed) {
-		const { name, path, isTypeOnly, asAlias } = curr;
-		if (Array.isArray(name)) {
-			if (!name.length) continue;
-			const key = pathTypeKey(path, isTypeOnly);
-			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
-				const newItem = {
-					...curr,
-					name: [...new Set(name)]
-				};
-				result.push(newItem);
-				namedByPath.set(key, newItem);
-			}
-		} else {
-			const key = exportKey(path, name, isTypeOnly, asAlias);
-			if (!seen.has(key)) {
-				result.push(curr);
-				seen.add(key);
-			}
-		}
-	}
-	return result;
-}
-/**
-* Deduplicates and merges `ImportNode` objects, filtering out unused imports.
-*
-* Retains imports that are referenced in `source` or re-exported. Imports with the same path and
-* `isTypeOnly` flag have their names merged. Returns a sorted, deduplicated, filtered array.
-*
-* @note Use this when combining imports from multiple files to avoid duplicate declarations.
-*/
-function combineImports(imports, exports, source) {
-	const exportedNames = new Set(exports.flatMap((e) => Array.isArray(e.name) ? e.name : e.name ? [e.name] : []));
-	const isUsed = (importName) => !source || source.includes(importName) || exportedNames.has(importName);
-	const importNameMemo = /* @__PURE__ */ new Map();
-	const canonicalizeName = (n) => {
-		if (typeof n === "string") return n;
-		const key = `${n.propertyName}:${n.name ?? ""}`;
-		if (!importNameMemo.has(key)) importNameMemo.set(key, n);
-		return importNameMemo.get(key);
-	};
-	const result = [];
-	const namedByPath = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const keyed = imports.map((node) => ({
-		node,
-		key: sortKey(node)
-	}));
-	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-	for (const { node: curr } of keyed) {
-		if (curr.path === curr.root) continue;
-		const { path, isTypeOnly } = curr;
-		let { name } = curr;
-		if (Array.isArray(name)) {
-			name = [...new Set(name.map(canonicalizeName))].filter((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName));
-			if (!name.length) continue;
-			const key = pathTypeKey(path, isTypeOnly);
-			const existing = namedByPath.get(key);
-			if (existing && Array.isArray(existing.name)) {
-				const merged = new Set(existing.name);
-				for (const n of name) merged.add(n);
-				existing.name = [...merged];
-			} else {
-				const newItem = {
-					...curr,
-					name
-				};
-				result.push(newItem);
-				namedByPath.set(key, newItem);
-			}
-		} else {
-			if (name && !isUsed(name)) continue;
-			const key = importKey(path, name, isTypeOnly);
-			if (!seen.has(key)) {
-				result.push(curr);
-				seen.add(key);
-			}
-		}
-	}
-	return result;
-}
-/**
-* Extracts all string content from a `CodeNode` tree recursively.
-*
-* Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
-* and nested node content. Used internally to build the full source string for import filtering.
-*/
-function extractStringsFromNodes(nodes) {
-	if (!nodes?.length) return "";
-	return nodes.map((node) => {
-		if (typeof node === "string") return node;
-		if (node.kind === "Text") return node.value;
-		if (node.kind === "Break") return "";
-		if (node.kind === "Jsx") return node.value;
-		const parts = [];
-		if ("params" in node && node.params) parts.push(node.params);
-		if ("generics" in node && node.generics) parts.push(Array.isArray(node.generics) ? node.generics.join(", ") : node.generics);
-		if ("returnType" in node && node.returnType) parts.push(node.returnType);
-		if ("type" in node && typeof node.type === "string") parts.push(node.type);
-		const nested = extractStringsFromNodes(node.nodes);
-		if (nested) parts.push(nested);
-		return parts.join("\n");
-	}).filter(Boolean).join("\n");
-}
-/**
-* Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
-*
-* Returns `undefined` for non-ref nodes or when no name can be resolved. Use this to get a schema's
-* identifier for type definitions or error messages.
-*
-* @example
-* ```ts
-* resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' })
-* // => 'Pet'
-* ```
-*/
-function resolveRefName(node) {
-	if (!node || node.type !== "ref") return void 0;
-	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? void 0;
-	return node.name ?? node.schema?.name ?? void 0;
-}
-/**
-* Collects every named schema referenced (transitively) from a node via ref edges.
-*
-* Refs are followed by name only — the resolved `node.schema` is not traversed inline.
-* Use this to determine schema dependencies, build reference graphs, or detect what schemas need to be emitted.
-*
-* @example Collect refs from a single schema
-* ```ts
-* const names = collectReferencedSchemaNames(petSchema)
-* // → Set { 'Category', 'Tag' }
-* ```
-*
-* @example Accumulate refs from multiple schemas into one set
-* ```ts
-* const out = new Set<string>()
-* for (const schema of schemas) {
-*   collectReferencedSchemaNames(schema, out)
-* }
-* ```
-*/
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-	if (!node) return out;
-	collect(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = resolveRefName(child);
-			if (name) out.add(name);
-		}
-	} });
-	return out;
-}
-/**
-* Collects the names of all top-level schemas transitively used by a set of operations.
-*
-* An operation uses a schema when any of its parameters, request body content, or responses
-* reference it — directly or indirectly through other named schemas.
-* The walk is iterative and safe against reference cycles.
-*
-* Use this together with `include` filters to determine which schemas from `components/schemas`
-* are reachable from the allowed operations, so that schemas used only by excluded operations
-* are not generated.
-*
-* @example Only generate schemas referenced by included operations
-* ```ts
-* const includedOps = inputNode.operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
-*
-* for (const schema of inputNode.schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // … generate schema
-* }
-* ```
-*
-* @example Check whether a specific schema is needed
-* ```ts
-* const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
-* allowed.has('OrderStatus') // false when no included operation references OrderStatus
-* ```
-*/
-function collectUsedSchemaNames(operations, schemas) {
-	const schemaMap = /* @__PURE__ */ new Map();
-	for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
-	const result = /* @__PURE__ */ new Set();
-	function visitSchema(schema) {
-		const directRefs = collectReferencedSchemaNames(schema);
-		for (const name of directRefs) if (!result.has(name)) {
-			result.add(name);
-			const namedSchema = schemaMap.get(name);
-			if (namedSchema) visitSchema(namedSchema);
-		}
-	}
-	for (const op of operations) for (const schema of collect(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
-}
-/**
-* Identifies all schemas that participate in circular dependency chains, including direct self-loops.
-*
-* Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
-* in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
-* Refs are followed by name only, keeping the algorithm linear in the schema graph size.
-*
-* @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
-*/
-function findCircularSchemas(schemas) {
-	const graph = /* @__PURE__ */ new Map();
-	for (const schema of schemas) {
-		if (!schema.name) continue;
-		graph.set(schema.name, collectReferencedSchemaNames(schema));
-	}
-	const circular = /* @__PURE__ */ new Set();
-	for (const start of graph.keys()) {
-		const visited = /* @__PURE__ */ new Set();
-		const stack = [...graph.get(start) ?? []];
-		while (stack.length > 0) {
-			const node = stack.pop();
-			if (node === start) {
-				circular.add(start);
-				break;
-			}
-			if (visited.has(node)) continue;
-			visited.add(node);
-			const next = graph.get(node);
-			if (next) for (const r of next) stack.push(r);
-		}
-	}
-	return circular;
-}
-/**
-* Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
-*
-* Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
-* Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
-*
-* @note Returns `true` for the first matching circular ref found; use for fast dependency checks.
-*/
-function containsCircularRef(node, { circularSchemas, excludeName }) {
-	if (!node || circularSchemas.size === 0) return false;
-	return collect(node, { schema(child) {
-		if (child.type !== "ref") return void 0;
-		const name = resolveRefName(child);
-		return name && name !== excludeName && circularSchemas.has(name) ? true : void 0;
-	} }).length > 0;
-}
-//#endregion
-//#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(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
-}
-/**
-* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
-*
-* @example
-* ```ts
-* const input = createInput()
-* // { kind: 'Input', schemas: [], operations: [] }
-* ```
-*
-* @example
-* ```ts
-* const input = createInput({ schemas: [petSchema] })
-* // keeps default operations: []
-* ```
-*/
-function createInput(overrides = {}) {
-	return {
-		schemas: [],
-		operations: [],
-		...overrides,
-		kind: "Input"
-	};
-}
-/**
-* Creates an `OutputNode` with a stable default for `files`.
-*
-* @example
-* ```ts
-* const output = createOutput()
-* // { kind: 'Output', files: [] }
-* ```
-*
-* @example
-* ```ts
-* const output = createOutput({ files: [petFile] })
-* ```
-*/
-function createOutput(overrides = {}) {
-	return {
-		files: [],
-		...overrides,
-		kind: "Output"
-	};
-}
-/**
-* 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 {
-		tags: [],
-		parameters: [],
-		responses: [],
-		...props,
-		kind: "Operation"
-	};
-}
-/**
-* Maps schema `type` to its underlying `primitive`.
-* Primitive types map to themselves; special string formats map to `'string'`.
-* Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
-*/
-const TYPE_TO_PRIMITIVE = {
-	string: "string",
-	number: "number",
-	integer: "integer",
-	bigint: "bigint",
-	boolean: "boolean",
-	null: "null",
-	any: "any",
-	unknown: "unknown",
-	void: "void",
-	never: "never",
-	object: "object",
-	array: "array",
-	date: "date",
-	uuid: "string",
-	email: "string",
-	url: "string",
-	datetime: "string",
-	time: "string"
-};
-function createSchema(props) {
-	const inferredPrimitive = TYPE_TO_PRIMITIVE[props.type];
-	if (props["type"] === "object") return {
-		properties: [],
-		primitive: "object",
-		...props,
-		kind: "Schema"
-	};
-	return {
-		primitive: inferredPrimitive,
-		...props,
-		kind: "Schema"
-	};
-}
-/**
-* 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 {
-		...props,
-		kind: "Property",
-		required,
-		schema: syncOptionality(props.schema, required)
-	};
-}
-/**
-* 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 {
-		...props,
-		kind: "Parameter",
-		required,
-		schema: syncOptionality(props.schema, required)
-	};
-}
-/**
-* Creates a `ResponseNode`.
-*
-* @example
-* ```ts
-* const response = createResponse({
-*   statusCode: '200',
-*   description: 'Success',
-*   schema: createSchema({ type: 'object', properties: [] }),
-* })
-* ```
-*/
-function createResponse(props) {
-	return {
-		...props,
-		kind: "Response"
-	};
-}
-/**
-* Creates a `FunctionParameterNode`.
-*
-* `optional` defaults to `false`.
-*
-* @example Required typed param
-* ```ts
-* createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
-* // → petId: string
-* ```
-*
-* @example Optional param
-* ```ts
-* createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
-* // → params?: QueryParams
-* ```
-*
-* @example Param with default (implicitly optional; cannot combine with `optional: true`)
-* ```ts
-* createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
-* // → config: RequestConfig = {}
-* ```
-*/
-function createFunctionParameter(props) {
-	return {
-		optional: false,
-		...props,
-		kind: "FunctionParameter"
-	};
+import "./chunk-CNktS9qV.js";
+import { D as simplifyUnion, E as setEnumName, F as isHttpOperationNode, H as httpMethods, I as narrowSchema, T as setDiscriminatorEnum, U as schemaTypes, _ as nodeDefs, g as walk, h as transform, j as extractRefName, m as collectLazy, p as collect, w as mergeAdjacentObjectsLazy } from "./utils-Dj_KoXMv.js";
+import { $ as defineNode, A as contentDef, D as fileDef, E as exportDef, G as typeDef, H as functionDef, J as extractStringsFromNodes, M as arrowFunctionDef, N as breakDef, O as importDef, P as constDef, Q as schemaDef, S as typeLiteralDef, U as jsxDef, W as textDef, Z as createSchema, b as indexedAccessTypeDef, c as operationDef, et as syncOptionality, f as inputDef, i as parameterDef, k as sourceDef, n as responseDef, o as outputDef, q as propertyDef, u as requestBodyDef, v as functionParameterDef, x as objectBindingPatternDef, y as functionParametersDef } from "./response-DKxTr522.js";
+import { n as factory_exports } from "./factory-Du7nEP4B.js";
+import { hash } from "node:crypto";
+//#region src/signature.ts
+/**
+* The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
+*/
+function flagsDescriptor(node) {
+	return `${node.primitive ?? ""};${node.format ?? ""};${node.nullable ? 1 : 0}`;
+}
+function refTargetName(node) {
+	if (node.ref) return extractRefName(node.ref);
+	return node.name ?? "";
+}
+const arrayTupleFields = [
+	{
+		kind: "children",
+		key: "items",
+		prefix: "i"
+	},
+	{
+		kind: "child",
+		key: "rest",
+		prefix: "r"
+	},
+	{
+		kind: "scalar",
+		key: "min",
+		prefix: "mn"
+	},
+	{
+		kind: "scalar",
+		key: "max",
+		prefix: "mx"
+	},
+	{
+		kind: "bool",
+		key: "unique",
+		prefix: "u"
+	}
+];
+const numericFields = [
+	{
+		kind: "scalar",
+		key: "min",
+		prefix: "mn"
+	},
+	{
+		kind: "scalar",
+		key: "max",
+		prefix: "mx"
+	},
+	{
+		kind: "scalar",
+		key: "exclusiveMinimum",
+		prefix: "emn"
+	},
+	{
+		kind: "scalar",
+		key: "exclusiveMaximum",
+		prefix: "emx"
+	},
+	{
+		kind: "scalar",
+		key: "multipleOf",
+		prefix: "mo"
+	}
+];
+const rangeFields = [{
+	kind: "scalar",
+	key: "min",
+	prefix: "mn"
+}, {
+	kind: "scalar",
+	key: "max",
+	prefix: "mx"
+}];
+/**
+* Maps each node `type` to its ordered shape-contributing fields. Types absent from the map
+* (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.
+*/
+const SHAPE_KEYS = {
+	object: [
+		{ kind: "objectProps" },
+		{ kind: "additionalProps" },
+		{ kind: "patternProps" },
+		{
+			kind: "scalar",
+			key: "minProperties",
+			prefix: "mn"
+		},
+		{
+			kind: "scalar",
+			key: "maxProperties",
+			prefix: "mx"
+		}
+	],
+	array: arrayTupleFields,
+	tuple: arrayTupleFields,
+	union: [
+		{
+			kind: "scalar",
+			key: "strategy",
+			prefix: "s"
+		},
+		{
+			kind: "scalar",
+			key: "discriminatorPropertyName",
+			prefix: "d"
+		},
+		{
+			kind: "children",
+			key: "members",
+			prefix: "m"
+		}
+	],
+	intersection: [{
+		kind: "children",
+		key: "members",
+		prefix: "m"
+	}],
+	enum: [{ kind: "enumValues" }],
+	ref: [{ kind: "refTarget" }],
+	string: [
+		{
+			kind: "scalar",
+			key: "min",
+			prefix: "mn"
+		},
+		{
+			kind: "scalar",
+			key: "max",
+			prefix: "mx"
+		},
+		{
+			kind: "scalar",
+			key: "pattern",
+			prefix: "pt"
+		}
+	],
+	number: numericFields,
+	integer: numericFields,
+	bigint: numericFields,
+	url: [
+		{
+			kind: "scalar",
+			key: "path",
+			prefix: "path"
+		},
+		{
+			kind: "scalar",
+			key: "min",
+			prefix: "mn"
+		},
+		{
+			kind: "scalar",
+			key: "max",
+			prefix: "mx"
+		}
+	],
+	uuid: rangeFields,
+	email: rangeFields,
+	datetime: [{
+		kind: "bool",
+		key: "offset",
+		prefix: "o"
+	}, {
+		kind: "bool",
+		key: "local",
+		prefix: "l"
+	}],
+	date: [{
+		kind: "scalar",
+		key: "representation",
+		prefix: "rep"
+	}],
+	time: [{
+		kind: "scalar",
+		key: "representation",
+		prefix: "rep"
+	}]
+};
+function serializeShapeField(field, node, record) {
+	switch (field.kind) {
+		case "scalar": return `${field.prefix}:${record[field.key] ?? ""}`;
+		case "bool": return `${field.prefix}:${record[field.key] ? 1 : 0}`;
+		case "child": {
+			const child = record[field.key];
+			return `${field.prefix}:${child ? signatureOf(child) : ""}`;
+		}
+		case "children": {
+			const children = record[field.key] ?? [];
+			return `${field.prefix}[${children.map((c) => signatureOf(c)).join(",")}]`;
+		}
+		case "objectProps": return `p[${(node.properties ?? []).map((prop) => `${prop.name}${prop.required ? "!" : "?"}${signatureOf(prop.schema)}`).join(",")}]`;
+		case "additionalProps": {
+			const obj = node;
+			if (typeof obj.additionalProperties === "boolean") return `ab:${obj.additionalProperties}`;
+			if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`;
+			return "";
+		}
+		case "patternProps": {
+			const obj = node;
+			return `pp[${obj.patternProperties ? Object.keys(obj.patternProperties).sort().map((key) => `${key}=${signatureOf(obj.patternProperties[key])}`).join(",") : ""}]`;
+		}
+		case "enumValues": {
+			const en = node;
+			let values = "";
+			if (en.namedEnumValues?.length) values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(",");
+			else if (en.enumValues?.length) values = en.enumValues.map((value) => `${value === null ? "null" : typeof value}:${String(value)}`).join(",");
+			return `v[${values}]`;
+		}
+		case "refTarget": return `->${refTargetName(node)}`;
+	}
 }
 /**
-* 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
-* createParamsType({ variant: 'reference', name: 'QueryParams' })
-* ```
-*
-* @example Struct type (TypeScript: `{ petId: string }`)
-* ```ts
-* createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
-* ```
-*
-* @example Member type (TypeScript: `DeletePetPathParams['petId']`)
-* ```ts
-* createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
-* ```
+* Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,
+* constraints, and its children's signatures.
 */
-function createParamsType(props) {
-	return {
-		...props,
-		kind: "ParamsType"
-	};
+function describeShape(node) {
+	const flags = flagsDescriptor(node);
+	const fields = SHAPE_KEYS[node.type];
+	if (!fields) return `${node.type}|${flags}`;
+	const record = node;
+	const parts = [`${node.type}|${flags}`];
+	for (const field of fields) parts.push(serializeShapeField(field, node, record));
+	return parts.join("|");
 }
 /**
-* Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
-*
-* @example Grouped param (TypeScript declaration)
-* ```ts
-* createParameterGroup({
-*   properties: [
-*     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
-*     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
-*   ],
-*   default: '{}',
-* })
-* // declaration → { id, name? }: { id: string; name?: string } = {}
-* // call        → { id, name }
-* ```
-*
-* @example Inline (spread) — children emitted as individual top-level parameters
-* ```ts
-* createParameterGroup({
-*   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
-*   inline: true,
-* })
-* // declaration → petId: string
-* // call        → petId
-* ```
+* Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so
+* a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.
+* Reuse is safe because a signature depends only on content, and nodes are immutable once created.
 */
-function createParameterGroup(props) {
-	return {
-		...props,
-		kind: "ParameterGroup"
-	};
-}
+const signatureCache = /* @__PURE__ */ new WeakMap();
 /**
-* Creates a `FunctionParametersNode` from an ordered list of parameters.
-*
-* @example
-* ```ts
-* createFunctionParameters({
-*   params: [
-*     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
-*     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
-*   ],
-* })
-* ```
+* Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas
+* share a signature when they are structurally identical, ignoring documentation (`name`, `title`,
+* `description`, `example`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,
+* `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`
+* nodes compare by target name, which also terminates on circular shapes.
 *
-* @example
+* @example Two enums with different descriptions share a signature
 * ```ts
-* const empty = createFunctionParameters()
-* // { kind: 'FunctionParameters', params: [] }
+* signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+*   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
 * ```
 */
-function createFunctionParameters(props = {}) {
-	return {
-		params: [],
-		...props,
-		kind: "FunctionParameters"
-	};
+function signatureOf(node) {
+	const cached = signatureCache.get(node);
+	if (cached !== void 0) return cached;
+	const signature = hash("sha256", describeShape(node), "hex");
+	signatureCache.set(node, signature);
+	return signature;
 }
+//#endregion
+//#region src/dedupe.ts
 /**
-* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
-*
-* @example Named import
-* ```ts
-* createImport({ name: ['useState'], path: 'react' })
-* // import { useState } from 'react'
-* ```
-*
-* @example Type-only import
-* ```ts
-* createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
-* // import type { FC } from 'react'
-* ```
+* Builds the shared `ref` replacement for a duplicate occurrence, carrying the
+* usage-slot and documentation fields that are not part of the canonical type.
 */
-function createImport(props) {
-	return {
-		...props,
-		kind: "Import"
-	};
+function createRefNode(node, canonical) {
+	return createSchema({
+		type: "ref",
+		name: canonical.name,
+		ref: canonical.ref,
+		optional: node.optional,
+		nullish: node.nullish,
+		readOnly: node.readOnly,
+		writeOnly: node.writeOnly,
+		deprecated: node.deprecated,
+		description: node.description,
+		default: node.default,
+		example: node.example
+	});
 }
-/**
-* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
-*
-* @example Named export
-* ```ts
-* createExport({ name: ['Pet'], path: './Pet' })
-* // export { Pet } from './Pet'
-* ```
-*
-* @example Wildcard export
-* ```ts
-* createExport({ path: './utils' })
-* // export * from './utils'
-* ```
-*/
-function createExport(props) {
-	return {
-		...props,
-		kind: "Export"
-	};
+function applyDedupe(node, plan, skipRootMatch = false) {
+	const { canonicalBySignature, aliasNames } = plan;
+	if (canonicalBySignature.size === 0 && aliasNames.size === 0) return node;
+	const root = node;
+	return transform(node, { schema(schemaNode) {
+		if (schemaNode.type === "ref") {
+			const target = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name;
+			const canonical = target ? aliasNames.get(target) : void 0;
+			return canonical ? {
+				...schemaNode,
+				name: canonical.name,
+				ref: canonical.ref
+			} : void 0;
+		}
+		const signature = signatureOf(schemaNode);
+		if (skipRootMatch && schemaNode === root) return void 0;
+		const canonical = canonicalBySignature.get(signature);
+		if (!canonical) return void 0;
+		return createRefNode(schemaNode, canonical);
+	} });
 }
 /**
-* Creates a `SourceNode` representing a fragment of source code within a file.
-*
-* @example
-* ```ts
-* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
-* ```
+* Strips usage-slot flags from a hoisted definition and applies its canonical name.
+* A standalone definition is never optional, so `optional`/`nullish` are cleared.
 */
-function createSource(props) {
+function cleanDefinition(node, name) {
 	return {
-		...props,
-		kind: "Source"
+		...node,
+		name,
+		optional: void 0,
+		nullish: void 0
 	};
 }
 /**
-* Creates a fully resolved `FileNode` from a file input descriptor.
-*
-* Computes:
-* - `id` — SHA256 hash of the file path
-* - `name` — `baseName` without extension
-* - `extname` — extension extracted from `baseName`
+* Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
 *
-* Deduplicates:
-* - `sources` via `combineSources`
-* - `exports` via `combineExports`
-* - `imports` via `combineImports` (also filters unused imports)
-*
-* @throws {Error} when `baseName` has no extension.
+* A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
+* is a named top-level schema, the first one becomes the canonical (so other top-level
+* duplicates and inline copies turn into references to it). Every other top-level name with
+* the same content is recorded in `aliasNames`, so refs to it can be repointed at the
+* canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
+* per node with {@link applyDedupe}.
 *
 * @example
 * ```ts
-* const file = createFile({
-*   baseName: 'petStore.ts',
-*   path: 'src/models/petStore.ts',
-*   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
-*   imports: [createImport({ name: ['z'], path: 'zod' })],
-*   exports: [createExport({ name: ['Pet'], path: './petStore' })],
-* })
-* // file.id      = SHA256 hash of 'src/models/petStore.ts'
-* // file.name    = 'petStore'
-* // file.extname = '.ts'
-* ```
-*/
-function createFile(input) {
-	const extname = path.extname(input.baseName) || (input.baseName.startsWith(".") ? input.baseName : "");
-	if (!extname) throw new Error(`No extname found for ${input.baseName}`);
-	const source = (input.sources ?? []).flatMap((item) => item.nodes ?? []).map((node) => extractStringsFromNodes([node])).filter(Boolean).join("\n\n");
-	const resolvedExports = input.exports?.length ? combineExports(input.exports) : [];
-	const resolvedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
-	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
-	return {
-		kind: "File",
-		...input,
-		id: createHash("sha256").update(input.path).digest("hex"),
-		name: trimExtName(input.baseName),
-		extname,
-		imports: resolvedImports,
-		exports: resolvedExports,
-		sources: resolvedSources,
-		meta: input.meta ?? {}
-	};
-}
-/**
-* Creates a `ConstNode` representing a TypeScript `const` declaration.
-*
-* Mirrors the `Const` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple constant
-* ```ts
-* createConst({ name: 'pet' })
-* // const pet = ...
-* ```
-*
-* @example Exported constant with type and `as const`
-* ```ts
-* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
-* // export const pets: Pet[] = ... as const
-* ```
-*
-* @example With JSDoc and child nodes
-* ```ts
-* createConst({
-*   name: 'config',
-*   export: true,
-*   JSDoc: { comments: ['@description App configuration'] },
-*   nodes: [],
-* })
-* ```
-*/
-function createConst(props) {
-	return {
-		...props,
-		kind: "Const"
-	};
-}
-/**
-* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
-*
-* Mirrors the `Type` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple type alias
-* ```ts
-* createType({ name: 'Pet' })
-* // type Pet = ...
-* ```
-*
-* @example Exported type with JSDoc
-* ```ts
-* createType({
-*   name: 'PetStatus',
-*   export: true,
-*   JSDoc: { comments: ['@description Status of a pet'] },
-* })
-* // export type PetStatus = ...
-* ```
-*/
-function createType(props) {
-	return {
-		...props,
-		kind: "Type"
-	};
-}
-/**
-* Creates a `FunctionNode` representing a TypeScript `function` declaration.
-*
-* Mirrors the `Function` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple function
-* ```ts
-* createFunction({ name: 'getPet' })
-* // function getPet() { ... }
-* ```
-*
-* @example Exported async function with return type
-* ```ts
-* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
-* // export async function fetchPet(): Promise<Pet> { ... }
-* ```
-*
-* @example Function with generics and params
-* ```ts
-* createFunction({
-*   name: 'identity',
-*   export: true,
-*   generics: ['T'],
-*   params: 'value: T',
-*   returnType: 'T',
-* })
-* // export function identity<T>(value: T): T { ... }
-* ```
-*/
-function createFunction(props) {
-	return {
-		...props,
-		kind: "Function"
-	};
-}
-/**
-* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
-*
-* Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
-* The component's `children` are represented as `nodes`.
-*
-* @example Simple arrow function
-* ```ts
-* createArrowFunction({ name: 'getPet' })
-* // const getPet = () => { ... }
-* ```
-*
-* @example Single-line exported arrow function
-* ```ts
-* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
-* // export const double = (n: number) => ...
-* ```
-*
-* @example Async arrow function with generics
-* ```ts
-* createArrowFunction({
-*   name: 'fetchPet',
-*   export: true,
-*   async: true,
-*   generics: ['T'],
-*   params: 'id: string',
-*   returnType: 'T',
+* const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
+*   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
+*   nameFor: (node) => node.name ?? null,
+*   refFor: (name) => `#/components/schemas/${name}`,
 * })
-* // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
-* ```
-*/
-function createArrowFunction(props) {
-	return {
-		...props,
-		kind: "ArrowFunction"
-	};
-}
-/**
-* Creates a {@link TextNode} representing a raw string fragment in the source output.
-*
-* Use this instead of bare strings when building `nodes` arrays so that every
-* entry in the array is a typed {@link CodeNode}.
-*
-* @example
-* ```ts
-* createText('return fetch(id)')
-* // { kind: 'Text', value: 'return fetch(id)' }
 * ```
 */
-function createText(value) {
+function buildDedupePlan(roots, options) {
+	const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options;
+	const topLevelNodes = /* @__PURE__ */ new Set();
+	const groups = /* @__PURE__ */ new Map();
+	function record(schemaNode) {
+		const signature = signatureOf(schemaNode);
+		if (!isCandidate(schemaNode)) return;
+		const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name;
+		const group = groups.get(signature);
+		if (group) {
+			group.count++;
+			if (isTopLevel) group.topLevelNames.push(schemaNode.name);
+		} else groups.set(signature, {
+			count: 1,
+			representative: schemaNode,
+			topLevelNames: isTopLevel ? [schemaNode.name] : []
+		});
+	}
+	for (const root of roots) {
+		if (root.kind === "Schema") topLevelNodes.add(root);
+		for (const schemaNode of collectLazy(root, { schema: (node) => node })) record(schemaNode);
+	}
+	const canonicalBySignature = /* @__PURE__ */ new Map();
+	const aliasNames = /* @__PURE__ */ new Map();
+	const pendingHoists = [];
+	for (const [signature, group] of groups) {
+		if (group.count < minOccurrences) continue;
+		const [firstName, ...duplicateNames] = group.topLevelNames;
+		if (firstName) {
+			const canonical = {
+				name: firstName,
+				ref: refFor(firstName)
+			};
+			canonicalBySignature.set(signature, canonical);
+			for (const duplicate of duplicateNames) aliasNames.set(duplicate, canonical);
+			continue;
+		}
+		const name = nameFor(group.representative, signature);
+		if (!name) continue;
+		canonicalBySignature.set(signature, {
+			name,
+			ref: refFor(name)
+		});
+		pendingHoists.push({
+			name,
+			representative: group.representative
+		});
+	}
 	return {
-		value,
-		kind: "Text"
+		canonicalBySignature,
+		aliasNames,
+		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
+			canonicalBySignature,
+			aliasNames
+		}, true), name))
 	};
 }
+//#endregion
+//#region src/dialect.ts
 /**
-* Creates a {@link BreakNode} representing a line break in the source output.
-*
-* Corresponds to `<br/>` in JSX components. Prints as an empty string which,
-* when joined with `\n` by `printNodes`, produces a blank line.
-*
-* @example
-* ```ts
-* createBreak()
-* // { kind: 'Break' }
-* ```
-*/
-function createBreak() {
-	return { kind: "Break" };
-}
-/**
-* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
-*
-* Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
+* Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
+* dialect's type for inference.
 *
 * @example
 * ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+* export const oasDialect = defineSchemaDialect({
+*   name: 'oas',
+*   isNullable,
+*   isReference,
+*   isDiscriminator,
+*   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+*   resolveRef,
+* })
 * ```
 */
-function createJsx(value) {
-	return {
-		value,
-		kind: "Jsx"
-	};
+function defineSchemaDialect(dialect) {
+	return dialect;
 }
 //#endregion
 //#region src/printer.ts
 /**
-* Creates a schema printer factory.
-*
-* This function wraps a builder and makes options optional at call sites.
+* Defines a schema printer: a function that takes a `SchemaNode` and emits
+* code in your target language. Each plugin that produces code from schemas
+* (TypeScript types, Zod schemas, Faker factories) ships a printer built
+* with this helper.
 *
 * 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).
+* - `name` unique identifier for the printer.
+* - `options` stored on the returned printer instance.
+* - `nodes` map of `SchemaType` → handler. Handlers return the rendered
+*   output (a string, a TypeScript AST node, ...) for that schema type.
+* - `print` (optional), top-level override exposed as `printer.print`.
+*   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
 *
-* @example Basic usage — Zod schema printer
+* Without a `print` override, `printer.print` falls back to `printer.transform`
+* (the node-level dispatcher).
+*
+* @example Tiny Zod printer
 * ```ts
+* import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
+*
 * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
 *
 * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
@@ -2013,7 +437,9 @@ function createJsx(value) {
 *   nodes: {
 *     string: () => 'z.string()',
 *     object(node) {
-*       const props = node.properties.map(p => `${p.name}: ${this.transform(p.schema)}`).join(', ')
+*       const props = node.properties
+*         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
+*         .join(', ')
 *       return `z.object({ ${props} })`
 *     },
 *   },
@@ -2025,11 +451,11 @@ function definePrinter(build) {
 }
 /**
 * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
-**
+*
 * @example
 * ```ts
-* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
-*   (node) => kindToHandlerKey[node.kind],
+* export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
+*   (node) => node.kind,
 * )
 * ```
 */
@@ -2041,7 +467,7 @@ function createPrinterFactory(getKey) {
 				options: resolvedOptions,
 				transform: (node) => {
 					const key = getKey(node);
-					if (key === void 0) return null;
+					if (key === null) return null;
 					const handler = nodes[key];
 					if (!handler) return null;
 					return handler.call(context, node);
@@ -2057,141 +483,6 @@ function createPrinterFactory(getKey) {
 	};
 }
 //#endregion
-//#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) => isScalarPrimitive(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;
-}
-//#endregion
-export { caseParams, childName, collect, collectImports, collectReferencedSchemaNames, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
+export { applyDedupe, arrowFunctionDef, breakDef, buildDedupePlan, collect, constDef, contentDef, createPrinterFactory, defineNode, definePrinter, defineSchemaDialect, exportDef, extractStringsFromNodes, factory_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, httpMethods, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, mergeAdjacentObjectsLazy, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, setDiscriminatorEnum, setEnumName, signatureOf, simplifyUnion, sourceDef, syncOptionality, textDef, transform, typeDef, typeLiteralDef, walk };
 
 //# sourceMappingURL=index.js.map