@kubb/ast 5.0.0-beta.57 → 5.0.0-beta.58

package/dist/index.js

@@ -1,189 +1,7 @@
-import "./chunk-C0LytTxp.js";
-import { _ as httpMethods, a as enumPropName, b as visitorDepths, g as camelCase, h as isValidVarName, o as extractRefName, v as isScalarPrimitive, y as schemaTypes } from "./utils-0p8ZO287.js";
+import "./chunk-CNktS9qV.js";
+import { $ as contentDef, A as collect, Ct as functionParametersDef, Dt as isHttpOperationNode, Et as typeLiteralDef, F as responseDef, Ft as httpMethods, G as inputDef, It as isScalarPrimitive, L as parameterDef, Lt as schemaTypes, M as transform, Mt as schemaDef, N as walk, Nt as defineNode, Ot as narrowSchema, Pt as syncOptionality, Q as sourceDef, St as functionParameterDef, Tt as objectBindingPatternDef, U as requestBodyDef, V as operationDef, X as fileDef, Y as exportDef, Z as importDef, a as enumPropName, dt as functionDef, ft as jsxDef, gt as propertyDef, ht as createProperty, j as collectLazy, jt as createSchema, kt as extractStringsFromNodes, mt as typeDef, nt as breakDef, o as extractRefName, pt as textDef, rt as constDef, tt as arrowFunctionDef, wt as indexedAccessTypeDef, z as outputDef } from "./utils-DN4XLVqz.js";
+import { n as factory_exports } from "./factory-C5gHvtLU.js";
 import { hash } from "node:crypto";
-import path from "node:path";
-//#region src/node.ts
-/**
-* Builds a type guard that matches nodes of the given `kind`.
-*/
-function isKind(kind) {
-	return (node) => node.kind === kind;
-}
-/**
-* Updates a schema's `optional` and `nullish` flags from a parent's `required`
-* value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
-* object properties combine "required" and "nullable" into a single AST.
-*
-* - Non-required + non-nullable → `optional: true`.
-* - Non-required + nullable → `nullish: true`.
-* - Required → both flags cleared.
-*/
-function syncOptionality(schema, required) {
-	const nullable = schema.nullable ?? false;
-	return {
-		...schema,
-		optional: !required && !nullable ? true : void 0,
-		nullish: !required && nullable ? true : void 0
-	};
-}
-/**
-* Defines a node once and derives its `create` builder, `is` guard, and traversal
-* metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
-* `kind`, so node construction lives in one place without scattered `as` casts.
-*
-* Set `rebuild: true` when the `build` hook derives fields from children. After a
-* transform rewrites those children, the registry reruns `create` so the derived
-* fields stay correct.
-*
-* @example Simple node
-* ```ts
-* const importDef = defineNode<ImportNode>({ kind: 'Import' })
-* const createImport = importDef.create
-* ```
-*
-* @example Node with a build hook that is rerun on transform
-* ```ts
-* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
-*   kind: 'Property',
-*   build: (props) => ({ ...props, required: props.required ?? false }),
-*   children: ['schema'],
-*   visitorKey: 'property',
-*   rebuild: true,
-* })
-* ```
-*/
-function defineNode(config) {
-	const { kind, defaults, build, children, visitorKey, rebuild } = config;
-	function create(input) {
-		const base = build ? build(input) : input;
-		return {
-			...defaults,
-			...base,
-			kind
-		};
-	}
-	return {
-		kind,
-		create,
-		is: isKind(kind),
-		children,
-		visitorKey,
-		rebuild
-	};
-}
-//#endregion
-//#region src/nodes/schema.ts
-/**
-* 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"
-};
-/**
-* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
-* empty array, and `primitive` is inferred from `type` when not explicitly provided.
-*/
-const schemaDef = defineNode({
-	kind: "Schema",
-	build: (props) => {
-		if (props.type === "object") return {
-			properties: [],
-			primitive: "object",
-			...props
-		};
-		return {
-			primitive: TYPE_TO_PRIMITIVE[props.type],
-			...props
-		};
-	},
-	children: [
-		"properties",
-		"items",
-		"members",
-		"additionalProperties"
-	],
-	visitorKey: "schema"
-});
-function createSchema(props) {
-	return schemaDef.create(props);
-}
-//#endregion
-//#region ../../internals/utils/src/fs.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 ../../internals/utils/src/promise.ts
-/**
-* Wraps `factory` with a keyed cache backed by the provided store.
-*
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
-*
-* @example Two-level (object + primitive)
-* ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
-* ```
-*/
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
-	};
-}
-//#endregion
 //#region src/signature.ts
 /**
 * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.
@@ -436,1657 +254,207 @@ function signatureOf(node) {
 	return signature;
 }
 //#endregion
-//#region src/nodes/code.ts
-/**
-* Definition for the {@link ConstNode}.
-*/
-const constDef = defineNode({ kind: "Const" });
+//#region src/dedupe.ts
 /**
-* Creates a `ConstNode` representing a TypeScript `const` declaration.
-*
-* @example Exported constant with type and `as const`
-* ```ts
-* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
-* // export const pets: Pet[] = ... as const
-* ```
+* Builds the shared `ref` replacement for a duplicate occurrence, carrying the
+* usage-slot and documentation fields that are not part of the canonical type.
 */
