@kubb/ast 5.0.0-alpha.7 → 5.0.0-alpha.71

package/dist/index.d.ts

@@ -1,55 +1,3443 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { D as OperationNode, J as SchemaNodeByType, N as ParameterNode, O as ResponseNode, S as createSchema, T as RootNode, _ as createOperation, a as transform, at as httpMethods, b as createResponse, c as buildRefMap, ct as schemaTypes, h as definePrinter, i as collect, l as refMapToObject, o as walk, ot as mediaTypes, q as SchemaNode, st as nodeKinds, tt as PropertyNode, u as resolveRef, v as createParameter, x as createRoot, y as createProperty } from "./visitor-DagMPgGo.js";
 
+//#region src/constants.d.ts
+/**
+ * Traversal depth used by AST visitor utilities.
+ */
+type VisitorDepth = 'shallow' | 'deep';
+declare const nodeKinds: {
+  readonly input: "Input";
+  readonly output: "Output";
+  readonly operation: "Operation";
+  readonly schema: "Schema";
+  readonly property: "Property";
+  readonly parameter: "Parameter";
+  readonly response: "Response";
+  readonly functionParameter: "FunctionParameter";
+  readonly parameterGroup: "ParameterGroup";
+  readonly functionParameters: "FunctionParameters";
+  readonly type: "Type";
+  readonly file: "File";
+  readonly import: "Import";
+  readonly export: "Export";
+  readonly source: "Source";
+  readonly text: "Text";
+  readonly break: "Break";
+};
+/**
+ * Canonical schema type strings used by AST schema nodes.
+ *
+ * These values are used across the AST as stable discriminators
+ * (for example `schema.type === schemaTypes.object`).
+ *
+ * The map is grouped by intent:
+ * - primitives (`string`, `number`, `boolean`, ...)
+ * - structural/composite (`object`, `array`, `union`, ...)
+ * - special OpenAPI-oriented types (`ref`, `datetime`, `uuid`, ...)
+ */
+declare const schemaTypes: {
+  /**
+   * Text value.
+   */
+  readonly string: "string";
+  /**
+   * Floating-point number (`float`, `double`).
+   */
+  readonly number: "number";
+  /**
+   * Whole number (`int32`). Use `bigint` for `int64`.
+   */
+  readonly integer: "integer";
+  /**
+   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
+   */
+  readonly bigint: "bigint";
+  /**
+   * Boolean value
+   */
+  readonly boolean: "boolean";
+  /**
+   * Explicit null value.
+   */
+  readonly null: "null";
+  /**
+   * Any value (no type restriction).
+   */
+  readonly any: "any";
+  /**
+   * Unknown value (must be narrowed before usage).
+   */
+  readonly unknown: "unknown";
+  /**
+   * No return value (`void`).
+   */
+  readonly void: "void";
+  /**
+   * Object with named properties.
+   */
+  readonly object: "object";
+  /**
+   * Sequential list of items.
+   */
+  readonly array: "array";
+  /**
+   * Fixed-length list with position-specific items.
+   */
+  readonly tuple: "tuple";
+  /**
+   * "One of" multiple schema members.
+   */
+  readonly union: "union";
+  /**
+   * "All of" multiple schema members.
+   */
+  readonly intersection: "intersection";
+  /**
+   * Enum schema.
+   */
+  readonly enum: "enum";
+  /**
+   * Reference to another schema.
+   */
+  readonly ref: "ref";
+  /**
+   * Calendar date (for example `2026-03-24`).
+   */
+  readonly date: "date";
+  /**
+   * Date-time value (for example `2026-03-24T09:00:00Z`).
+   */
+  readonly datetime: "datetime";
+  /**
+   * Time-only value (for example `09:00:00`).
+   */
+  readonly time: "time";
+  /**
+   * UUID value.
+   */
+  readonly uuid: "uuid";
+  /**
+   * Email address value.
+   */
+  readonly email: "email";
+  /**
+   * URL value.
+   */
+  readonly url: "url";
+  /**
+   * IPv4 address value.
+   */
+  readonly ipv4: "ipv4";
+  /**
+   * IPv6 address value.
+   */
+  readonly ipv6: "ipv6";
+  /**
+   * Binary/blob value.
+   */
+  readonly blob: "blob";
+  /**
+   * Impossible value (`never`).
+   */
+  readonly never: "never";
+};
+type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean';
+/**
+ * Returns `true` when `type` is a scalar primitive schema type.
+ */
+declare function isScalarPrimitive(type: string): type is ScalarPrimitive;
+declare const httpMethods: {
+  readonly get: "GET";
+  readonly post: "POST";
+  readonly put: "PUT";
+  readonly patch: "PATCH";
+  readonly delete: "DELETE";
+  readonly head: "HEAD";
+  readonly options: "OPTIONS";
+  readonly trace: "TRACE";
+};
+declare const mediaTypes: {
+  readonly applicationJson: "application/json";
+  readonly applicationXml: "application/xml";
+  readonly applicationFormUrlEncoded: "application/x-www-form-urlencoded";
+  readonly applicationOctetStream: "application/octet-stream";
+  readonly applicationPdf: "application/pdf";
+  readonly applicationZip: "application/zip";
+  readonly applicationGraphql: "application/graphql";
+  readonly multipartFormData: "multipart/form-data";
+  readonly textPlain: "text/plain";
+  readonly textHtml: "text/html";
+  readonly textCsv: "text/csv";
+  readonly textXml: "text/xml";
+  readonly imagePng: "image/png";
+  readonly imageJpeg: "image/jpeg";
+  readonly imageGif: "image/gif";
+  readonly imageWebp: "image/webp";
+  readonly imageSvgXml: "image/svg+xml";
+  readonly audioMpeg: "audio/mpeg";
+  readonly videoMp4: "video/mp4";
+};
+//#endregion
+//#region src/nodes/base.d.ts
+/**
+ * `kind` values used by AST nodes.
+ *
+ * @example
+ * ```ts
+ * const kind: NodeKind = 'Schema'
+ * ```
+ */
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ParameterGroup' | 'FunctionParameters' | 'Type' | 'ParamsType' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
+/**
+ * Base shape shared by all AST nodes.
+ *
+ * @example
+ * ```ts
+ * const base: BaseNode = { kind: 'Input' }
+ * ```
+ */
+type BaseNode = {
+  /**
+   * Node discriminator.
+   */
+  kind: NodeKind;
+};
+//#endregion
+//#region src/nodes/code.d.ts
+/**
+ * JSDoc documentation metadata attached to code declarations.
+ */
+type JSDocNode = {
+  /**
+   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
+   * @example ['@description A pet resource', '@deprecated']
+   */
+  comments?: Array<string | undefined>;
+};
+/**
+ * AST node representing a TypeScript `const` declaration.
+ *
+ * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createConst({ name: 'pet', export: true, asConst: true })
+ * // export const pet = ... as const
+ * ```
+ */
+type ConstNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Const';
+  /**
+   * Name of the constant declaration.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * Optional explicit type annotation.
+   * @example 'Pet'
+   */
+  type?: string;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * Whether to append `as const` to the declaration.
+   * @default false
+   */
+  asConst?: boolean;
+  /**
+   * Child nodes representing the value of the constant (children of the `Const` component).
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `type` alias declaration.
+ *
+ * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
+ */
+type TypeNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Type';
+  /**
+   * Name of the type alias.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * Child nodes representing the type body (children of the `Type` component).
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * Convenience alias for {@link TypeNode}.
+ * @deprecated Use `TypeNode` directly.
+ */
+type TypeDeclarationNode = TypeNode;
+/**
+ * AST node representing a TypeScript `function` declaration.
+ *
+ * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createFunctionDeclaration({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function getPet(): Promise<Pet> { ... }
+ * ```
+ */
+type FunctionNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Function';
+  /**
+   * Name of the function.
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   * @default false
+   */
+  default?: boolean;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  params?: string;
+  /**
+   * Whether the function should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
+   * @default false
+   */
+  async?: boolean;
+  /**
+   * TypeScript generic type parameters.
+   * @example ['T', 'U extends string']
+   */
+  generics?: string | string[];
+  /**
+   * Return type annotation.
+   * @example 'Pet'
+   */
+  returnType?: string;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * Child nodes representing the function body (children of the `Function` component).
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createArrowFunctionDeclaration({ name: 'getPet', export: true, singleLine: true })
+ * // export const getPet = () => ...
+ * ```
+ */
+type ArrowFunctionNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'ArrowFunction';
+  /**
+   * Name of the arrow function (used as the `const` variable name).
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   * @default false
+   */
+  default?: boolean;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  params?: string;
+  /**
+   * Whether the arrow function should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
+   * @default false
+   */
+  async?: boolean;
+  /**
+   * TypeScript generic type parameters.
+   * @example ['T', 'U extends string']
+   */
+  generics?: string | string[];
+  /**
+   * Return type annotation.
+   * @example 'Pet'
+   */
+  returnType?: string;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * Render the arrow function body as a single-line expression.
+   * @default false
+   */
+  singleLine?: boolean;
+  /**
+   * Child nodes representing the function body (children of the `Function.Arrow` component).
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a raw text/string fragment in the source output.
+ *
+ * Used instead of bare `string` values so that all entries in `nodes` arrays
+ * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
+ */
+type TextNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Text';
+  /**
+   * The raw string content.
+   */
+  value: string;
+};
+/**
+ * AST node representing a line break in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. When printed, produces an empty
+ * string that — joined with `\n` by `printNodes` — creates a blank line
+ * between surrounding code nodes.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * // prints as '' → blank line when surrounded by other nodes
+ * ```
+ */
+type BreakNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Break';
+};
+/**
+ * AST node representing a raw JSX fragment in the source output.
+ *
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Use this to embed raw
+ * JSX/TSX 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</>' }
+ * ```
+ */
+type JsxNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Jsx';
+  /**
+   * The raw JSX string content.
+   */
+  value: string;
+};
+/**
+ * Union of all code-generation AST nodes.
+ *
+ * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
+ * structured children in {@link SourceNode.nodes}.
+ */
+type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
+//#endregion
+//#region src/nodes/file.d.ts
+/**
+ * Supported file extensions.
+ */
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type ImportName = string | Array<string | {
+  propertyName: string;
+  name?: string;
+}>;
+/**
+ * Represents a language-agnostic import/dependency declaration.
+ *
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * ```
+ *
+ * @example Default import (TypeScript: `import React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react' })
+ * ```
+ *
+ * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * ```
+ *
+ * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * ```
+ */
+type ImportNode = BaseNode & {
+  kind: 'Import';
+  /**
+   * Import name(s) to be used.
+   * @example ['useState']
+   * @example 'React'
+   */
+  name: ImportName;
+  /**
+   * Path for the import.
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Import entire module as namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates standard import
+   * @default false
+   */
+  isNameSpace?: boolean;
+  /**
+   * When set, the import path is resolved relative to this root.
+   */
+  root?: string;
+};
+/**
+ * Represents a language-agnostic export/public API declaration.
+ *
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
+ * ```ts
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
+ *
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * ```
+ *
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
+ * ```ts
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * ```
+ */
+type ExportNode = BaseNode & {
+  kind: 'Export';
+  /**
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   * @example ['useState']
+   * @example 'React'
+   */
+  name?: string | Array<string>;
+  /**
+   * Path for the export.
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   * @default false
+   */
+  asAlias?: boolean;
+};
+/**
+ * Represents a fragment of source code within a file.
+ *
+ * @example Named exportable source
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
+ * ```
+ *
+ * @example Inline unnamed code block
+ * ```ts
+ * createSource({ nodes: [createText('const x = 1')] })
+ * ```
+ */
+type SourceNode = BaseNode & {
+  kind: 'Source';
+  /**
+   * Optional name identifying this source (used for deduplication and barrel generation).
+   */
+  name?: string;
+  /**
+   * Mark this source as a type-only export.
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Include `export` keyword in the generated source.
+   * @default false
+   */
+  isExportable?: boolean;
+  /**
+   * Include this source in barrel/index file generation.
+   * @default false
+   */
+  isIndexable?: boolean;
+  /**
+   * Structured child nodes representing the content of this source fragment, in DOM order.
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * Represents a fully resolved file in the AST.
+ *
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id   = SHA256 hash of the path
+ * // file.name = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ */
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
+  /**
+   * Unique identifier derived from a SHA256 hash of the file path.
+   * @default hash
+   */
+  id: string;
+  /**
+   * File name without extension, derived from `baseName`.
+   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string;
+  /**
+   * File base name, including extension.
+   * Based on UNIX basename: `${name}${extname}`
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   */
+  baseName: `${string}.${string}`;
+  /**
+   * Full qualified path to the file.
+   */
+  path: string;
+  /**
+   * File extension extracted from `baseName`.
+   */
+  extname: Extname;
+  /**
+   * Deduplicated list of source code fragments.
+   */
+  sources: Array<SourceNode>;
+  /**
+   * Deduplicated list of import declarations.
+   */
+  imports: Array<ImportNode>;
+  /**
+   * Deduplicated list of export declarations.
+   */
+  exports: Array<ExportNode>;
+  /**
+   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
+   */
+  meta?: TMeta;
+  /**
+   * Optional banner prepended to the generated file content.
+   */
+  banner?: string;
+  /**
+   * Optional footer appended to the generated file content.
+   */
+  footer?: string;
+};
+//#endregion
+//#region src/nodes/function.d.ts
+/**
+ * AST node representing a language-agnostic type expression used as a function parameter
+ * type annotation. Each language printer renders the variant into its own syntax.
+ *
+ * - `struct` — an inline anonymous type grouping named fields.
+ *   TypeScript renders as `{ petId: string; name?: string }`.
+ * - `member` — a single named field accessed from a named group type.
+ *   TypeScript renders as `PathParams['petId']`.
+ *
+ * @example Reference variant
+ * ```ts
+ * createParamsType({ variant: 'reference', name: 'QueryParams' })
+ * // QueryParams
+ * ```
+ *
+ * @example Struct variant
+ * ```ts
+ * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
+ * // { petId: string }
+ * ```
+ *
+ * @example Member variant
+ * ```ts
+ * createParamsType({ variant: 'member', base: 'PathParams', key: 'petId' })
+ * // PathParams['petId']
+ * ```
+ */
+type ParamsTypeNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'ParamsType';
+} & ({
+  /**
+   * Reference variant — a plain type name or identifier.
+   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
+   */
+  variant: 'reference';
+  /**
+   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
+   */
+  name: string;
+} | {
+  /**
+   * Struct variant — an inline anonymous type grouping named fields.
+   * TypeScript renders as `{ key: Type; other?: OtherType }`.
+   */
+  variant: 'struct';
+  /**
+   * Properties of the struct type.
+   */
+  properties: Array<{
+    name: string;
+    optional: boolean;
+    type: ParamsTypeNode;
+  }>;
+} | {
+  /**
+   * Member variant — a single named field accessed from a group type.
+   * TypeScript renders as `Base['key']`.
+   */
+  variant: 'member';
+  /**
+   * Base type name, e.g. `'DeletePetPathParams'`.
+   */
+  base: string;
+  /**
+   * The field name to access, e.g. `'petId'`.
+   */
+  key: string;
+});
+/**
+ * AST node for one function parameter.
+ *
+ * @example Required parameter
+ * `name: Type`
+ *
+ * @example Optional parameter
+ * `name?: Type`
+ *
+ * @example Parameter with default value
+ * `name: Type = defaultValue`
+ *
+ * @example Rest parameter
+ * `...name: Type[]`
+ */
+type FunctionParameterNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'FunctionParameter';
+  /**
+   * Parameter name in the generated signature.
+   */
+  name: string;
+  /**
+   * Type annotation as a structured {@link ParamsTypeNode}.
+   * Omit for untyped output.
+   *
+   * @example Reference type node
+   * `{ kind: 'ParamsType', variant: 'reference', name: 'string' }` → `petId: string`
+   *
+   * @example Struct type node
+   * `{ kind: 'ParamsType', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
+   *
+   * @example Member type node
+   * `{ kind: 'ParamsType', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
+   */
+  type?: ParamsTypeNode;
+  /**
+   * When `true` the parameter is emitted as a rest parameter.
+   *
+   * @example Rest parameter
+   * `...name: Type[]`
+   */
+  rest?: boolean;
+}
+/**
+* Optional parameter — rendered with `?` and may be omitted by the caller.
+* Cannot be combined with `default` because a defaulted parameter is already optional.
+*/
+& ({
+  optional: true;
+  default?: never;
+}
+/**
+ * Required parameter, or a parameter with a default value.
+ *
+ * @example Required
+ * `name: Type`
+ *
+ * @example With default
+ * `name: Type = default`
+ */
+| {
+  optional?: false;
+  default?: string;
+});
+/**
+ * AST node for a group of related function parameters treated as a single unit.
+ *
+ * Each language printer decides how to render this group:
+ * - TypeScript/JS: destructured object `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}`
+ * - Python: keyword-only args or a typed dict parameter
+ * - C# / Kotlin: named record / data-class parameter
+ *
+ * When `inline` is `true`, the group is spread as individual top-level parameters
+ * rather than wrapped in a single grouped construct.
+ *
+ * @example Grouped destructuring
+ * `{ id, name }: { id: string; name: string } = {}`
+ *
+ * @example Inline (spread as individual parameters)
+ * `id: string, name: string`
+ */
+type ParameterGroupNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'ParameterGroup';
+  /**
+   * The individual parameters that form the group.
+   * Rendered as a destructured object or spread inline when `inline` is `true`.
+   */
+  properties: Array<FunctionParameterNode>;
+  /**
+   * Optional explicit type annotation for the whole group.
+   * When absent, printers auto-compute it from `properties`.
+   */
+  type?: ParamsTypeNode;
+  /**
+   * When `true`, `properties` are emitted as individual top-level parameters instead of
+   * being wrapped in a single grouped construct.
+   *
+   * @default false
+   */
+  inline?: boolean;
+  /**
+   * Whether the group as a whole is optional.
+   * If omitted, printers infer this from child properties.
+   */
+  optional?: boolean;
+  /**
+   * Default value for the group, written verbatim after `=`.
+   * Commonly `'{}'` to allow omitting the argument entirely.
+   */
+  default?: string;
+};
+/**
+ * AST node for a complete function parameter list.
+ *
+ * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
+ * Nodes are plain immutable data.
+ *
+ * Renders differently depending on the output mode:
+ * - `declaration` → `(id: string, config: Config = {})` — function declaration parameters
+ * - `call`        → `(id, { method, url })` — function call arguments
+ * - `keys`        → `{ id, config }` — key names only (for destructuring)
+ * - `values`      → `{ id: id, config: config }` — key → value pairs
+ */
+type FunctionParametersNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'FunctionParameters';
+  /**
+   * Ordered parameter nodes.
+   */
+  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
+};
+/**
+ * Union of all function-parameter AST node variants used by the function-parameter printer.
+ */
+type FunctionParamNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | ParamsTypeNode;
+/**
+ * Handler map keys — one per `FunctionParamNode` kind.
+ */
+type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'paramsType';
+//#endregion
+//#region src/nodes/property.d.ts
+/**
+ * AST node representing one named object property.
+ *
+ * @example
+ * ```ts
+ * const property: PropertyNode = {
+ *   kind: 'Property',
+ *   name: 'id',
+ *   schema: createSchema({ type: 'integer' }),
+ *   required: true,
+ * }
+ * ```
+ */
+type PropertyNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Property';
+  /**
+   * Property key.
+   */
+  name: string;
+  /**
+   * Property schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the property is required.
+   */
+  required: boolean;
+};
+//#endregion
+//#region src/nodes/schema.d.ts
+type PrimitiveSchemaType =
+/**
+ * Text value.
+ */
+'string'
+/**
+ * Floating-point number.
+ */
+| 'number'
+/**
+ * Integer number.
+ */
+| 'integer'
+/**
+ * Big integer number.
+ */
+| 'bigint'
+/**
+ * Boolean value.
+ */
+| 'boolean'
+/**
+ * Null value.
+ */
+| 'null'
+/**
+ * Any value.
+ */
+| 'any'
+/**
+ * Unknown value.
+ */
+| 'unknown'
+/**
+ * No value (`void`).
+ */
+| 'void'
+/**
+ * Never value.
+ */
+| 'never'
+/**
+ * Object value.
+ */
+| 'object'
+/**
+ * Array value.
+ */
+| 'array'
+/**
+ * Date value.
+ */
+| 'date';
+/**
+ * Composite schema types.
+ */
+type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
+/**
+ * Schema types that need special handling in generators.
+ */
+type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
+/**
+ * All schema type strings.
+ */
+type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+/**
+ * Scalar schema types without extra object/array/ref structure.
+ */
+type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+/**
+ * Fields shared by all schema nodes.
+ */
+type SchemaNodeBase = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Schema';
+  /**
+   * Schema name for named definitions (for example, `"Pet"`).
+   * Inline schemas omit this field.
+   * `null` means kubb has processed this and determined there is no applicable name.
+   * `undefined` means the name has not been set yet.
+   */
+  name?: string | null;
+  /**
+   * Short schema title.
+   */
+  title?: string;
+  /**
+   * Schema description text.
+   */
+  description?: string;
+  /**
+   * Whether `null` is allowed.
+   */
+  nullable?: boolean;
+  /**
+   * Whether the field is optional.
+   */
+  optional?: boolean;
+  /**
+   * Both optional and nullable (`optional` + `nullable`).
+   */
+  nullish?: boolean;
+  /**
+   * Whether the schema is deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Whether the schema is read-only.
+   */
+  readOnly?: boolean;
+  /**
+   * Whether the schema is write-only.
+   */
+  writeOnly?: boolean;
+  /**
+   * Default value.
+   */
+  default?: unknown;
+  /**
+   * Example value.
+   */
+  example?: unknown;
+  /**
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
+   */
+  primitive?: PrimitiveSchemaType;
+};
+/**
+ * Object schema with ordered properties.
+ *
+ * @example
+ * ```ts
+ * const objectSchema: ObjectSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'object',
+ *   properties: [],
+ * }
+ * ```
+ */
+type ObjectSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'object';
+  /**
+   * Primitive type — always `'object'` for object schemas.
+   */
+  primitive: 'object';
+  /**
+   * Ordered object properties.
+   */
+  properties: Array<PropertyNode>;
+  /**
+   * Additional object properties behavior:
+   * - `true`: allow any value
+   * - `false`: reject unknown properties (maps to `.strict()` in Zod)
+   * - `SchemaNode`: allow values that match that schema
+   * - `undefined`: no additional properties constraint (open object)
+   */
+  additionalProperties?: SchemaNode | boolean;
+  /**
+   * Pattern-based property schemas.
+   */
+  patternProperties?: Record<string, SchemaNode>;
+  /**
+   * Minimum number of properties allowed.
+   */
+  minProperties?: number;
+  /**
+   * Maximum number of properties allowed.
+   */
+  maxProperties?: number;
+};
+/**
+ * Array-like schema (`array` or `tuple`).
+ *
+ * @example
+ * ```ts
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
+ * }
+ * ```
+ */
+type ArraySchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator (`array` or `tuple`).
+   */
+  type: 'array' | 'tuple';
+  /**
+   * Item schemas.
+   */
+  items?: Array<SchemaNode>;
+  /**
+   * Tuple rest-item schema for elements beyond positional `items`.
+   */
+  rest?: SchemaNode;
+  /**
+   * Minimum item count (or tuple length).
+   */
+  min?: number;
+  /**
+   * Maximum item count (or tuple length).
+   */
+  max?: number;
+  /**
+   * Whether all items must be unique.
+   */
+  unique?: boolean;
+};
+/**
+ * Shared shape for union and intersection schemas.
+ */
+type CompositeSchemaNodeBase = SchemaNodeBase & {
+  /**
+   * Member schemas.
+   */
+  members?: Array<SchemaNode>;
+};
+/**
+ * Union schema, often from `oneOf` or `anyOf`.
+ *
+ * @example
+ * ```ts
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
+ * }
+ * ```
+ */
+type UnionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'union';
+  /**
+   * Discriminator property name from OpenAPI `discriminator.propertyName`.
+   */
+  discriminatorPropertyName?: string;
+  /**
+   * Logical strategy applied to union members: 'one' means exactly one member must be valid (from `oneOf`),
+   * 'any' means any number of members can be valid (from `anyOf`).
+   */
+  strategy?: 'one' | 'any';
+};
+/**
+ * Intersection schema, often from `allOf`.
+ *
+ * @example
+ * ```ts
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
+ * }
+ * ```
+ */
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'intersection';
+};
+/**
+ * One named enum item.
+ */
+type EnumValueNode = {
+  /**
+   * Enum item name.
+   */
+  name: string;
+  /**
+   * Enum item value.
+   */
+  value: string | number | boolean;
+  /**
+   * Primitive type of the enum value.
+   */
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
+};
+/**
+ * Enum schema node.
+ *
+ * @example
+ * ```ts
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
+ * }
+ * ```
+ */
+type EnumSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'enum';
+  /**
+   * Enum values in simple form.
+   */
+  enumValues?: Array<string | number | boolean | null>;
+  /**
+   * Enum values in named form.
+   * If present, this is used instead of `enumValues`.
+   */
+  namedEnumValues?: Array<EnumValueNode>;
+};
+/**
+ * Reference schema that points to another schema definition.
+ *
+ * @example
+ * ```ts
+ * const refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
+ * ```
+ */
+type RefSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ref';
+  /**
+   * Referenced schema name.
+   */
+  name?: string;
+  /**
+   * Original `$ref` path, for example, `#/components/schemas/Order`.
+   * Used to resolve names later.
+   */
+  ref?: string;
+  /**
+   * Pattern copied from a sibling `pattern` field.
+   */
+  pattern?: string;
+  /**
+   * The fully-parsed schema that this ref resolves to.
+   * Populated during OAS parsing when the referenced definition can be resolved.
+   * `undefined` when the ref cannot be resolved or is part of a circular chain.
+   *
+   * Useful for inspecting the referenced schema's structure (e.g. `primitive`, `properties`)
+   * without following the reference manually.
+   */
+  schema?: SchemaNode;
+};
+/**
+ * Datetime schema.
+ *
+ * @example
+ * ```ts
+ * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
+ * ```
+ */
+type DatetimeSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'datetime';
+  /**
+   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
+   */
+  offset?: boolean;
+  /**
+   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
+   */
+  local?: boolean;
+};
+/**
+ * Shared base for `date` and `time` schemas.
+ */
+type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: T;
+  /**
+   * Output representation in generated code.
+   */
+  representation: 'date' | 'string';
+};
+/**
+ * Date schema node.
+ *
+ * @example
+ * ```ts
+ * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
+ * ```
+ */
+type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
+/**
+ * Time schema node.
+ *
+ * @example
+ * ```ts
+ * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
+ * ```
+ */
+type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
+/**
+ * String schema node.
+ *
+ * @example
+ * ```ts
+ * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
+ * ```
+ */
+type StringSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'string';
+  /**
+   * Minimum string length.
+   */
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  max?: number;
+  /**
+   * Regex pattern.
+   */
+  pattern?: string;
+};
+/**
+ * Numeric schema (`number`, `integer`, or `bigint`).
+ *
+ * @example
+ * ```ts
+ * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
+ * ```
+ */
+type NumberSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'number' | 'integer' | 'bigint';
+  /**
+   * Minimum value.
+   */
+  min?: number;
+  /**
+   * Maximum value.
+   */
+  max?: number;
+  /**
+   * Exclusive minimum value.
+   */
+  exclusiveMinimum?: number;
+  /**
+   * Exclusive maximum value.
+   */
+  exclusiveMaximum?: number;
+  /**
+   * The value must be a multiple of this number.
+   */
+  multipleOf?: number;
+};
+/**
+ * Scalar schema with no extra constraints.
+ *
+ * @example
+ * ```ts
+ * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
+ * ```
+ */
+type ScalarSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: ScalarSchemaType;
+};
+/**
+ * URL schema node.
+ * Can include an OpenAPI-style path template for template literal types.
+ *
+ * @example
+ * ```ts
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
+ * ```
+ */
+type UrlSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'url';
+  /**
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
+   */
+  path?: string;
+  /**
+   * Minimum string length.
+   */
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  max?: number;
+};
+/**
+ * Format-string schema for string-based formats that support length constraints.
+ *
+ * @example
+ * ```ts
+ * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
+ * ```
+ */
+type FormatStringSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'uuid' | 'email';
+  /**
+   * Minimum string length.
+   */
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  max?: number;
+};
+/**
+ * IPv4 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
+ * ```
+ */
+type Ipv4SchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ipv4';
+};
+/**
+ * IPv6 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
+ * ```
+ */
+type Ipv6SchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ipv6';
+};
+/**
+ * Mapping from schema type literals to concrete schema node types.
+ * Used by `narrowSchema`.
+ */
+type SchemaNodeByType = {
+  object: ObjectSchemaNode;
+  array: ArraySchemaNode;
+  tuple: ArraySchemaNode;
+  union: UnionSchemaNode;
+  intersection: IntersectionSchemaNode;
+  enum: EnumSchemaNode;
+  ref: RefSchemaNode;
+  datetime: DatetimeSchemaNode;
+  date: DateSchemaNode;
+  time: TimeSchemaNode;
+  string: StringSchemaNode;
+  number: NumberSchemaNode;
+  integer: NumberSchemaNode;
+  bigint: NumberSchemaNode;
+  boolean: ScalarSchemaNode;
+  null: ScalarSchemaNode;
+  any: ScalarSchemaNode;
+  unknown: ScalarSchemaNode;
+  void: ScalarSchemaNode;
+  never: ScalarSchemaNode;
+  uuid: FormatStringSchemaNode;
+  email: FormatStringSchemaNode;
+  url: UrlSchemaNode;
+  ipv4: Ipv4SchemaNode;
+  ipv6: Ipv6SchemaNode;
+  blob: ScalarSchemaNode;
+};
+/**
+ * Union of all schema node types.
+ */
+type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | ScalarSchemaNode;
+//#endregion
+//#region src/nodes/parameter.d.ts
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+/**
+ * AST node representing one operation parameter.
+ *
+ * @example
+ * ```ts
+ * const param: ParameterNode = {
+ *   kind: 'Parameter',
+ *   name: 'petId',
+ *   in: 'path',
+ *   schema: createSchema({ type: 'string' }),
+ *   required: true,
+ * }
+ * ```
+ */
+type ParameterNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Parameter';
+  /**
+   * Parameter name.
+   */
+  name: string;
+  /**
+   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   */
+  in: ParameterLocation;
+  /**
+   * Parameter schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the parameter is required.
+   */
+  required: boolean;
+};
+//#endregion
+//#region src/nodes/http.d.ts
+/**
+ * All supported HTTP status code literals as strings, as used in API specs
+ * (for example, `"200"` and `"404"`).
+ */
+type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
+/**
+ * Response status code literal used by operations.
+ *
+ * Includes specific HTTP status code strings and `"default"` for catch-all responses.
+ *
+ * @example
+ * ```ts
+ * const status: StatusCode = '200'
+ * const fallback: StatusCode = 'default'
+ * ```
+ */
+type StatusCode = HttpStatusCode | 'default';
+/**
+ * Supported media type strings used in request and response bodies.
+ *
+ * @example
+ * ```ts
+ * const mediaType: MediaType = 'application/json'
+ * ```
+ */
+type MediaType = 'application/json' | 'application/xml' | 'application/x-www-form-urlencoded' | 'application/octet-stream' | 'application/pdf' | 'application/zip' | 'application/graphql' | 'multipart/form-data' | 'text/plain' | 'text/html' | 'text/csv' | 'text/xml' | 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp' | 'image/svg+xml' | 'audio/mpeg' | 'video/mp4';
+//#endregion
+//#region src/nodes/response.d.ts
+/**
+ * AST node representing one operation response variant.
+ *
+ * @example
+ * ```ts
+ * const response: ResponseNode = {
+ *   kind: 'Response',
+ *   statusCode: '200',
+ *   schema: createSchema({ type: 'string' }),
+ * }
+ * ```
+ */
+type ResponseNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Response';
+  /**
+   * HTTP status code or `'default'` for a fallback response.
+   */
+  statusCode: StatusCode;
+  /**
+   * Optional response description.
+   */
+  description?: string;
+  /**
+   * Response body schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Response media type.
+   */
+  mediaType?: MediaType | null;
+  /**
+   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+   * Set when a referenced schema has `writeOnly` fields that should not appear in response types.
+   */
+  keysToOmit?: Array<string>;
+};
+//#endregion
+//#region src/nodes/operation.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
+/**
+ * AST node representing one API operation.
+ *
+ * @example
+ * ```ts
+ * const operation: OperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
+ * ```
+ */
+type OperationNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Operation';
+  /**
+   * Operation identifier, usually from OpenAPI `operationId`.
+   */
+  operationId: string;
+  /**
+   * HTTP Method like 'GET'
+   */
+  method: HttpMethod;
+  /**
+   * OpenAPI-style path string, for example `/pets/{petId}`.
+   * Path parameters retain the `{param}` notation from the original spec.
+   */
+  path: string;
+  /**
+   * Group labels for the operation.
+   * Usually copied from OpenAPI `tags`.
+   */
+  tags: Array<string>;
+  /**
+   * Short one-line operation summary.
+   */
+  summary?: string;
+  /**
+   * Full operation description.
+   */
+  description?: string;
+  /**
+   * Marks the operation as deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   */
+  parameters: Array<ParameterNode>;
+  /**
+   * Request body metadata for the operation.
+   */
+  requestBody?: {
+    /**
+     * Human-readable request body description.
+     */
+    description?: string;
+    /**
+     * Whether the request body is required (`requestBody.required: true` in the spec).
+     * When `false` or absent, the generated `data` parameter should be optional.
+     */
+    required?: boolean;
+    /**
+     * All available content type entries for this request body.
+     *
+     * When the adapter `contentType` option is set, this array contains exactly one entry for
+     * that content type. Otherwise it contains one entry per content type declared in the spec,
+     * so that plugins can generate code for every variant (e.g. separate hooks for
+     * `application/json` and `multipart/form-data`).
+     *
+     * @example
+     * ```ts
+     * // spec has both application/json and multipart/form-data
+     * requestBody.content[0].contentType // 'application/json'
+     * requestBody.content[1].contentType // 'multipart/form-data'
+     * ```
+     */
+    content?: Array<{
+      /**
+       * The content type for this entry (e.g. `'application/json'`).
+       */
+      contentType: string;
+      /**
+       * Request body schema for this content type.
+       */
+      schema?: SchemaNode;
+      /**
+       * Property keys to exclude from the generated request body type via `Omit<Type, Keys>`.
+       * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
+       */
+      keysToOmit?: Array<string>;
+    }>;
+  };
+  /**
+   * Operation responses.
+   */
+  responses: Array<ResponseNode>;
+};
+//#endregion
+//#region src/nodes/output.d.ts
+/**
+ * Output AST node that groups all generated file output for one API document.
+ *
+ * Produced by generators and consumed by the build pipeline to write files.
+ *
+ * @example
+ * ```ts
+ * const output: OutputNode = {
+ *   kind: 'Output',
+ *   files: [],
+ * }
+ * ```
+ */
+type OutputNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Output';
+  /**
+   * Generated file nodes.
+   */
+  files: Array<FileNode>;
+};
+//#endregion
+//#region src/nodes/root.d.ts
+/**
+ * Basic metadata for an API document.
+ * Adapters fill fields that exist in their source format.
+ *
+ * @example
+ * ```ts
+ * const meta: InputMeta = { title: 'Pet API', version: '1.0.0' }
+ * ```
+ */
+type InputMeta = {
+  /**
+   * API title (from `info.title` in OAS/AsyncAPI).
+   */
+  title?: string;
+  /**
+   * API description (from `info.description` in OAS/AsyncAPI).
+   */
+  description?: string;
+  /**
+   * API version string (from `info.version` in OAS/AsyncAPI).
+   */
+  version?: string;
+  /**
+   * Resolved API base URL.
+   * For OpenAPI and AsyncAPI, this comes from the selected server URL.
+   */
+  baseURL?: string;
+};
+/**
+ * Input AST node that contains all schemas and operations for one API document.
+ * Produced by the adapter and consumed by all Kubb plugins.
+ *
+ * @example
+ * ```ts
+ * const input: InputNode = {
+ *   kind: 'Input',
+ *   schemas: [],
+ *   operations: [],
+ * }
+ * ```
+ */
+type InputNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Input';
+  /**
+   * All schema nodes in the document.
+   */
+  schemas: Array<SchemaNode>;
+  /**
+   * All operation nodes in the document.
+   */
+  operations: Array<OperationNode>;
+  /**
+   * Optional document metadata populated by the adapter.
+   */
+  meta?: InputMeta;
+};
+//#endregion
+//#region src/nodes/index.d.ts
+/**
+ * Union of all AST node types.
+ *
+ * This lets TypeScript narrow types in `switch (node.kind)` blocks.
+ *
+ * @example
+ * ```ts
+ * function getKind(node: Node): string {
+ *   switch (node.kind) {
+ *     case 'Input':
+ *       return 'input'
+ *     case 'Output':
+ *       return 'output'
+ *     default:
+ *       return 'other'
+ *   }
+ * }
+ * ```
+ */
+type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | ParamsTypeNode | FunctionNode | ArrowFunctionNode;
+//#endregion
+//#region src/infer.d.ts
+/**
+ * Shared parser options used by OAS-to-AST inference and parser flows.
+ */
+type ParserOptions = {
+  /**
+   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
+   */
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  /**
+   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
+   */
+  integerType?: 'number' | 'bigint';
+  /**
+   * AST type used when no schema type can be inferred.
+   */
+  unknownType: 'any' | 'unknown' | 'void';
+  /**
+   * AST type used for completely empty schemas (`{}`).
+   */
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  /**
+   * Suffix appended to derived enum names when building property schema names.
+   */
+  enumSuffix: 'enum' | (string & {});
+};
+/**
+ * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
+ */
+type DateTimeNodeByDateType = {
+  date: DateSchemaNode;
+  string: DatetimeSchemaNode;
+  stringOffset: DatetimeSchemaNode;
+  stringLocal: DatetimeSchemaNode;
+  false: StringSchemaNode;
+};
+/**
+ * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
+ */
+type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
+/**
+ * Ordered list of `[schema-shape, SchemaNode]` pairs.
+ * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
+ */
+type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
+  $ref: string;
+}, RefSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+  properties: object;
+}, IntersectionSchemaNode], [{
+  allOf: readonly [unknown, unknown, ...unknown[]];
+}, IntersectionSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+}, SchemaNode], [{
+  oneOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  anyOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  const: null;
+}, ScalarSchemaNode], [{
+  const: string | number | boolean;
+}, EnumSchemaNode], [{
+  type: ReadonlyArray<string>;
+}, UnionSchemaNode], [{
+  type: 'array';
+  enum: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  enum: ReadonlyArray<unknown>;
+}, EnumSchemaNode], [{
+  type: 'enum';
+}, EnumSchemaNode], [{
+  type: 'union';
+}, UnionSchemaNode], [{
+  type: 'intersection';
+}, IntersectionSchemaNode], [{
+  type: 'tuple';
+}, ArraySchemaNode], [{
+  type: 'ref';
+}, RefSchemaNode], [{
+  type: 'datetime';
+}, DatetimeSchemaNode], [{
+  type: 'date';
+}, DateSchemaNode], [{
+  type: 'time';
+}, TimeSchemaNode], [{
+  type: 'url';
+}, UrlSchemaNode], [{
+  type: 'object';
+}, ObjectSchemaNode], [{
+  additionalProperties: boolean | {};
+}, ObjectSchemaNode], [{
+  type: 'array';
+}, ArraySchemaNode], [{
+  items: object;
+}, ArraySchemaNode], [{
+  prefixItems: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  type: string;
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  type: string;
+  format: 'date';
+}, DateSchemaNode], [{
+  type: string;
+  format: 'time';
+}, TimeSchemaNode], [{
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  format: 'date';
+}, DateSchemaNode], [{
+  format: 'time';
+}, TimeSchemaNode], [{
+  type: 'string';
+}, StringSchemaNode], [{
+  type: 'number';
+}, NumberSchemaNode], [{
+  type: 'integer';
+}, NumberSchemaNode], [{
+  type: 'bigint';
+}, NumberSchemaNode], [{
+  type: string;
+}, ScalarSchemaNode], [{
+  minLength: number;
+}, StringSchemaNode], [{
+  maxLength: number;
+}, StringSchemaNode], [{
+  pattern: string;
+}, StringSchemaNode], [{
+  minimum: number;
+}, NumberSchemaNode], [{
+  maximum: number;
+}, NumberSchemaNode]];
+/**
+ * Infers the matching AST `SchemaNode` type from an input schema shape.
+ */
+type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>] ? TSchema extends TEntry[0] ? TEntry[1] : InferSchemaNode<TSchema, TDateType, TRest> : SchemaNode;
+/**
+ * Backward-compatible alias for `InferSchemaNode`.
+ */
+type InferSchema<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = InferSchemaNode<TSchema, TDateType, TEntries>;
+//#endregion
+//#region src/factory.d.ts
+/**
+ * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ *
+ * - `optional` is set for non-required, non-nullable schemas.
+ * - `nullish` is set for non-required, nullable schemas.
+ */
+declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
+/**
+ * Distributive `Omit` that preserves each member of a union.
+ *
+ * @example
+ * ```ts
+ * type A = { kind: 'a'; keep: string; drop: number }
+ * type B = { kind: 'b'; keep: boolean; drop: number }
+ * type Result = DistributiveOmit<A | B, 'drop'>
+ * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
+ * ```
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & {
+  properties?: Array<PropertyNode>;
+  primitive?: 'object';
+};
+type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>;
+type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
+  kind: 'Schema';
+};
+/**
+ * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
+ *
+ * @example
+ * ```ts
+ * const input = createInput()
+ * // { kind: 'Input', schemas: [], operations: [] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const input = createInput({ schemas: [petSchema] })
+ * // keeps default operations: []
+ * ```
+ */
+declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
+/**
+ * Creates an `OutputNode` with a stable default for `files`.
+ *
+ * @example
+ * ```ts
+ * const output = createOutput()
+ * // { kind: 'Output', files: [] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const output = createOutput({ files: [petFile] })
+ * ```
+ */
+declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): OutputNode;
+/**
+ * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+ *
+ * @example
+ * ```ts
+ * const operation = createOperation({
+ *   operationId: 'getPetById',
+ *   method: 'GET',
+ *   path: '/pet/{petId}',
+ * })
+ * // tags, parameters, and responses are []
+ * ```
+ *
+ * @example
+ * ```ts
+ * const operation = createOperation({
+ *   operationId: 'findPets',
+ *   method: 'GET',
+ *   path: '/pet/findByStatus',
+ *   tags: ['pet'],
+ * })
+ * ```
+ */
+declare function createOperation(props: Pick<OperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<OperationNode, 'kind' | 'operationId' | 'method' | 'path'>>): OperationNode;
+/**
+ * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
+ * For object schemas, `properties` defaults to an empty array.
+ * `primitive` is automatically inferred from `type` when not explicitly provided.
+ *
+ * @example
+ * ```ts
+ * const scalar = createSchema({ type: 'string' })
+ * // { kind: 'Schema', type: 'string', primitive: 'string' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const uuid = createSchema({ type: 'uuid' })
+ * // { kind: 'Schema', type: 'uuid', primitive: 'string' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const object = createSchema({ type: 'object' })
+ * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const enumSchema = createSchema({
+ *   type: 'enum',
+ *   primitive: 'string',
+ *   enumValues: ['available', 'pending'],
+ * })
+ * ```
+ */
+declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
+declare function createSchema(props: CreateSchemaInput): SchemaNode;
+type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
+/**
+ * Creates a `PropertyNode`.
+ *
+ * `required` defaults to `false`.
+ * `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
+ *
+ * @example
+ * ```ts
+ * const property = createProperty({
+ *   name: 'status',
+ *   schema: createSchema({ type: 'string' }),
+ * })
+ * // required=false, schema.optional=true
+ * ```
+ *
+ * @example
+ * ```ts
+ * const property = createProperty({
+ *   name: 'status',
+ *   required: true,
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=true, no optional/nullish
+ * ```
+ */
+declare function createProperty(props: UserPropertyNode): PropertyNode;
+/**
+ * Creates a `ParameterNode`.
+ *
+ * `required` defaults to `false`.
+ * Nested schema flags are set from `required` and `schema.nullable`.
+ *
+ * @example
+ * ```ts
+ * const param = createParameter({
+ *   name: 'petId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: createSchema({ type: 'string' }),
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * const param = createParameter({
+ *   name: 'status',
+ *   in: 'query',
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=false, schema.nullish=true
+ * ```
+ */
+declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>): ParameterNode;
+/**
+ * Creates a `ResponseNode`.
+ *
+ * @example
+ * ```ts
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   description: 'Success',
+ *   schema: createSchema({ type: 'object', properties: [] }),
+ * })
+ * ```
+ */
+declare function createResponse(props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>): ResponseNode;
+/**
+ * Creates a `FunctionParameterNode`.
+ *
+ * `optional` defaults to `false`.
+ *
+ * @example Required typed param
+ * ```ts
+ * createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
+ * // → petId: string
+ * ```
+ *
+ * @example Optional param
+ * ```ts
+ * createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
+ * // → params?: QueryParams
+ * ```
+ *
+ * @example Param with default (implicitly optional; cannot combine with `optional: true`)
+ * ```ts
+ * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
+ * // → config: RequestConfig = {}
+ * ```
+ */
+declare function createFunctionParameter(props: {
+  name: string;
+  type?: ParamsTypeNode;
+  rest?: boolean;
+} & ({
+  optional: true;
+  default?: never;
+} | {
+  optional?: false;
+  default?: string;
+})): FunctionParameterNode;
+/**
+ * Creates a {@link TypeNode} representing a language-agnostic structured type expression.
+ *
+ * Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
+ * named field accessed from a group type. Each language's printer renders the variant
+ * into its own syntax (TypeScript, Python, C#, Kotlin, …).
+ *
+ * @example Reference type (TypeScript: `QueryParams`)
+ * ```ts
+ * createParamsType({ variant: 'reference', name: 'QueryParams' })
+ * ```
+ *
+ * @example Struct type (TypeScript: `{ petId: string }`)
+ * ```ts
+ * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
+ * ```
+ *
+ * @example Member type (TypeScript: `DeletePetPathParams['petId']`)
+ * ```ts
+ * createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
+ * ```
+ */
+declare function createParamsType(props: {
+  variant: 'reference';
+  name: string;
+} | {
+  variant: 'struct';
+  properties: Array<{
+    name: string;
+    optional: boolean;
+    type: ParamsTypeNode;
+  }>;
+} | {
+  variant: 'member';
+  base: string;
+  key: string;
+}): ParamsTypeNode;
+/**
+ * Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
+ *
+ * @example Grouped param (TypeScript declaration)
+ * ```ts
+ * createParameterGroup({
+ *   properties: [
+ *     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
+ *   ],
+ *   default: '{}',
+ * })
+ * // declaration → { id, name? }: { id: string; name?: string } = {}
+ * // call        → { id, name }
+ * ```
+ *
+ * @example Inline (spread) — children emitted as individual top-level parameters
+ * ```ts
+ * createParameterGroup({
+ *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
+ *   inline: true,
+ * })
+ * // declaration → petId: string
+ * // call        → petId
+ * ```
+ */
+declare function createParameterGroup(props: Pick<ParameterGroupNode, 'properties'> & Partial<Omit<ParameterGroupNode, 'kind' | 'properties'>>): ParameterGroupNode;
+/**
+ * Creates a `FunctionParametersNode` from an ordered list of parameters.
+ *
+ * @example
+ * ```ts
+ * createFunctionParameters({
+ *   params: [
+ *     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
+ *   ],
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * const empty = createFunctionParameters()
+ * // { kind: 'FunctionParameters', params: [] }
+ * ```
+ */
+declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+/**
+ * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+ *
+ * @example Named import
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * // import { useState } from 'react'
+ * ```
+ *
+ * @example Type-only import
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * // import type { FC } from 'react'
+ * ```
+ */
+declare function createImport(props: Omit<ImportNode, 'kind'>): ImportNode;
+/**
+ * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+ *
+ * @example Named export
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet' })
+ * // export { Pet } from './Pet'
+ * ```
+ *
+ * @example Wildcard export
+ * ```ts
+ * createExport({ path: './utils' })
+ * // export * from './utils'
+ * ```
+ */
+declare function createExport(props: Omit<ExportNode, 'kind'>): ExportNode;
+/**
+ * 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 })
+ * ```
+ */
+declare function createSource(props: Omit<SourceNode, 'kind'>): SourceNode;
+type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
+/**
+ * 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'
+ * ```
+ */
+declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
+/**
+ * Creates a `ConstNode` representing a TypeScript `const` declaration.
+ *
+ * Mirrors the `Const` component from `@kubb/renderer-jsx`.
+ * The component's `children` are represented as `nodes`.
+ *
+ * @example Simple constant
+ * ```ts
+ * createConst({ name: 'pet' })
+ * // const pet = ...
+ * ```
+ *
+ * @example Exported constant with type and `as const`
+ * ```ts
+ * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+ * // export const pets: Pet[] = ... as const
+ * ```
+ *
+ * @example With JSDoc and child nodes
+ * ```ts
+ * createConst({
+ *   name: 'config',
+ *   export: true,
+ *   JSDoc: { comments: ['@description App configuration'] },
+ *   nodes: [],
+ * })
+ * ```
+ */
+declare function createConst(props: Omit<ConstNode, 'kind'>): ConstNode;
+/**
+ * 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 = ...
+ * ```
+ */
+declare function createType(props: Omit<TypeNode, 'kind'>): TypeNode;
+/**
+ * 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 { ... }
+ * ```
+ */
+declare function createFunction(props: Omit<FunctionNode, 'kind'>): FunctionNode;
+/**
+ * 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> => { ... }
+ * ```
+ */
+declare function createArrowFunction(props: Omit<ArrowFunctionNode, 'kind'>): ArrowFunctionNode;
+/**
+ * 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)' }
+ * ```
+ */
+declare function createText(value: string): TextNode;
+/**
+ * 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' }
+ * ```
+ */
+declare function createBreak(): BreakNode;
+/**
+ * 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</>' }
+ * ```
+ */
+declare function createJsx(value: string): JsxNode;
+//#endregion
 //#region src/guards.d.ts
 /**
- * Narrows a `SchemaNode` to the specific variant matching `type`.
+ * Narrows a `SchemaNode` to the variant that matches `type`.
+ *
+ * @example
+ * ```ts
+ * const schema = createSchema({ type: 'string' })
+ * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+ * ```
  */
 declare function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | undefined;
 /**
- * Type guard for `RootNode`.
+ * Returns `true` when the input is an `InputNode`.
+ *
+ * @example
+ * ```ts
+ * if (isInputNode(node)) {
+ *   console.log(node.schemas.length)
+ * }
+ * ```
+ */
+declare const isInputNode: (node: unknown) => node is InputNode;
+/**
+ * Returns `true` when the input is an `OutputNode`.
+ *
+ * @example
+ * ```ts
+ * if (isOutputNode(node)) {
+ *   console.log(node.files.length)
+ * }
+ * ```
  */
