@kubb/ast 5.0.0-alpha.67 → 5.0.0-alpha.69

package/dist/index.cjs

@@ -381,212 +381,527 @@ isKind("FunctionParameter");
 isKind("ParameterGroup");
 isKind("FunctionParameters");
 //#endregion
-//#region src/utils.ts
-const plainStringTypes = new Set([
-	"string",
-	"uuid",
-	"email",
-	"url",
-	"datetime"
-]);
+//#region src/refs.ts
 /**
-* Returns a merged schema view for a ref node, combining the resolved `node.schema`
-* (base from the referenced definition) with any usage-site sibling fields set directly
-* on the ref node (description, readOnly, nullable, deprecated, etc.).
+* Returns the last path segment of a reference string.
 *
-* Usage-site fields take precedence over the resolved schema's own fields when both are defined.
+* Example: `#/components/schemas/Pet` becomes `Pet`.
 *
-* For non-ref nodes the node itself is returned unchanged.
+* @example
+* ```ts
+* extractRefName('#/components/schemas/Pet') // 'Pet'
+* ```
 */
-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
-	});
+function extractRefName(ref) {
+	return ref.split("/").at(-1) ?? ref;
 }
+//#endregion
+//#region src/visitor.ts
 /**
-* Returns `true` when a schema is emitted as a plain `string` type.
+* Creates a small async concurrency limiter.
 *
-* - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
-* - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
+* At most `concurrency` tasks are in flight at once. Extra tasks are queued.
 *
 * @example
 * ```ts
-* isStringType(createSchema({ type: 'uuid' }))                          // true
-* isStringType(createSchema({ type: 'date', representation: 'date' }))  // false
+* const limit = createLimit(2)
+* for (const task of [taskA, taskB, taskC]) {
+*   await limit(() => task())
+* }
+* // only 2 tasks run at the same time
 * ```
 */
-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;
+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();
+		});
+	};
 }
 /**
-* Applies casing rules to parameter names and returns a new parameter array.
-*
-* The input array is not mutated.
-* If `casing` is not set, the original array is returned unchanged.
+* Returns the immediate traversable children of `node`.
 *
-* Use this before passing parameters to schema builders so that property keys
-* in generated output match the desired casing while preserving
-* `OperationNode.parameters` for other consumers.
+* 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 params = [createParameter({ name: 'pet_id', in: 'query', schema: createSchema({ type: 'string' }) })]
-* const cased = caseParams(params, 'camelcase')
-* // cased[0].name === 'petId'
+* const children = getChildren(operationNode, true)
+* // returns parameters, requestBody schema (if present), and responses
 * ```
 */
-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
-		};
-	});
+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 [];
+	}
 }
 /**
-* Creates a single-property object schema used as a discriminator literal.
+* 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
-* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
-* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+* await walk(root, {
+*   operation(node) {
+*     console.log(node.operationId)
+*   },
+* })
 * ```
-*/
-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 {@link OperationNode} into a {@link FunctionParametersNode}.
-*
-* Centralizes the per-plugin `getParams()` pattern. Provide a `resolver` for
-* type resolution and `extraParams` for plugin-specific trailing parameters.
 *
 * @example
 * ```ts
-* const params = createOperationParams(node, {
-*   paramsType: 'inline',
-*   pathParamsType: 'inline',
-*   resolver: tsResolver,
-*   extraParams: [createFunctionParameter({ name: 'options', type: createParamsType({ variant: 'reference', name: 'Partial<RequestOptions>' }), default: '{}' })],
-* })
+* // Visit only the current node
+* await walk(root, { depth: 'shallow', root: () => {} })
 * ```
 */