-const createConst = constDef.create;
+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
+	});
+}
+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);
+	} });
+}
 /**
-* Definition for the {@link TypeNode}.
+* Strips usage-slot flags from a hoisted definition and applies its canonical name.
+* A standalone definition is never optional, so `optional`/`nullish` are cleared.
 */
-const typeDef = defineNode({ kind: "Type" });
+function cleanDefinition(node, name) {
+	return {
+		...node,
+		name,
+		optional: void 0,
+		nullish: void 0
+	};
+}
 /**
-* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+* Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
 *
-* @example
-* ```ts
-* createType({ name: 'Pet', export: true })
-* // export type Pet = ...
-* ```
-*/
-const createType = typeDef.create;
-/**
-* Definition for the {@link FunctionNode}.
-*/
-const functionDef = defineNode({ kind: "Function" });
-/**
-* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+* 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
-* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
-* // export async function fetchPet(): Promise<Pet> { ... }
+* const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
+*   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
+*   nameFor: (node) => node.name ?? null,
+*   refFor: (name) => `#/components/schemas/${name}`,
+* })
 * ```
 */
-const createFunction = functionDef.create;
-/**
-* Definition for the {@link ArrowFunctionNode}.
-*/
-const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
+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 {
+		canonicalBySignature,
+		aliasNames,
+		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
+			canonicalBySignature,
+			aliasNames
+		}, true), name))
+	};
+}
+//#endregion
+//#region src/dialect.ts
 /**
-* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
+* Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
+* dialect's type for inference.
 *
 * @example
 * ```ts
-* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
-* // export const double = (n: number) => ...
+* export const oasDialect = defineSchemaDialect({
+*   name: 'oas',
+*   isNullable,
+*   isReference,
+*   isDiscriminator,
+*   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+*   resolveRef,
+* })
 * ```
 */
-const createArrowFunction = arrowFunctionDef.create;
-/**
-* Definition for the {@link TextNode}.
-*/
-const textDef = defineNode({
-	kind: "Text",
-	build: (value) => ({ value })
-});
+function defineSchemaDialect(dialect) {
+	return dialect;
+}
+//#endregion
+//#region src/printer.ts
 /**
-* Creates a {@link TextNode} representing a raw string fragment in the source output.
+* 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.
 *
-* @example
-* ```ts
-* createText('return fetch(id)')
-* // { kind: 'Text', value: 'return fetch(id)' }
-* ```
-*/
-const createText = textDef.create;
-/**
-* Definition for the {@link BreakNode}.
-*/
-const breakDef = defineNode({
-	kind: "Break",
-	build: () => ({})
-});
-/**
-* Creates a {@link BreakNode} representing a line break in the source output.
+* The builder receives resolved options and returns:
 *
-* @example
+* - `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.
+*
+* Without a `print` override, `printer.print` falls back to `printer.transform`
+* (the node-level dispatcher).
+*
+* @example Tiny Zod printer
 * ```ts
-* createBreak()
-* // { kind: 'Break' }
+* import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
+*
+* type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+*
+* export const zodPrinter = definePrinter<PrinterZod>((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} })`
+*     },
+*   },
+* }))
 * ```
 */