-declare const isRootNode: (node: unknown) => node is RootNode;
+declare const isOutputNode: (node: unknown) => node is OutputNode;
 /**
- * Type guard for `OperationNode`.
+ * Returns `true` when the input is an `OperationNode`.
+ *
+ * @example
+ * ```ts
+ * if (isOperationNode(node)) {
+ *   console.log(node.operationId)
+ * }
+ * ```
  */
 declare const isOperationNode: (node: unknown) => node is OperationNode;
 /**
- * Type guard for `SchemaNode`.
+ * Returns `true` when the input is a `SchemaNode`.
+ *
+ * @example
+ * ```ts
+ * if (isSchemaNode(node)) {
+ *   console.log(node.type)
+ * }
+ * ```
  */
 declare const isSchemaNode: (node: unknown) => node is SchemaNode;
+//#endregion
+//#region src/printer.d.ts
 /**
- * Type guard for `PropertyNode`.
+ * Runtime context passed as `this` to printer handlers.
+ *
+ * `this.transform` dispatches to node-level handlers from `nodes`.
+ *
+ * @example
+ * ```ts
+ * const context: PrinterHandlerContext<string, {}> = {
+ *   options: {},
+ *   transform: () => 'value',
+ * }
+ * ```
  */
-declare const isPropertyNode: (node: unknown) => node is PropertyNode;
+type PrinterHandlerContext<TOutput, TOptions extends object> = {
+  /**
+   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
+   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
+   */
+  transform: (node: SchemaNode) => TOutput | null | undefined;
+  /**
+   * Options for this printer instance.
+   */
+  options: TOptions;
+};
 /**
- * Type guard for `ParameterNode`.
+ * Handler for one schema node type.
+ *
+ * Use a regular function (not an arrow function) if you need `this`.
+ *
+ * @example
+ * ```ts
+ * const handler: PrinterHandler<string, {}, 'string'> = function () {
+ *   return 'string'
+ * }
+ * ```
  */