-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
-		}));
+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"
+]);
+/**
+* Returns a merged schema view for a ref node, combining the resolved `node.schema`
+* (base from the referenced definition) with any usage-site sibling fields set directly
+* on the ref node (description, readOnly, nullable, deprecated, etc.).
+*
+* Usage-site fields take precedence over the resolved schema's own fields when both are defined.
+*
+* For non-ref nodes the node itself is returned unchanged.
+*/
+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
+	});
+}
+/**
+* Returns `true` when a schema is emitted as a plain `string` type.
+*
+* - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
+* - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
+*
+* @example
+* ```ts
+* isStringType(createSchema({ type: 'uuid' }))                          // true
+* isStringType(createSchema({ type: 'date', representation: 'date' }))  // false
+* ```
+*/
+function isStringType(node) {
+	if (plainStringTypes.has(node.type)) return true;
+	const temporal = narrowSchema(node, "date") ?? narrowSchema(node, "time");
+	if (temporal) return temporal.representation !== "date";
+	return false;
+}
+/**
+* Applies casing rules to parameter names and returns a new parameter array.
+*
+* The input array is not mutated.
+* If `casing` is not set, the original array is returned unchanged.
+*
+* Use this before passing parameters to schema builders so that property keys
+* in generated output match the desired casing while preserving
+* `OperationNode.parameters` for other consumers.
+*
+* @example
+* ```ts
+* const params = [createParameter({ name: 'pet_id', in: 'query', schema: createSchema({ type: 'string' }) })]
+* const cased = caseParams(params, 'camelcase')
+* // cased[0].name === 'petId'
+* ```
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	return params.map((param) => {
+		const transformed = casing === "camelcase" || !isValidVarName(param.name) ? camelCase(param.name) : param.name;
+		return {
+			...param,
+			name: transformed
+		};
+	});
+}
+/**
+* Creates a single-property object schema used as a discriminator literal.
+*
+* @example
+* ```ts
+* createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+* // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+* ```
+*/
+function createDiscriminantNode({ propertyName, value }) {
+	return createSchema({
+		type: "object",
+		primitive: "object",
+		properties: [createProperty({
+			name: propertyName,
+			schema: createSchema({
+				type: "enum",
+				primitive: "string",
+				enumValues: [value]
+			}),
+			required: true
+		})]
+	});
+}
+function 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 {@link OperationNode} into a {@link FunctionParametersNode}.
+*
+* Centralizes the per-plugin `getParams()` pattern. Provide a `resolver` for
+* type resolution and `extraParams` for plugin-specific trailing parameters.
+*
+* @example
+* ```ts
+* const params = createOperationParams(node, {
+*   paramsType: 'inline',
+*   pathParamsType: 'inline',
+*   resolver: tsResolver,
+*   extraParams: [createFunctionParameter({ name: 'options', type: createParamsType({ variant: 'reference', name: 'Partial<RequestOptions>' }), default: '{}' })],
+* })
+* ```
+*/
+function createOperationParams(node, options) {
+	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const dataName = paramNames?.data ?? "data";
+	const paramsName = paramNames?.params ?? "params";
+	const headersName = paramNames?.headers ?? "headers";
+	const pathName = paramNames?.path ?? "pathParams";
+	const wrapType = (type) => 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;
@@ -850,6 +1165,114 @@ function extractStringsFromNodes(nodes) {
 		return parts.join("\n");
 	}).filter(Boolean).join("\n");
 }
+/**
+* Resolves the referenced 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.
+*
+* @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;
+}
+/**
+* Recursively collects every named schema referenced (transitively) from
+* `node` via `ref` edges. Refs are followed by name only — the resolved
+* `node.schema` of a ref is not traversed inline.
+*
+* @example
+* ```ts
+* const refs = collectReferencedSchemaNames(petSchema)
+* // => Set { 'Cat', 'Dog' }
+* ```
+*/
+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;
+}
+/**
+* Identifies every named schema that participates in a circular dependency
+* chain — including direct self-loops (e.g. `TreeNode → TreeNode`) and indirect
+* cycles spanning multiple schemas (e.g. `Pet → Cat → Pet`).
+*
+* The returned set contains schema names. Plugins that translate schemas into
+* a host language can use this to wrap recursive positions in a deferred
+* construct (lazy getter, `z.lazy(() => …)`, etc.) and avoid runtime stack
+* overflows when the generated code is executed.
+*
+* Refs are followed by name only — `node.schema` (the resolved referent) is
+* not traversed inline, which keeps the algorithm linear in the size of the
+* schema graph.
+*
+* @example
+* ```ts
+* const circular = findCircularSchemas(inputNode.schemas)
+* if (circular.has('Pet')) {
+*   // emit lazy wrapper for any property whose schema references Pet
+* }
+* ```
+*/
+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;
+}
+/**
+* Returns true when `node` (or anything nested within it) carries a `ref`
+* whose resolved name belongs to `circularSchemas`.
+*
+* When `excludeName` is provided, refs to that name are ignored — useful
+* when self-references are already handled separately from cross-schema
+* cycles (e.g. the faker plugin emits `undefined as any` for direct
+* self-recursion but a lazy getter for indirect cycles).
+*
+* @example
+* ```ts
+* const circular = findCircularSchemas(schemas)
+* if (containsCircularRef(property.schema, { circularSchemas: circular, excludeName: 'Pet' })) {
+*   // emit `get foo() { return fakeCat() }` instead of eager call
+* }
+* ```
+*/
+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
 /**
@@ -1318,545 +1741,230 @@ function createFile(input) {
 */
 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',