-function createBreak() {
-	return breakDef.create();
+function definePrinter(build) {
+	return createPrinterFactory((node) => node.type)(build);
 }
 /**
-* Definition for the {@link JsxNode}.
-*/
-const jsxDef = defineNode({
-	kind: "Jsx",
-	build: (value) => ({ value })
-});
-/**
-* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+* Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
 *
 * @example
 * ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
-* ```
-*/
-const createJsx = jsxDef.create;
-//#endregion
-//#region src/nodes/content.ts
-/**
-* Definition for the {@link ContentNode}.
-*/
-const contentDef = defineNode({
-	kind: "Content",
-	children: ["schema"]
-});
-/**
-* Creates a `ContentNode` for a single request-body or response content type.
-*/
-const createContent = contentDef.create;
-//#endregion
-//#region src/nodes/file.ts
-/**
-* Definition for the {@link ImportNode}.
-*/
-const importDef = defineNode({ kind: "Import" });
-/**
-* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
-*
-* @example Named import
-* ```ts
-* createImport({ name: ['useState'], path: 'react' })
-* // import { useState } from 'react'
-* ```
-*/
-const createImport = importDef.create;
-/**
-* Definition for the {@link ExportNode}.
-*/
-const exportDef = defineNode({ kind: "Export" });
-/**
-* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
-*
-* @example Named export
-* ```ts
-* createExport({ name: ['Pet'], path: './Pet' })
-* // export { Pet } from './Pet'
-* ```
-*/
-const createExport = exportDef.create;
-/**
-* Definition for the {@link SourceNode}.
-*/
-const sourceDef = defineNode({ kind: "Source" });
-/**
-* 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 })
-* ```
-*/
-const createSource = sourceDef.create;
-/**
-* Definition for the {@link FileNode}. The fully resolved builder lives in
-* `createFile`, so this definition only supplies the guard.
-*/
-const fileDef = defineNode({ kind: "File" });
-//#endregion
-//#region src/nodes/function.ts
-/**
-* Definition for the {@link TypeLiteralNode}.
-*/
-const typeLiteralDef = defineNode({ kind: "TypeLiteral" });
-/**
-* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
-*
-* @example
-* ```ts
-* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
-* // { petId: string }
-* ```
-*/
-const createTypeLiteral = typeLiteralDef.create;
-/**
-* Definition for the {@link IndexedAccessTypeNode}.
-*/
-const indexedAccessTypeDef = defineNode({ kind: "IndexedAccessType" });
-/**
-* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
-*
-* @example
-* ```ts
-* createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
-* // DeletePetPathParams['petId']
-* ```
-*/
-const createIndexedAccessType = indexedAccessTypeDef.create;
-/**
-* Definition for the {@link ObjectBindingPatternNode}.
-*/
-const objectBindingPatternDef = defineNode({ kind: "ObjectBindingPattern" });
-/**
-* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
-*
-* @example
-* ```ts
-* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
-* // { id, name }
-* ```
-*/
-const createObjectBindingPattern = objectBindingPatternDef.create;
-/**
-* Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
-* Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
-* paired with a {@link TypeLiteralNode} type.
-*/
-const functionParameterDef = defineNode({
-	kind: "FunctionParameter",
-	build: (input) => {
-		if ("properties" in input) return {
-			name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),
-			type: createTypeLiteral({ members: input.properties.map((p) => ({
-				name: p.name,
-				type: p.type,
-				optional: p.optional ?? false
-			})) }),
-			optional: input.optional ?? false,
-			...input.default !== void 0 ? { default: input.default } : {}
-		};
-		return {
-			optional: false,
-			...input
-		};
-	}
-});
-/**
-* Creates a `FunctionParameterNode`. `optional` defaults to `false`.
-*
-* @example Optional param
-* ```ts
-* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
-* // → params?: QueryParams
-* ```
-*
-* @example Destructured group
-* ```ts
-* createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
-* // → { id, name }: { id: string; name?: string } = {}
-* ```
-*/
-const createFunctionParameter = functionParameterDef.create;
-/**
-* Definition for the {@link FunctionParametersNode}.
-*/
-const functionParametersDef = defineNode({
-	kind: "FunctionParameters",
-	defaults: { params: [] }
-});
-/**
-* Creates a `FunctionParametersNode` from an ordered list of parameters.
-*
-* @example
-* ```ts
-* const empty = createFunctionParameters()
-* // { kind: 'FunctionParameters', params: [] }
-* ```
-*/
-function createFunctionParameters(props = {}) {
-	return functionParametersDef.create(props);
-}
-//#endregion
-//#region src/nodes/input.ts
-/**
-* Definition for the {@link InputNode}.
-*/
-const inputDef = defineNode({
-	kind: "Input",
-	defaults: {
-		schemas: [],
-		operations: [],
-		meta: {
-			circularNames: [],
-			enumNames: []
-		}
-	},
-	children: ["schemas", "operations"],
-	visitorKey: "input"
-});
-/**
-* Creates an `InputNode` with stable defaults for `schemas` and `operations`.
-*
-* @example
-* ```ts
-* const input = createInput()
-* // { kind: 'Input', schemas: [], operations: [] }
-* ```
-*/
-function createInput(overrides = {}) {
-	return inputDef.create(overrides);
-}
-/**
-* Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
-*
-* @example
-* ```ts
-* const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
-* ```
-*/
-function createStreamInput(schemas, operations, meta) {
-	return {
-		kind: "Input",
-		schemas,
-		operations,
-		meta
-	};
-}
-//#endregion
-//#region src/nodes/requestBody.ts
-/**
-* Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
-*/
-const requestBodyDef = defineNode({
-	kind: "RequestBody",
-	build: (props) => ({
-		...props,
-		content: props.content?.map(createContent)
-	}),
-	children: ["content"]
-});
-/**
-* Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
-*/
-const createRequestBody = requestBodyDef.create;
-//#endregion
-//#region src/nodes/operation.ts
-/**
-* Definition for the {@link OperationNode}. HTTP operations (those carrying both
-* `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
-* normalized into a `RequestBodyNode`.
-*/
-const operationDef = defineNode({
-	kind: "Operation",
-	build: (props) => {
-		const { requestBody, ...rest } = props;
-		const isHttp = rest.method !== void 0 && rest.path !== void 0;
-		return {
-			tags: [],
-			parameters: [],
-			responses: [],
-			...rest,
-			...isHttp ? { protocol: "http" } : {},
-			requestBody: requestBody ? createRequestBody(requestBody) : void 0
-		};
-	},
-	children: [
-		"parameters",
-		"requestBody",
-		"responses"
-	],
-	visitorKey: "operation"
-});
-function createOperation(props) {
-	return operationDef.create(props);
-}
-//#endregion
-//#region src/nodes/output.ts
-/**
-* Definition for the {@link OutputNode}.
-*/
-const outputDef = defineNode({
-	kind: "Output",
-	defaults: { files: [] },
-	visitorKey: "output"
-});
-/**
-* Creates an `OutputNode` with a stable default for `files`.
-*
-* @example
-* ```ts
-* const output = createOutput()
-* // { kind: 'Output', files: [] }
-* ```
-*/
-function createOutput(overrides = {}) {
-	return outputDef.create(overrides);
-}
-//#endregion
-//#region src/nodes/parameter.ts
-/**
-* Definition for the {@link ParameterNode}. `required` defaults to `false` and the
-* schema's `optional`/`nullish` flags are kept in sync with it.
-*/
-const parameterDef = defineNode({
-	kind: "Parameter",
-	build: (props) => {
-		const required = props.required ?? false;
-		return {
-			...props,
-			required,
-			schema: syncOptionality(props.schema, required)
-		};
-	},
-	children: ["schema"],
-	visitorKey: "parameter",
-	rebuild: true
-});
-/**
-* Creates a `ParameterNode`.
-*
-* @example
-* ```ts
-* const param = createParameter({
-*   name: 'petId',
-*   in: 'path',
-*   required: true,
-*   schema: createSchema({ type: 'string' }),
-* })
-* ```
-*/
-const createParameter = parameterDef.create;
-//#endregion
-//#region src/nodes/property.ts
-/**
-* Definition for the {@link PropertyNode}. `required` defaults to `false` and the
-* schema's `optional`/`nullish` flags are kept in sync with it.
-*/
-const propertyDef = defineNode({
-	kind: "Property",
-	build: (props) => {
-		const required = props.required ?? false;
-		return {
-			...props,
-			required,
-			schema: syncOptionality(props.schema, required)
-		};
-	},
-	children: ["schema"],
-	visitorKey: "property",
-	rebuild: true
-});
-/**
-* Creates a `PropertyNode`.
-*
-* @example
-* ```ts
-* const property = createProperty({
-*   name: 'status',
-*   required: true,
-*   schema: createSchema({ type: 'string', nullable: true }),
-* })
-* // required=true, no optional/nullish
-* ```
-*/
-const createProperty = propertyDef.create;
-//#endregion
-//#region src/nodes/response.ts
-/**
-* Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
-* `mediaType`/`keysToOmit`) is normalized into one `content` entry.
-*/
-const responseDef = defineNode({
-	kind: "Response",
-	build: (props) => {
-		const { schema, mediaType, keysToOmit, content, ...rest } = props;
-		const entries = content ?? (schema ? [{
-			contentType: mediaType ?? "application/json",
-			schema,
-			keysToOmit: keysToOmit ?? null
-		}] : void 0);
-		return {
-			...rest,
-			content: entries?.map(createContent)
-		};
-	},
-	children: ["content"],
-	visitorKey: "response"
-});
-/**
-* Creates a `ResponseNode`.
-*
-* @example
-* ```ts
-* const response = createResponse({
-*   statusCode: '200',
-*   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
-* })
-* ```
-*/
-const createResponse = responseDef.create;
-//#endregion
-//#region src/registry.ts
-/**
-* Every node definition. Adding a node means adding its `defineNode` to one
-* `nodes/*.ts` file and listing it here. The visitor tables below derive from it.
-*/
-const nodeDefs = [
-	inputDef,
-	outputDef,
-	operationDef,
-	requestBodyDef,
-	contentDef,
-	responseDef,
-	schemaDef,
-	propertyDef,
-	parameterDef,
-	functionParameterDef,
-	functionParametersDef,
-	typeLiteralDef,
-	indexedAccessTypeDef,
-	objectBindingPatternDef,
-	constDef,
-	typeDef,
-	functionDef,
-	arrowFunctionDef,
-	textDef,
-	breakDef,
-	jsxDef,
-	importDef,
-	exportDef,
-	sourceDef,
-	fileDef
-];
-/**
-* Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
-* Derived from each definition's `children`.
-*/
-const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => def.children ? [[def.kind, def.children]] : []));
-/**
-* Maps a node kind to the matching visitor callback name. Derived from each
-* definition's `visitorKey`.
-*/
-const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => def.visitorKey ? [[def.kind, def.visitorKey]] : []));
-/**
-* Per-kind builders rerun after children are rebuilt. Derived from each
-* definition's `rebuild` flag.
-*/
-const nodeRebuilders = Object.fromEntries(nodeDefs.flatMap((def) => def.rebuild ? [[def.kind, def.create]] : []));
-//#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();
-		});
-	};
-}
-const visitorKeysByKind = VISITOR_KEYS;
-/**
-* Returns `true` when `value` is an AST node (an object carrying a `kind`).
-*/
-function isNode(value) {
-	return typeof value === "object" && value !== null && "kind" in value;
-}
-/**
-* Returns the immediate traversable children of `node` based on {@link VISITOR_KEYS}.
-*
-* `Schema` children are only included when `recurse` is `true`. Shallow mode skips them.
-*
-* @example
-* ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, the request body, and responses
-* ```
-*/
-function* getChildren(node, recurse) {
-	if (node.kind === "Schema" && !recurse) return;
-	const keys = visitorKeysByKind[node.kind];
-	if (!keys) return;
-	const record = node;
-	for (const key of keys) {
-		const value = record[key];
-		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item)) yield item;
-		} else if (isNode(value)) yield value;
-	}
-}
-/**
-* Invokes the visitor callback that matches `node.kind`, passing the traversal
-* context. Returns the callback's result (a replacement node, a collected
-* value, or `undefined` when no callback is registered for the kind).
-*
-* Shared by `walk`, `transform`, and `collectLazy` so node-kind dispatch lives
-* in one place. `TResult` is the caller's expected return: the same node type
-* for `transform`, the collected value type for `collectLazy`, ignored for `walk`.
-*/
-function applyVisitor(node, visitor, parent) {
-	const key = VISITOR_KEY_BY_KIND[node.kind];
-	if (!key) return void 0;
-	const fn = visitor[key];
-	return fn?.(node, { parent });
-}
-/**
-* Async depth-first traversal for side effects. Visitor return values are
-* ignored. Use `transform` when you want to rewrite nodes.
-*
-* Sibling nodes at each depth run concurrently up to `options.concurrency`
-* (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
-* work. Lower values reduce memory pressure.
-*
-* @example Log every operation
-* ```ts
-* await walk(root, {
-*   operation(node) {
-*     console.log(node.operationId)
-*   },
-* })
-* ```
-*
-* @example Only visit the root node
-* ```ts
-* await walk(root, { depth: 'shallow', input: () => {} })
-* ```
-*/
-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) {
-	await limit(() => applyVisitor(node, visitor, parent));
-	const children = Array.from(getChildren(node, recurse));
-	if (children.length === 0) return;
-	await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)));
-}
-function transform(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	const rebuilt = transformChildren(applyVisitor(node, visitor, parent) ?? node, options, recurse);
-	if (rebuilt === node) return node;
-	const rebuild = nodeRebuilders[rebuilt.kind];
-	return rebuild ? rebuild(rebuilt) : rebuilt;
-}
-/**
-* Immutably rebuilds a node's children using {@link VISITOR_KEYS}, transforming
-* each child node and leaving non-node values (e.g. `additionalProperties: true`) intact.
-* `Schema` children are skipped in shallow mode.
-*/
-function transformChildren(node, options, recurse) {
-	if (node.kind === "Schema" && !recurse) return node;
-	const keys = visitorKeysByKind[node.kind];
-	if (!keys) return node;
-	const record = node;
-	const childOptions = {
-		...options,
-		parent: node
-	};
-	let updates;
-	for (const key of keys) {
-		if (!(key in record)) continue;
-		const value = record[key];
-		if (Array.isArray(value)) {
-			let changed = false;
-			const mapped = value.map((item) => {
-				if (!isNode(item)) return item;
-				const next = transform(item, childOptions);
-				if (next !== item) changed = true;
-				return next;
-			});
-			if (changed) (updates ??= {})[key] = mapped;
-		} else if (isNode(value)) {
-			const next = transform(value, childOptions);
-			if (next !== value) (updates ??= {})[key] = next;
-		}
-	}
-	return updates ? {
-		...node,
-		...updates
-	} : node;
-}
-/**
-* Lazy depth-first collection pass. Yields every non-null value returned by
-* the visitor callbacks. Use `collect` for the eager array form.
-*
-* @example Collect every operationId
-* ```ts
-* const ids: string[] = []
-* for (const id of collectLazy<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })) {
-*   ids.push(id)
-* }
-* ```
-*/
-function* collectLazy(node, options) {
-	const { depth, parent, ...visitor } = options;
-	const recurse = (depth ?? visitorDepths.deep) === visitorDepths.deep;
-	const v = applyVisitor(node, visitor, parent);
-	if (v != null) yield v;
-	for (const child of getChildren(node, recurse)) yield* collectLazy(child, {
-		...options,
-		parent: node
-	});
-}
-/**
-* Eager depth-first collection pass. Returns an array of every non-null value
-* the visitor callbacks return.
-*
-* @example Collect every operationId
-* ```ts
-* const ids = collect<string>(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })
-* ```
-*/
-function collect(node, options) {
-	return Array.from(collectLazy(node, options));
-}
-//#endregion
-//#region src/dedupe.ts
-/**
-* 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 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
-	});
-}
-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);
-	} });
-}
-/**
-* 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 cleanDefinition(node, name) {
-	return {
-		...node,
-		name,
-		optional: void 0,
-		nullish: void 0
-	};
-}
-/**
-* Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
-*
-* 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 plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
-*   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
-*   nameFor: (node) => node.name ?? null,
-*   refFor: (name) => `#/components/schemas/${name}`,
-* })
-* ```
-*/
-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 {
-		canonicalBySignature,
-		aliasNames,
-		hoisted: pendingHoists.map(({ name, representative }) => cleanDefinition(applyDedupe(representative, {
-			canonicalBySignature,
-			aliasNames
-		}, true), name))
-	};
-}
-//#endregion
-//#region src/dialect.ts
-/**
-* Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
-* dialect's type for inference.
-*
-* @example
-* ```ts
-* export const oasDialect = defineSchemaDialect({
-*   name: 'oas',
-*   isNullable,
-*   isReference,
-*   isDiscriminator,
-*   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
-*   resolveRef,
-* })
-* ```
-*/
-function defineSchemaDialect(dialect) {
-	return dialect;
-}
-//#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 | null
-* ```
-*/
-function narrowSchema(node, type) {
-	return node?.type === type ? node : null;
-}
-/**
-* Narrows an `OperationNode` to an `HttpOperationNode`, guaranteeing `method` and `path`.
-*
-* @example
-* ```ts
-* if (isHttpOperationNode(node)) {
-*   console.log(node.method, node.path)
-* }
-* ```
-*/
-function isHttpOperationNode(node) {
-	return node.protocol === "http" || node.method !== void 0 && node.path !== void 0;
-}
-//#endregion
-//#region src/utils/ast.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.
-*/
-const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoize(/* @__PURE__ */ new Map(), (casing) => params.map((param) => {
-	const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
-	return {
-		...param,
-		name: transformed
-	};
-})));
-function caseParams(params, casing) {
-	if (!casing) return params;
-	return caseParamsMemo(params)(casing);
-}
-/**
-* 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
-		})]
-	});
-}
-/**
-* Resolves the {@link TypeExpression} for an individual parameter.
-*
-* Without a resolver, falls back to the schema primitive (a plain type-name string).
-* When the parameter belongs to a named group, emits an {@link IndexedAccessTypeNode}
-* (`GroupParams['petId']`); otherwise the resolved individual name as a plain string.
-*/
-function resolveParamType({ node, param, resolver }) {
-	if (!resolver) return param.schema.primitive ?? "unknown";
-	const individualName = resolver.resolveParamName(node, param);
-	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
-	const groupResolvers = {
-		path: resolver.resolvePathParamsName,
-		query: resolver.resolveQueryParamsName,
-		header: resolver.resolveHeaderParamsName
-	};
-	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
-	if (groupName && groupName !== individualName) return createIndexedAccessType({
-		objectType: groupName,
-		indexType: param.name
-	});
-	return individualName;
-}
-/**
-* Converts an `OperationNode` into function parameters for code generation.
-*
-* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
-* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
-* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
-* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
-*/
-function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
-	const dataName = paramNames?.data ?? "data";
-	const paramsName = paramNames?.params ?? "params";
-	const headersName = paramNames?.headers ?? "headers";
-	const pathName = paramNames?.path ?? "pathParams";
-	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
-	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
-	const casedParams = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const toProperty = (param) => ({
-		name: param.name,
-		type: wrapTypeExpression(resolveParamType({
-			node,
-			param,
-			resolver
-		})),
-		optional: !param.required
-	});
-	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
-	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
-	const bodyProperty = bodyType ? [{
-		name: dataName,
-		type: bodyType,
-		optional: !(node.requestBody?.required ?? false)
-	}] : [];
-	const trailingGroups = [{
-		name: paramsName,
-		node,
-		params: queryParams,
-		groupType: resolveGroupType({
-			node,
-			params: queryParams,
-			group: "query",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}, {
-		name: headersName,
-		node,
-		params: headerParams,
-		groupType: resolveGroupType({
-			node,
-			params: headerParams,
-			group: "header",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}];
-	const params = [];
-	if (paramsType === "object") {
-		const children = [
-			...pathParams.map(toProperty),
-			...bodyProperty,
-			...trailingGroups.flatMap(buildGroupProperty)
-		];
-		if (children.length) params.push(createFunctionParameter({
-			properties: children,
-			default: emptyObjectDefault(children)
-		}));
-	} else {
-		if (pathParamsType === "inlineSpread" && pathParams.length) {
-			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
-			params.push(createFunctionParameter({
-				name: pathName,
-				type: spreadType ? wrapType(spreadType) : void 0,
-				rest: true
-			}));
-		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => createFunctionParameter(toProperty(p))));
-		else if (pathParams.length) {
-			const pathChildren = pathParams.map(toProperty);
-			params.push(createFunctionParameter({
-				properties: pathChildren,
-				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
-			}));
-		}
-		params.push(...bodyProperty.map((p) => createFunctionParameter(p)));
-		params.push(...trailingGroups.flatMap(buildGroupParam));
-	}
-	params.push(...extraParams);
-	return createFunctionParameters({ params });
-}
-/**
-* Builds the property descriptor for a query or header group.
-* Returns an empty array when there are no params to emit.
-*
-* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
-* {@link TypeLiteralNode} from the individual params.
-*/
-function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
-	if (groupType) return [{
-		name,
-		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
-		optional: groupType.optional
-	}];
-	if (params.length) return [{
-		name,
-		type: buildTypeLiteral({
-			node,
-			params,
-			resolver
-		}),
-		optional: params.every((p) => !p.required)
-	}];
-	return [];
-}
-/**
-* Builds a single {@link FunctionParameterNode} for a query or header group.
-* Returns an empty array when there are no params to emit.
-*
-* A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
-* {@link TypeLiteralNode} from the individual params.
-*/
-function buildGroupParam(args) {
-	return buildGroupProperty(args).map((p) => createFunctionParameter(p));
-}
-/**
-* Derives a {@link ParamGroupType} for a query or header group from the resolver.
-*
-* Returns `null` when there is no resolver, no params, or the group name equals the
-* individual param name (so there is no real group to emit).
-*/
-function resolveGroupType({ node, params, group, resolver }) {
-	if (!resolver || !params.length) return null;
-	const firstParam = params[0];
-	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: groupName,
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Builds a {@link TypeLiteralNode} 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 buildTypeLiteral({ node, params, resolver }) {
-	return createTypeLiteral({ members: params.map((p) => ({
-		name: p.name,
-		type: resolveParamType({
-			node,
-			param: p,
-			resolver
-		}),
-		optional: !p.required
-	})) });
-}
-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.toSorted().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()];
-}
-/**
-* Merges `incoming` names into `existing`, preserving order and dropping duplicates.
-*
-* Shared by `combineExports` and `combineImports` for the same-path name-merge case.
-*/
-function mergeNameArrays(existing, incoming) {
-	const merged = new Set(existing);
-	for (const name of incoming) merged.add(name);
-	return [...merged];
-}
-/**
-* 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)) existing.name = mergeNameArrays(existing.name, name);
-			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 pathsWithUsedNamedImport = /* @__PURE__ */ new Set();
-	for (const node of imports) {
-		if (!Array.isArray(node.name)) continue;
-		if (node.name.some((item) => typeof item === "string" ? isUsed(item) : isUsed(item.name ?? item.propertyName))) pathsWithUsedNamedImport.add(node.path);
-	}
-	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)) existing.name = mergeNameArrays(existing.name, name);
-			else {
-				const newItem = {
-					...curr,
-					name
-				};
-				result.push(newItem);
-				namedByPath.set(key, newItem);
-			}
-		} else {
-			if (name && !isUsed(name) && !pathsWithUsedNamedImport.has(path)) 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 `null` 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 null;
-	if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null;
-	return node.name ?? node.schema?.name ?? null;
-}
-/**
-* 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)
-* }
-* ```
-*/
-const collectSchemaRefs = memoize(/* @__PURE__ */ new WeakMap(), (node) => {
-	const refs = /* @__PURE__ */ new Set();
-	collect(node, { schema(child) {
-		if (child.type === "ref") {
-			const name = resolveRefName(child);
-			if (name) refs.add(name);
-		}
-	} });
-	return refs;
-});
-function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
-	if (!node) return out;
-	for (const name of collectSchemaRefs(node)) 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 = operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
-*
-* for (const schema of schemas) {
-*   if (schema.name && !allowed.has(schema.name)) continue
-*   // … generate schema
-* }
-* ```
-*
-* @example Check whether a specific schema is needed
-* ```ts
-* const allowed = collectUsedSchemaNames(includedOps, schemas)
-* allowed.has('OrderStatus') // false when no included operation references OrderStatus
-* ```
-*/
-const collectUsedSchemaNamesMemo = memoize(/* @__PURE__ */ new WeakMap(), (ops) => memoize(/* @__PURE__ */ new WeakMap(), (schemas) => computeUsedSchemaNames(ops, schemas)));
-function computeUsedSchemaNames(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 collectLazy(op, {
-		depth: "shallow",
-		schema: (node) => node
-	})) visitSchema(schema);
-	return result;
-}
-function collectUsedSchemaNames(operations, schemas) {
-	return collectUsedSchemaNamesMemo(operations)(schemas);
-}
-const EMPTY_CIRCULAR_SET = /* @__PURE__ */ new Set();
-const findCircularSchemasMemo = memoize(/* @__PURE__ */ new WeakMap(), (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;
-});
-/**
-* 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) {
-	if (schemas.length === 0) return EMPTY_CIRCULAR_SET;
-	return findCircularSchemasMemo(schemas);
-}
-/**
-* 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;
-	for (const _ of collectLazy(node, { schema(child) {
-		if (child.type !== "ref") return null;
-		const name = resolveRefName(child);
-		return name && name !== excludeName && circularSchemas.has(name) ? true : null;
-	} })) return true;
-	return false;
-}
-//#endregion
-//#region src/factory.ts
-/**
-* Identity-preserving node update: returns `node` unchanged when every field in
-* `changes` already equals (by reference) the current value, otherwise a new node
-* with the changes applied.
-*
-* Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
-* structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
-* downstream passes can detect "nothing changed" by identity. Comparison is
-* shallow: a structurally-equal but newly-allocated array/object counts as a change.
-*
-* @example
-* ```ts
-* update(node, { name: node.name })        // -> same `node` reference
-* update(node, { name: 'renamed' })        // -> new node, `name` replaced
-* ```
-*/
-function update(node, changes) {
-	for (const key in changes) if (changes[key] !== node[key]) return {
-		...node,
-		...changes
-	};
-	return node;
-}
-/**
-* 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`
-*
-* Deduplicates:
-* - `sources` via `combineSources`
-* - `exports` via `combineExports`
-* - `imports` via `combineImports` (also filters unused imports)
-*
-* @throws {Error} when `baseName` has no extension.
-*
-* @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 combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || void 0) : [];
-	const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name) => Boolean(name)));
-	const nameOf = (item) => typeof item === "string" ? item : item.name ?? item.propertyName;
-	const resolvedImports = combinedImports.filter((imp) => imp.path !== input.path).flatMap((imp) => {
-		if (!Array.isArray(imp.name)) return typeof imp.name === "string" && localNames.has(imp.name) ? [] : [imp];
-		const kept = imp.name.filter((item) => !localNames.has(nameOf(item)));
-		if (!kept.length) return [];
-		return [kept.length === imp.name.length ? imp : {
-			...imp,
-			name: kept
-		}];
-	});
-	const resolvedSources = input.sources?.length ? combineSources(input.sources) : [];
-	return {
-		kind: "File",
-		...input,
-		id: hash("sha256", input.path, "hex"),
-		name: trimExtName(input.baseName),
-		extname,
-		imports: resolvedImports,
-		exports: resolvedExports,
-		sources: resolvedSources,
-		meta: input.meta ?? {}
-	};
-}
-//#endregion
-//#region src/printer.ts
-/**
-* 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` 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.
-*
-* 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) => ({
-*   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} })`
-*     },
-*   },
-* }))
-* ```
-*/
-function definePrinter(build) {
-	return createPrinterFactory((node) => node.type)(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,
 * )
 * ```
 */
@@ -2221,6 +589,6 @@ function setEnumName(propNode, parentName, propName, enumSuffix) {
 	return propNode;
 }
 //#endregion
-export { applyDedupe, arrowFunctionDef, breakDef, buildDedupePlan, caseParams, collect, collectUsedSchemaNames, constDef, containsCircularRef, contentDef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createIndexedAccessType, createInput, createJsx, createObjectBindingPattern, createOperation, createOperationParams, createOutput, createParameter, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createStreamInput, createText, createType, createTypeLiteral, defineNode, definePrinter, defineSchemaDialect, exportDef, extractStringsFromNodes, fileDef, findCircularSchemas, functionDef, functionParameterDef, functionParametersDef, httpMethods, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, isStringType, jsxDef, mergeAdjacentObjectsLazy, narrowSchema, objectBindingPatternDef, operationDef, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, setDiscriminatorEnum, setEnumName, signatureOf, simplifyUnion, sourceDef, syncOptionality, syncSchemaRef, textDef, transform, typeDef, typeLiteralDef, update, 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, objectBindingPatternDef, operationDef, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, setDiscriminatorEnum, setEnumName, signatureOf, simplifyUnion, sourceDef, syncOptionality, textDef, transform, typeDef, typeLiteralDef, walk };
 
 //# sourceMappingURL=index.js.map