-declare const isParameterNode: (node: unknown) => node is ParameterNode;
+type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null | undefined;
 /**
- * Type guard for `ResponseNode`.
+ * Partial map of per-node-type handler overrides for a printer.
+ *
+ * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
+ * Supply only the handlers you want to replace; the printer's built-in
+ * defaults fill in the rest.
+ *
+ * @example
+ * ```ts
+ * pluginZod({
+ *   printer: {
+ *     nodes: {
+ *       date(): string {
+ *         return 'z.string().date()'
+ *       },
+ *     } satisfies PrinterPartial<string, PrinterZodOptions>,
+ *   },
+ * })
+ * ```
+ */
+type PrinterPartial<TOutput, TOptions extends object> = Partial<{ [K in SchemaType]: PrinterHandler<TOutput, TOptions, K> }>;
+/**
+ * Generic shape used by `definePrinter`.
+ *
+ * - `TName`        — unique string identifier (e.g. `'zod'`, `'ts'`)
+ * - `TOptions`     — options passed to and stored on the printer instance
+ * - `TOutput`      — the type emitted by node handlers
+ * - `TPrintOutput` — type returned by public `print` (defaults to `TOutput`)
+ *
+ * @example
+ * ```ts
+ * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
+ * ```
+ */
+type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
+  name: TName;
+  options: TOptions;
+  output: TOutput;
+  printOutput: TPrintOutput;
+};
+/**
+ * Printer instance returned by a printer factory.
+ *
+ * @example
+ * ```ts
+ * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
+ * ```
+ */
+type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
+  /**
+   * Unique identifier supplied at creation time.
+   */
+  name: T['name'];
+  /**
+   * Options for this printer instance.
+   */
+  options: T['options'];
+  /**
+   * Node-level dispatcher — converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
+   * Always dispatches through the `nodes` map; never calls the `print` override.
+   * Use this when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
+   */
+  transform: (node: SchemaNode) => T['output'] | null | undefined;
+  /**
+   * Public printer. If the builder provides a root-level `print`, this calls that
+   * higher-level function (which may produce full declarations).
+   * Otherwise, falls back to the node-level dispatcher.
+   */
+  print: (node: SchemaNode) => T['printOutput'] | null | undefined;
+};
+/**
+ * Builder function passed to `definePrinter`.
+ *
+ * It receives resolved options and returns:
+ * - `name`
+ * - `options`
+ * - `nodes` handlers
+ * - optional top-level `print` override
+ *
+ * @example
+ * ```ts
+ * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
+ * ```
+ */
+type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
+  name: T['name'];
+  /**
+   * Options to store on the printer.
+   */
+  options: T['options'];
+  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K> }>;
+  /**
+   * Optional root-level print override. When provided, becomes the public `printer.print`.
+   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
+   * not the override itself — so recursion is safe.
+   */
+  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
+};
+/**
+ * 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} })`
+ *     },
+ *   },
+ * }))
+ * ```
+ */
+declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
+/**
+ * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
+ **
+ * @example
+ * ```ts
+ * export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
+ *   (node) => kindToHandlerKey[node.kind],
+ * )
+ * ```
+ */
+declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | undefined): <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
+  name: T["name"];
+  options: T["options"];
+  nodes: Partial<{ [K in TKey]: (this: {
+    transform: (node: TNode) => T["output"] | null | undefined;
+    options: T["options"];
+  }, node: TNodeByKey[K]) => T["output"] | null | undefined }>;
+  print?: (this: {
+    transform: (node: TNode) => T["output"] | null | undefined;
+    options: T["options"];
+  }, node: TNode) => T["printOutput"] | null | undefined;
+}) => (options?: T["options"]) => {
+  name: T["name"];
+  options: T["options"];
+  transform: (node: TNode) => T["output"] | null | undefined;
+  print: (node: TNode) => T["printOutput"] | null | undefined;
+};
+//#endregion
+//#region src/refs.d.ts
+/**
+ * Lookup map from schema name to `SchemaNode`.
+ */
+type RefMap = Map<string, SchemaNode>;
+/**
+ * Returns the last path segment of a reference string.
+ *
+ * Example: `#/components/schemas/Pet` becomes `Pet`.
+ *
+ * @example
+ * ```ts
+ * extractRefName('#/components/schemas/Pet') // 'Pet'
+ * ```
+ */
+declare function extractRefName(ref: string): string;
+//#endregion
+//#region src/resolvers.d.ts
+declare function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | null;
+declare function childName(parentName: string | null | undefined, propName: string): string | null;
+declare function enumPropName(parentName: string | null | undefined, propName: string, enumSuffix: string): string;
+/**
+ * Collects import entries for all `ref` schema nodes in `node`.
+ */
+declare function collectImports<TImport>({
+  node,
+  nameMapping,
+  resolve
+}: {
+  node: SchemaNode;
+  nameMapping: Map<string, string>;
+  resolve: (schemaName: string) => TImport | undefined;
+}): Array<TImport>;
+//#endregion
+//#region src/transformers.d.ts
+/**
+ * Replaces a discriminator property's schema with a string enum of allowed values.
+ *
+ * If `node` is not an object schema, or if the property does not exist, the input
+ * node is returned as-is.
+ *
+ * @example
+ * ```ts
+ * const schema = createSchema({
+ *   type: 'object',
+ *   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
+ * })
+ * const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
+ * ```
+ */
+declare function setDiscriminatorEnum({
+  node,
+  propertyName,
+  values,
+  enumName
+}: {
+  node: SchemaNode;
+  propertyName: string;
+  values: Array<string>;
+  enumName?: string;
+}): SchemaNode;
+/**
+ * Merges adjacent anonymous object members into a single anonymous object member.
+ *
+ * @example
+ * ```ts
+ * const merged = mergeAdjacentObjects([
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
+ * ])
+ * ```
+ */
+declare function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode>;
+/**
+ * Removes enum members that are covered by broader scalar primitives in the same union.
+ *
+ * @example
+ * ```ts
+ * const simplified = simplifyUnion([
+ *   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
+ *   createSchema({ type: 'string' }),
+ * ])
+ * // keeps only string member
+ * ```
+ */
+declare function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode>;
+declare function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode;
+//#endregion
+//#region src/visitor.d.ts
+/**
+ * Ordered mapping of `[NodeType, ParentType]` pairs.
+ *
+ * `ParentOf` uses this map to find parent types.
+ */
+type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [OperationNode, InputNode], [SchemaNode, InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
+/**
+ * Resolves the parent node type for a given AST node type.
+ *
+ * This is used by visitor context so `ctx.parent` is correctly typed
+ * for each callback.
+ *
+ * @example
+ * ```ts
+ * type InputParent = ParentOf<InputNode>
+ * // undefined
+ * ```
+ *
+ * @example
+ * ```ts
+ * type PropertyParent = ParentOf<PropertyNode>
+ * // SchemaNode
+ * ```
+ *
+ * @example
+ * ```ts
+ * type SchemaParent = ParentOf<SchemaNode>
+ * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
+ * ```
+ */
+type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [infer TEntry extends [Node, unknown], ...infer TRest extends ReadonlyArray<[Node, unknown]>] ? T extends TEntry[0] ? TEntry[1] : ParentOf<T, TRest> : Node;
+/**
+ * Traversal context passed as the second argument to every visitor callback.
+ * `parent` is typed from the current node type.
+ *
+ * @example
+ * ```ts
+ * const visitor: Visitor = {
+ *   schema(node, { parent }) {
+ *     // parent type is narrowed by node kind
+ *   },
+ * }
+ * ```
+ */
+type VisitorContext<T extends Node = Node> = {
+  /**
+   * Parent node of the currently visited node.
+   * For `InputNode`, this is `undefined`.
+   */
+  parent?: ParentOf<T>;
+};
+/**
+ * Synchronous visitor used by `transform`.
+ *
+ * @example
+ * ```ts
+ * const visitor: Visitor = {
+ *   operation(node) {
+ *     return { ...node, operationId: `x_${node.operationId}` }
+ *   },
+ * }
+ * ```
+ */
+type Visitor = {
+  input?(node: InputNode, context: VisitorContext<InputNode>): void | InputNode;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): void | OutputNode;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): void | OperationNode;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): void | SchemaNode;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): void | PropertyNode;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): void | ParameterNode;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): void | ResponseNode;
+};
+/**
+ * Utility type for values that can be returned directly or asynchronously.
+ */
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
+ *
+ * @example
+ * ```ts
+ * const visitor: AsyncVisitor = {
+ *   async operation(node) {
+ *     await Promise.resolve(node.operationId)
+ *   },
+ * }
+ * ```
  */