-* })
-* // 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) {
-	return {
-		value,
-		kind: "Text"
-	};
-}
-/**
-* 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.
-*
-* @example
-* ```ts
-* createJsx('<>\n  <a href={href}>Open</a>\n</>')
-* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
-* ```
-*/
-function createJsx(value) {
-	return {
-		value,
-		kind: "Jsx"
+		...props,
+		kind: "Const"
 	};
 }
-//#endregion
-//#region src/printer.ts
 /**
-* Creates a schema printer factory.
-*
-* This function wraps a builder and makes options optional at call sites.
-*
-* The builder receives resolved options and returns:
-* - `name` — a unique identifier for the printer
-* - `options` — options stored on the returned printer instance
-* - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
-* - `print` _(optional)_ — top-level override exposed as `printer.print`
-*   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
-*   - This keeps recursion safe and avoids self-calls
+* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
 *
-* When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+* Mirrors the `Type` component from `@kubb/renderer-jsx`.
+* The component's `children` are represented as `nodes`.
 *
-* @example Basic usage — Zod schema printer
+* @example Simple type alias
 * ```ts
-* 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} })`
-*     },
-*   },
-* }))
+* createType({ name: 'Pet' })
+* // type Pet = ...
 * ```
-*/
-function definePrinter(build) {
-	return createPrinterFactory((node) => node.type)(build);
-}
-/**
-* Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
-**
-* @example
+*
+* @example Exported type with JSDoc
 * ```ts
-* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
-*   (node) => kindToHandlerKey[node.kind],
-* )
+* createType({
+*   name: 'PetStatus',
+*   export: true,
+*   JSDoc: { comments: ['@description Status of a pet'] },
+* })
+* // export type PetStatus = ...
 * ```
 */
-function createPrinterFactory(getKey) {
-	return function(build) {
-		return (options) => {
-			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
-			const context = {
-				options: resolvedOptions,
-				transform: (node) => {
-					const key = getKey(node);
-					if (key === void 0) return null;
-					const handler = nodes[key];
-					if (!handler) return null;
-					return handler.call(context, node);
-				}
-			};
-			return {
-				name,
-				options: resolvedOptions,
-				transform: context.transform,
-				print: printOverride ? printOverride.bind(context) : context.transform
-			};
-		};
+function createType(props) {
+	return {
+		...props,
+		kind: "Type"
 	};
 }
-//#endregion
-//#region src/refs.ts
 /**
-* Returns the last path segment of a reference string.
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
 *
-* Example: `#/components/schemas/Pet` becomes `Pet`.
+* Mirrors the `Function` component from `@kubb/renderer-jsx`.
+* The component's `children` are represented as `nodes`.
 *
-* @example
+* @example Simple function
 * ```ts
-* extractRefName('#/components/schemas/Pet') // 'Pet'
+* createFunction({ name: 'getPet' })
+* // function getPet() { ... }
 * ```
-*/
-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 Exported async function with return type
+* ```ts
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
+* ```
 *
-* @example
+* @example Function with generics and params
 * ```ts
-* const limit = createLimit(2)
-* for (const task of [taskA, taskB, taskC]) {
-*   await limit(() => task())
-* }
-* // only 2 tasks run at the same time
+* createFunction({
+*   name: 'identity',
+*   export: true,
+*   generics: ['T'],
+*   params: 'value: T',
+*   returnType: 'T',
+* })
+* // export function identity<T>(value: T): T { ... }
 * ```
 */
-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();
-		});
+function createFunction(props) {
+	return {
+		...props,
+		kind: "Function"
 	};
 }
 /**
-* Returns the immediate traversable children of `node`.
+* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
 *
-* For `Schema` nodes, children (`properties`, `items`, `members`, and non-boolean
-* `additionalProperties`) are only included
-* when `recurse` is `true`; shallow mode skips them.
+* Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
+* The component's `children` are represented as `nodes`.
 *
-* @example
+* @example Simple arrow function
 * ```ts
-* const children = getChildren(operationNode, true)
-* // returns parameters, requestBody schema (if present), and responses
+* createArrowFunction({ name: 'getPet' })
+* // const getPet = () => { ... }
 * ```
-*/
-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
+* @example Single-line exported arrow function
 * ```ts
-* await walk(root, {
-*   operation(node) {
-*     console.log(node.operationId)
-*   },
-* })
+* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+* // export const double = (n: number) => ...
 * ```
 *