-declare const isResponseNode: (node: unknown) => node is ResponseNode;
+type AsyncVisitor = {
+  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<void | InputNode>;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<void | OutputNode>;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<void | OperationNode>;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<void | SchemaNode>;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<void | PropertyNode>;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<void | ParameterNode>;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<void | ResponseNode>;
+};
+/**
+ * Visitor used by `collect`.
+ *
+ * @example
+ * ```ts
+ * const visitor: CollectVisitor<string> = {
+ *   operation(node) {
+ *     return node.operationId
+ *   },
+ * }
+ * ```
+ */
+type CollectVisitor<T> = {
+  input?(node: InputNode, context: VisitorContext<InputNode>): T | undefined;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | undefined;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | undefined;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | undefined;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | undefined;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | undefined;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | undefined;
+};
+/**
+ * Options for `transform`.
+ *
+ * @example
+ * ```ts
+ * const options: TransformOptions = { depth: 'deep', schema: (node) => node }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Only transform the current node, not nested children
+ * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
+ * ```
+ */
+type TransformOptions = Visitor & {
+  /**
+   * Traversal depth (`'deep'` by default).
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Internal parent override used during recursion.
+   */
+  parent?: Node;
+};
+/**
+ * Options for `walk`.
+ *
+ * @example
+ * ```ts
+ * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }
+ * ```
+ */
+type WalkOptions = AsyncVisitor & {
+  /**
+   * Traversal depth (`'deep'` by default).
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Maximum number of sibling nodes visited concurrently.
+   * @default 30
+   */
+  concurrency?: number;
+};
+/**
+ * Options for `collect`.
+ *
+ * @example
+ * ```ts
+ * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
+ * ```
+ */
+type CollectOptions<T> = CollectVisitor<T> & {
+  /**
+   * Traversal depth (`'deep'` by default).
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Internal parent override used during recursion.
+   */
+  parent?: Node;
+};
+/**
+ * Depth-first traversal for side effects. Visitor return values are ignored.
+ * Sibling nodes at each level are visited concurrently up to `options.concurrency`
+ * (default: `WALK_CONCURRENCY`).
+ *
+ * @example
+ * ```ts
+ * await walk(root, {
+ *   operation(node) {
+ *     console.log(node.operationId)
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Visit only the current node
+ * await walk(root, { depth: 'shallow', root: () => {} })
+ * ```
+ */
+declare function walk(node: Node, options: WalkOptions): Promise<void>;
+/**
+ * Runs a depth-first immutable transform.
+ *
+ * If a visitor returns a node, it replaces the current node.
+ * If it returns `undefined`, the current node stays the same.
+ *
+ * @example
+ * ```ts
+ * const next = transform(root, {
+ *   operation(node) {
+ *     return { ...node, operationId: `prefixed_${node.operationId}` }
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Shallow mode: only transform the input node
+ * const next = transform(root, { depth: 'shallow', root: (node) => node })
+ * ```
+ */
+declare function transform(node: InputNode, options: TransformOptions): InputNode;
+declare function transform(node: OutputNode, options: TransformOptions): OutputNode;
+declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
+declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
+declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
+declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
+declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
+declare function transform(node: Node, options: TransformOptions): 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' })
+ * ```
+ */
+declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
 //#endregion
 //#region src/utils.d.ts
 /**
- * Returns `true` when a schema node will be represented as a plain string in generated code.
+ * 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.
+ */
+declare function syncSchemaRef(node: SchemaNode): SchemaNode;
+/**
+ * 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
+ * ```
  */
-declare function isPlainStringType(node: SchemaNode): boolean;
+declare function isStringType(node: SchemaNode): boolean;
 /**
- * Transforms the `name` field of each parameter node according to the given casing strategy.
+ * Applies casing rules to parameter names and returns a new parameter array.
  *
- * The original `params` array is never mutated — a new array of cloned nodes is returned.
- * When no `casing` is provided the original array is returned as-is.
+ * 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 the generated output match the desired casing while the original
- * `OperationNode.parameters` array remains untouched for other consumers.
+ * 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'
+ * ```
+ */
+declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
+/**
+ * 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') }] }
+ * ```
+ */
+declare function createDiscriminantNode({
+  propertyName,
+  value
+}: {
+  propertyName: string;
+  value: string;
+}): SchemaNode;
+/**
+ * Resolver interface for {@link createOperationParams}.
+ *
+ * `ResolverTs` from `@kubb/plugin-ts` satisfies this interface and can be passed directly.
+ */
+type OperationParamsResolver = {
+  /**
+   * Resolves the type name for an individual parameter.
+   *
+   * @example Individual path parameter name
+   * `resolver.resolveParamName(node, param) // → 'DeletePetPathPetId'`
+   */
+  resolveParamName(node: OperationNode, param: ParameterNode): string;
+  /**
+   * Resolves the request body type name.
+   *
+   * @example Request body type name
+   * `resolver.resolveDataName(node) // → 'CreatePetData'`
+   */
+  resolveDataName(node: OperationNode): string;
+  /**
+   * Resolves the grouped path parameters type name.
+   * When the return value equals `resolveParamName`, no indexed access is emitted.
+   *
+   * @example Grouped path params type name
+   * `resolver.resolvePathParamsName(node, param) // → 'DeletePetPathParams'`
+   */
+  resolvePathParamsName(node: OperationNode, param: ParameterNode): string;
+  /**
+   * Resolves the grouped query parameters type name.
+   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
+   *
+   * @example Grouped query params type name
+   * `resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'`
+   */
+  resolveQueryParamsName(node: OperationNode, param: ParameterNode): string;
+  /**
+   * Resolves the grouped header parameters type name.
+   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
+   *
+   * @example Grouped header params type name
+   * `resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'`
+   */
+  resolveHeaderParamsName(node: OperationNode, param: ParameterNode): string;
+};
+/**
+ * Options for {@link createOperationParams}.
+ */
+type CreateOperationParamsOptions = {
+  /**
+   * How all operation parameters are grouped in the function signature.
+   * - `'object'` wraps all params into a single destructured object `{ petId, data, params }`
+   * - `'inline'` emits each param category as a separate top-level parameter
+   */
+  paramsType: 'object' | 'inline';
+  /**
+   * How path parameters are emitted when `paramsType` is `'inline'`.
+   * - `'object'` groups them as `{ petId, storeId }: PathParams`
+   * - `'inline'` spreads them as individual parameters `petId: string, storeId: string`
+   * - `'inlineSpread'` emits a single rest parameter `...pathParams: PathParams`
+   */
+  pathParamsType: 'object' | 'inline' | 'inlineSpread';
+  /**
+   * Converts parameter names to camelCase before output.
+   */
+  paramsCasing?: 'camelcase';
+  /**
+   * Resolver for parameter and request body type names.
+   * Pass `ResolverTs` from `@kubb/plugin-ts` directly.
+   * When omitted, falls back to the schema primitive or `'unknown'`.
+   */
+  resolver?: OperationParamsResolver;
+  /**
+   * Default value for the path parameters binding when `pathParamsType` is `'object'`.
+   * Falls back to `'{}'` when all path params are optional.
+   */
+  pathParamsDefault?: string;
+  /**
+   * Extra parameters appended after the standard operation parameters.
+   *
+   * @example Plugin-specific trailing parameter
+   * ```ts
+   * extraParams: [createFunctionParameter({ name: 'options', type: 'Partial<RequestOptions>', default: '{}' })]
+   * ```
+   */
+  extraParams?: Array<FunctionParameterNode | ParameterGroupNode>;
+  /**
+   * Override the default parameter names used for body, query, header, and rest-path groups.
+   *
+   * Useful when targeting languages or frameworks with different naming conventions.
+   *
+   * @default { data: 'data', params: 'params', headers: 'headers', path: 'pathParams' }
+   */
+  paramNames?: {
+    /**
+     * Name for the request body parameter.
+     * @default 'data'
+     */
+    data?: string;
+    /**
+     * Name for the query parameters group parameter.
+     * @default 'params'
+     */
+    params?: string;
+    /**
+     * Name for the header parameters group parameter.
+     * @default 'headers'
+     */
+    headers?: string;
+    /**
+     * Name for the rest path-parameters parameter when `pathParamsType` is `'inlineSpread'`.
+     * @default 'pathParams'
+     */
+    path?: string;
+  };
+  /**
+   * Applies a uniform transformation to every resolved type name before it is used
+   * in a parameter node. Use this for framework-level type wrappers.
+   *
+   * @example Vue Query — wrap every parameter type with `MaybeRefOrGetter`
+   * `typeWrapper: (t) => \`MaybeRefOrGetter<${t}>\``
+   */
+  typeWrapper?: (type: string) => string;
+};
+/**
+ * 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: '{}' })],
+ * })
+ * ```
+ */
+declare function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
+/**
+ * Recursively extracts all string content embedded in a {@link CodeNode} tree.
+ *
+ * Includes text node values, and string attribute fields (`params`, `generics`,
+ * `returnType`, `type`) that may reference identifiers needing imports.
+ * Used by `createFile` to build the full source string for import filtering.
+ */
+declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
+/**
+ * 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'
+ * ```
+ */
+declare function resolveRefName(node: SchemaNode | undefined): string | undefined;
+/**
+ * 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' }
+ * ```
+ */
+declare function collectReferencedSchemaNames(node: SchemaNode | undefined, out?: Set<string>): Set<string>;
+/**
+ * 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
+ * }
+ * ```
+ */
+declare function findCircularSchemas(schemas: ReadonlyArray<SchemaNode>): Set<string>;
+/**
+ * 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
+ * }
+ * ```
  */