-* @example
+* @example Async arrow function with generics
 * ```ts
-* // Visit only the current node
-* await walk(root, { depth: 'shallow', root: () => {} })
+* createArrowFunction({
+*   name: 'fetchPet',
+*   export: true,
+*   async: true,
+*   generics: ['T'],
+*   params: 'id: string',
+*   returnType: 'T',
+* })
+* // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
 * ```
 */
-async function walk(node, options) {
-	return _walk(node, options, (options.depth ?? visitorDepths.deep) === visitorDepths.deep, createLimit(options.concurrency ?? 30), void 0);
+function createArrowFunction(props) {
+	return {
+		...props,
+		kind: "ArrowFunction"
+	};
 }
-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);
+/**
+* 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) {
+	return {
+		value,
+		kind: "Text"
+	};
 }
-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;
-	}
+/**
+* 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" };
 }
 /**
-* Runs a depth-first synchronous collection pass.
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
 *
-* Non-`undefined` values returned by visitor callbacks are appended to the result.
+* Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
 *
 * @example
 * ```ts
-* const ids = collect(root, {
-*   operation(node) {
-*     return node.operationId
-*   },
-* })
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
 * ```
+*/
+function createJsx(value) {
+	return {
+		value,
+		kind: "Jsx"
+	};
+}
+//#endregion
+//#region src/printer.ts
+/**
+* Creates a schema printer factory.
+*
+* This function wraps a builder and makes options optional at call sites.
+*
+* The builder receives resolved options and returns:
+* - `name` — a unique identifier for the printer
+* - `options` — options stored on the returned printer instance
+* - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
+* - `print` _(optional)_ — top-level override exposed as `printer.print`
+*   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
+*   - This keeps recursion safe and avoids self-calls
+*
+* When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+*
+* @example Basic usage — Zod schema printer
+* ```ts
+* type 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
-* // Collect from only the current node
-* const values = collect(root, { depth: 'shallow', root: () => 'root' })
+* export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
+*   (node) => kindToHandlerKey[node.kind],
+* )
 * ```
 */
-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;
+function createPrinterFactory(getKey) {
+	return function(build) {
+		return (options) => {
+			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
+			const context = {
+				options: resolvedOptions,
+				transform: (node) => {
+					const key = getKey(node);
+					if (key === void 0) return null;
+					const handler = nodes[key];
+					if (!handler) return null;
+					return handler.call(context, node);
+				}
+			};
+			return {
+				name,
+				options: resolvedOptions,
+				transform: context.transform,
+				print: printOverride ? printOverride.bind(context) : context.transform
+			};
+		};
+	};
 }
 //#endregion
 //#region src/resolvers.ts
@@ -1998,6 +2106,8 @@ exports.caseParams = caseParams;
 exports.childName = childName;
 exports.collect = collect;
 exports.collectImports = collectImports;
+exports.collectReferencedSchemaNames = collectReferencedSchemaNames;
+exports.containsCircularRef = containsCircularRef;
 exports.createArrowFunction = createArrowFunction;
 exports.createBreak = createBreak;
 exports.createConst = createConst;
@@ -2027,6 +2137,7 @@ exports.definePrinter = definePrinter;
 exports.enumPropName = enumPropName;
 exports.extractRefName = extractRefName;
 exports.extractStringsFromNodes = extractStringsFromNodes;
+exports.findCircularSchemas = findCircularSchemas;
 exports.findDiscriminator = findDiscriminator;
 exports.httpMethods = httpMethods;
 exports.isInputNode = isInputNode;
@@ -2039,6 +2150,7 @@ exports.mediaTypes = mediaTypes;
 exports.mergeAdjacentObjects = mergeAdjacentObjects;
 exports.narrowSchema = narrowSchema;
 exports.nodeKinds = nodeKinds;
+exports.resolveRefName = resolveRefName;
 exports.schemaTypes = schemaTypes;
 exports.setDiscriminatorEnum = setDiscriminatorEnum;
 exports.setEnumName = setEnumName;