-declare function applyParamsCasing(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
+declare function containsCircularRef(node: SchemaNode | undefined, {
+  circularSchemas,
+  excludeName
+}: {
+  circularSchemas: ReadonlySet<string>;
+  excludeName?: string;
+}): boolean;
 //#endregion
-export { applyParamsCasing, buildRefMap, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, definePrinter, httpMethods, isOperationNode, isParameterNode, isPlainStringType, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, transform, walk };
+export { type ArraySchemaNode, type ArrowFunctionNode, AsyncVisitor, type BaseNode, type BreakNode, type CodeNode, CollectOptions, CollectVisitor, type ComplexSchemaType, type ConstNode, type DateSchemaNode, type DatetimeSchemaNode, DistributiveOmit, type EnumSchemaNode, type EnumValueNode, type ExportNode, type FileNode, type FormatStringSchemaNode, type FunctionNode, type FunctionNodeType, type FunctionParamNode, type FunctionParameterNode, type FunctionParametersNode, type HttpMethod, type HttpStatusCode, type ImportNode, InferSchema, InferSchemaNode, type InputMeta, type InputNode, type IntersectionSchemaNode, type Ipv4SchemaNode, type Ipv6SchemaNode, type JSDocNode, type JsxNode, type MediaType, Node, type NodeKind, type NumberSchemaNode, type ObjectSchemaNode, type OperationNode, OperationParamsResolver, type OutputNode, type ParameterGroupNode, type ParameterLocation, type ParameterNode, type ParamsTypeNode, ParentOf, ParserOptions, type PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, type PropertyNode, RefMap, type RefSchemaNode, type ResponseNode, ScalarPrimitive, type ScalarSchemaNode, type ScalarSchemaType, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type SpecialSchemaType, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, TransformOptions, type TypeDeclarationNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, UserFileNode, Visitor, VisitorContext, VisitorDepth, WalkOptions, caseParams, childName, collect, collectImports, collectReferencedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
 //# sourceMappingURL=index.d.ts.map