@kubb/ast 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/index.d.ts

@@ -199,7 +199,7 @@ declare const mediaTypes: {
  * 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';
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | 'FunctionParameter' | 'ParameterGroup' | 'FunctionParameters' | 'Type' | 'ParamsType' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
 /**
  * Base shape shared by all AST nodes.
  *
@@ -251,21 +251,21 @@ type ConstNode = BaseNode & {
    * Whether the declaration should be exported.
    * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * Optional explicit type annotation.
    * @example 'Pet'
    */
-  type?: string;
+  type?: string | null;
   /**
    * JSDoc documentation metadata.
    */
-  JSDoc?: JSDocNode;
+  JSDoc?: JSDocNode | null;
   /**
    * Whether to append `as const` to the declaration.
    * @default false
    */
-  asConst?: boolean;
+  asConst?: boolean | null;
   /**
    * 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.
@@ -297,11 +297,11 @@ type TypeNode = BaseNode & {
    * Whether the declaration should be exported.
    * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * JSDoc documentation metadata.
    */
-  JSDoc?: JSDocNode;
+  JSDoc?: JSDocNode | null;
   /**
    * Child nodes representing the type body (children of the `Type` component).
    * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
@@ -338,35 +338,35 @@ type FunctionNode = BaseNode & {
    * Whether the function is a default export.
    * @default false
    */
-  default?: boolean;
+  default?: boolean | null;
   /**
    * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
    */
-  params?: string;
+  params?: string | null;
   /**
    * Whether the function should be exported.
    * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
    * @default false
    */
-  async?: boolean;
+  async?: boolean | null;
   /**
    * TypeScript generic type parameters.
    * @example ['T', 'U extends string']
    */
-  generics?: string | string[];
+  generics?: string | Array<string> | null;
   /**
    * Return type annotation.
    * @example 'Pet'
    */
-  returnType?: string;
+  returnType?: string | null;
   /**
    * JSDoc documentation metadata.
    */
-  JSDoc?: JSDocNode;
+  JSDoc?: JSDocNode | null;
   /**
    * Child nodes representing the function body (children of the `Function` component).
    * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
@@ -398,40 +398,40 @@ type ArrowFunctionNode = BaseNode & {
    * Whether the function is a default export.
    * @default false
    */
-  default?: boolean;
+  default?: boolean | null;
   /**
    * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
    */
-  params?: string;
+  params?: string | null;
   /**
    * Whether the arrow function should be exported.
    * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
    * @default false
    */
-  async?: boolean;
+  async?: boolean | null;
   /**
    * TypeScript generic type parameters.
    * @example ['T', 'U extends string']
    */
-  generics?: string | string[];
+  generics?: string | Array<string> | null;
   /**
    * Return type annotation.
    * @example 'Pet'
    */
-  returnType?: string;
+  returnType?: string | null;
   /**
    * JSDoc documentation metadata.
    */
-  JSDoc?: JSDocNode;
+  JSDoc?: JSDocNode | null;
   /**
    * Render the arrow function body as a single-line expression.
    * @default false
    */
-  singleLine?: boolean;
+  singleLine?: boolean | null;
   /**
    * 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.
@@ -510,1079 +510,1123 @@ type JsxNode = BaseNode & {
  */
 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;
-}>;
+//#region src/nodes/property.d.ts
 /**
- * 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 })
- * ```
+ * AST node representing one named object property.
  *
- * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * @example
  * ```ts
- * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * const property: PropertyNode = {
+ *   kind: 'Property',
+ *   name: 'id',
+ *   schema: createSchema({ type: 'integer' }),
+ *   required: true,
+ * }
  * ```
  */
-type ImportNode = BaseNode & {
-  kind: 'Import';
-  /**
-   * Import name(s) to be used.
-   * @example ['useState']
-   * @example 'React'
-   */
-  name: ImportName;
+type PropertyNode = BaseNode & {
   /**
-   * Path for the import.
-   * @example '@kubb/core'
+   * Node kind.
    */
-  path: string;
+  kind: 'Property';
   /**
-   * Add type-only import prefix.
-   * - `true` generates `import type { Type } from './path'`
-   * - `false` generates `import { Type } from './path'`
-   * @default false
+   * Property key.
    */
-  isTypeOnly?: boolean;
+  name: string;
   /**
-   * Import entire module as namespace.
-   * - `true` generates `import * as Name from './path'`
-   * - `false` generates standard import
-   * @default false
+   * Property schema.
    */
-  isNameSpace?: boolean;
+  schema: SchemaNode;
   /**
-   * When set, the import path is resolved relative to this root.
+   * Whether the property is required.
    */
-  root?: string;
+  required: boolean;
 };
+//#endregion
+//#region src/nodes/schema.d.ts
+type PrimitiveSchemaType =
 /**
- * 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 })
- * ```
+ * Text value.
  */
-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;
-};
+'string'
 /**
- * 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')] })
- * ```
+ * Floating-point number.
  */
-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;
+| '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 & {
   /**
-   * Include `export` keyword in the generated source.
-   * @default false
+   * Node kind.
    */
-  isExportable?: boolean;
+  kind: 'Schema';
   /**
-   * Include this source in barrel/index file generation.
-   * @default false
+   * 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.
    */
-  isIndexable?: boolean;
+  name?: string | null;
   /**
-   * 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.
+   * Short schema title.
    */
-  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';
+  title?: string;
   /**
-   * Unique identifier derived from a SHA256 hash of the file path.
-   * @default hash
+   * Schema description text.
    */
-  id: string;
+  description?: string;
   /**
-   * File name without extension, derived from `baseName`.
-   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   * Whether `null` is allowed.
    */
-  name: string;
+  nullable?: boolean;
   /**
-   * File base name, including extension.
-   * Based on UNIX basename: `${name}${extname}`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   * Whether the field is optional.
    */
-  baseName: `${string}.${string}`;
+  optional?: boolean;
   /**
-   * Full qualified path to the file.
+   * Both optional and nullable (`optional` + `nullable`).
    */
-  path: string;
+  nullish?: boolean;
   /**
-   * File extension extracted from `baseName`.
+   * Whether the schema is deprecated.
    */
-  extname: Extname;
+  deprecated?: boolean;
   /**
-   * Deduplicated list of source code fragments.
+   * Whether the schema is read-only.
    */
-  sources: Array<SourceNode>;
+  readOnly?: boolean;
   /**
-   * Deduplicated list of import declarations.
+   * Whether the schema is write-only.
    */
-  imports: Array<ImportNode>;
+  writeOnly?: boolean;
   /**
-   * Deduplicated list of export declarations.
+   * Default value.
    */
-  exports: Array<ExportNode>;
+  default?: unknown;
   /**
-   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
+   * Example value.
    */
-  meta?: TMeta;
+  example?: unknown;
   /**
-   * Optional banner prepended to the generated file content.
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
    */
-  banner?: string;
+  primitive?: PrimitiveSchemaType;
   /**
-   * Optional footer appended to the generated file content.
+   * Schema `format` value.
    */
-  footer?: string;
+  format?: 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 }
- * ```
+ * Object schema with ordered properties.
  *
- * @example Member variant
+ * @example
  * ```ts
- * createParamsType({ variant: 'member', base: 'PathParams', key: 'petId' })
- * // PathParams['petId']
+ * const objectSchema: ObjectSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'object',
+ *   properties: [],
+ * }
  * ```
  */
-type ParamsTypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'ParamsType';
-} & ({
+type ObjectSchemaNode = SchemaNodeBase & {
   /**
-   * Reference variant — a plain type name or identifier.
-   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
+   * Schema type discriminator.
    */
-  variant: 'reference';
+  type: 'object';
   /**
-   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
+   * Primitive type — always `'object'` for object schemas.
    */
-  name: string;
-} | {
+  primitive: 'object';
   /**
-   * Struct variant — an inline anonymous type grouping named fields.
-   * TypeScript renders as `{ key: Type; other?: OtherType }`.
+   * Ordered object properties.
    */
-  variant: 'struct';
+  properties: Array<PropertyNode>;
   /**
-   * Properties of the struct type.
+   * 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)
    */
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
+  additionalProperties?: SchemaNode | boolean;
   /**
-   * Member variant — a single named field accessed from a group type.
-   * TypeScript renders as `Base['key']`.
+   * Pattern-based property schemas.
    */
-  variant: 'member';
+  patternProperties?: Record<string, SchemaNode>;
   /**
-   * Base type name, e.g. `'DeletePetPathParams'`.
+   * Minimum number of properties allowed.
    */
-  base: string;
+  minProperties?: number;
   /**
-   * The field name to access, e.g. `'petId'`.
+   * Maximum number of properties allowed.
    */
-  key: string;
-});
+  maxProperties?: number;
+};
 /**
- * AST node for one function parameter.
- *
- * @example Required parameter
- * `name: Type`
- *
- * @example Optional parameter
- * `name?: Type`
- *
- * @example Parameter with default value
- * `name: Type = defaultValue`
+ * Array-like schema (`array` or `tuple`).
  *
- * @example Rest parameter
- * `...name: Type[]`
+ * @example
+ * ```ts
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
+ * }
+ * ```
  */
-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;
+type ArraySchemaNode = SchemaNodeBase & {
   /**
-   * When `true` the parameter is emitted as a rest parameter.
-   *
-   * @example Rest parameter
-   * `...name: Type[]`
+   * Schema type discriminator (`array` or `tuple`).
    */
-  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 & {
+  type: 'array' | 'tuple';
   /**
-   * Node kind.
+   * Item schemas.
    */
-  kind: 'ParameterGroup';
+  items?: Array<SchemaNode>;
   /**
-   * The individual parameters that form the group.
-   * Rendered as a destructured object or spread inline when `inline` is `true`.
+   * Tuple rest-item schema for elements beyond positional `items`.
    */
-  properties: Array<FunctionParameterNode>;
+  rest?: SchemaNode;
   /**
-   * Optional explicit type annotation for the whole group.
-   * When absent, printers auto-compute it from `properties`.
+   * Minimum item count (or tuple length).
    */
-  type?: ParamsTypeNode;
+  min?: number;
   /**
-   * When `true`, `properties` are emitted as individual top-level parameters instead of
-   * being wrapped in a single grouped construct.
-   *
-   * @default false
+   * Maximum item count (or tuple length).
    */
-  inline?: boolean;
+  max?: number;
   /**
-   * Whether the group as a whole is optional.
-   * If omitted, printers infer this from child properties.
+   * Whether all items must be unique.
    */
-  optional?: boolean;
+  unique?: boolean;
+};
+/**
+ * Shared shape for union and intersection schemas.
+ */
+type CompositeSchemaNodeBase = SchemaNodeBase & {
   /**
-   * Default value for the group, written verbatim after `=`.
-   * Commonly `'{}'` to allow omitting the argument entirely.
+   * Member schemas.
    */
-  default?: string;
+  members?: Array<SchemaNode>;
 };
 /**
- * AST node for a complete function parameter list.
- *
- * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
- * Nodes are plain immutable data.
+ * Union schema, often from `oneOf` or `anyOf`.
  *
- * 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
+ * @example
+ * ```ts
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
+ * }
+ * ```
  */
-type FunctionParametersNode = BaseNode & {
+type UnionSchemaNode = CompositeSchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'FunctionParameters';
+  type: 'union';
   /**
-   * Ordered parameter nodes.
+   * Discriminator property name from OpenAPI `discriminator.propertyName`.
    */
-  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
+  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';
 };
 /**
- * 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.
+ * Intersection schema, often from `allOf`.
  *
  * @example
  * ```ts
- * const property: PropertyNode = {
- *   kind: 'Property',
- *   name: 'id',
- *   schema: createSchema({ type: 'integer' }),
- *   required: true,
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
  * }
  * ```
  */
-type PropertyNode = BaseNode & {
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'Property';
+  type: 'intersection';
+};
+/**
+ * One named enum item.
+ */
+type EnumValueNode = {
   /**
-   * Property key.
+   * Enum item name.
    */
   name: string;
   /**
-   * Property schema.
+   * Enum item value.
    */
-  schema: SchemaNode;
+  value: string | number | boolean;
   /**
-   * Whether the property is required.
+   * Primitive type of the enum value.
    */
-  required: boolean;
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | '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.
+ * Enum schema node.
+ *
+ * @example
+ * ```ts
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
+ * }
+ * ```
  */
-type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+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>;
+};
 /**
- * Fields shared by all schema nodes.
+ * Reference schema that points to another schema definition.
+ *
+ * @example
+ * ```ts
+ * const refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
+ * ```
  */
-type SchemaNodeBase = BaseNode & {
+type RefSchemaNode = SchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'Schema';
+  type: 'ref';
   /**
-   * 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.
+   * Referenced schema name.
+   * `null` means Kubb has processed this and determined there is no applicable name.
    */
   name?: string | null;
   /**
-   * Short schema title.
+   * Original `$ref` path, for example, `#/components/schemas/Order`.
+   * Used to resolve names later.
    */
-  title?: string;
+  ref?: string;
   /**
-   * Schema description text.
+   * Pattern copied from a sibling `pattern` field.
    */
-  description?: string;
+  pattern?: string;
   /**
-   * Whether `null` is allowed.
+   * The fully-parsed schema that this ref resolves to.
+   * Populated during OAS parsing when the referenced definition can be resolved.
+   * `null` when the ref cannot be resolved or is part of a circular chain.
+   * `undefined` when resolution has not been attempted.
+   *
+   * Useful for inspecting the referenced schema's structure (e.g. `primitive`, `properties`)
+   * without following the reference manually.
    */
-  nullable?: boolean;
+  schema?: SchemaNode | null;
+};
+/**
+ * Datetime schema.
+ *
+ * @example
+ * ```ts
+ * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
+ * ```
+ */
+type DatetimeSchemaNode = SchemaNodeBase & {
   /**
-   * Whether the field is optional.
+   * Schema type discriminator.
    */
-  optional?: boolean;
+  type: 'datetime';
   /**
-   * Both optional and nullable (`optional` + `nullable`).
+   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
    */
-  nullish?: boolean;
+  offset?: boolean;
   /**
-   * Whether the schema is deprecated.
+   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
    */
-  deprecated?: boolean;
+  local?: boolean;
+};
+/**
+ * Shared base for `date` and `time` schemas.
+ */
+type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
   /**
-   * Whether the schema is read-only.
+   * Schema type discriminator.
    */
-  readOnly?: boolean;
+  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 & {
   /**
-   * Whether the schema is write-only.
+   * Schema type discriminator.
    */
-  writeOnly?: boolean;
+  type: 'string';
   /**
-   * Default value.
+   * Minimum string length.
    */
-  default?: unknown;
+  min?: number;
   /**
-   * Example value.
+   * Maximum string length.
    */
-  example?: unknown;
+  max?: number;
   /**
-   * Base primitive type.
-   * For example, this is `'string'` for a `uuid` schema.
+   * Regex pattern.
    */
-  primitive?: PrimitiveSchemaType;
+  pattern?: string;
 };
 /**
- * Object schema with ordered properties.
+ * Numeric schema (`number`, `integer`, or `bigint`).
  *
  * @example
  * ```ts
- * const objectSchema: ObjectSchemaNode = {
- *   kind: 'Schema',
- *   type: 'object',
- *   properties: [],
- * }
+ * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
  * ```
  */
-type ObjectSchemaNode = SchemaNodeBase & {
+type NumberSchemaNode = SchemaNodeBase & {
   /**
    * Schema type discriminator.
    */
-  type: 'object';
+  type: 'number' | 'integer' | 'bigint';
   /**
-   * Primitive type — always `'object'` for object schemas.
+   * Minimum value.
    */
-  primitive: 'object';
+  min?: number;
   /**
-   * Ordered object properties.
+   * Maximum value.
    */
-  properties: Array<PropertyNode>;
+  max?: number;
   /**
-   * 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)
+   * Exclusive minimum value.
    */
-  additionalProperties?: SchemaNode | boolean;
+  exclusiveMinimum?: number;
   /**
-   * Pattern-based property schemas.
+   * Exclusive maximum value.
    */
-  patternProperties?: Record<string, SchemaNode>;
+  exclusiveMaximum?: number;
   /**
-   * Minimum number of properties allowed.
+   * The value must be a multiple of this number.
    */
-  minProperties?: number;
+  multipleOf?: number;
+};
+/**
+ * Scalar schema with no extra constraints.
+ *
+ * @example
+ * ```ts
+ * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
+ * ```
+ */
+type ScalarSchemaNode = SchemaNodeBase & {
   /**
-   * Maximum number of properties allowed.
+   * Schema type discriminator.
    */
-  maxProperties?: number;
+  type: ScalarSchemaType;
 };
 /**
- * Array-like schema (`array` or `tuple`).
+ * URL schema node.
+ * Can include an OpenAPI-style path template for template literal types.
  *
  * @example
  * ```ts
- * const arraySchema: ArraySchemaNode = {
- *   kind: 'Schema',
- *   type: 'array',
- *   items: [],
- * }
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
  * ```
  */
-type ArraySchemaNode = SchemaNodeBase & {
+type UrlSchemaNode = SchemaNodeBase & {
   /**
-   * Schema type discriminator (`array` or `tuple`).
+   * Schema type discriminator.
    */
-  type: 'array' | 'tuple';
+  type: 'url';
   /**
-   * Item schemas.
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
    */
-  items?: Array<SchemaNode>;
+  path?: string;
   /**
-   * Tuple rest-item schema for elements beyond positional `items`.
+   * Minimum string length.
    */
-  rest?: SchemaNode;
+  min?: number;
   /**
-   * Minimum item count (or tuple length).
+   * 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 item count (or tuple length).
+   * Maximum string length.
    */
   max?: number;
+};
+/**
+ * IPv4 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
+ * ```
+ */
+type Ipv4SchemaNode = SchemaNodeBase & {
   /**
-   * Whether all items must be unique.
+   * Schema type discriminator.
    */
-  unique?: boolean;
+  type: 'ipv4';
 };
 /**
- * Shared shape for union and intersection schemas.
+ * IPv6 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
+ * ```
  */
-type CompositeSchemaNodeBase = SchemaNodeBase & {
+type Ipv6SchemaNode = SchemaNodeBase & {
   /**
-   * Member schemas.
+   * Schema type discriminator.
    */
-  members?: Array<SchemaNode>;
+  type: 'ipv6';
 };
 /**
- * Union schema, often from `oneOf` or `anyOf`.
+ * 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/content.d.ts
+/**
+ * AST node representing one content-type entry of a request body or response.
+ *
+ * One entry per content type declared in the spec (e.g. `application/json`,
+ * `multipart/form-data`), each carrying its own body schema.
  *
  * @example
  * ```ts
- * const unionSchema: UnionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'union',
- *   members: [],
+ * const content: ContentNode = {
+ *   kind: 'Content',
+ *   contentType: 'application/json',
+ *   schema: createSchema({ type: 'string' }),
  * }
  * ```
  */
-type UnionSchemaNode = CompositeSchemaNodeBase & {
+type ContentNode = BaseNode & {
   /**
-   * Schema type discriminator.
+   * Node kind.
    */
-  type: 'union';
+  kind: 'Content';
   /**
-   * Discriminator property name from OpenAPI `discriminator.propertyName`.
+   * The content type for this entry (e.g. `'application/json'`).
    */
-  discriminatorPropertyName?: string;
+  contentType: 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`).
+   * Body schema for this content type.
+   */
+  schema?: SchemaNode;
+  /**
+   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+   * Set when a referenced schema has `readOnly`/`writeOnly` fields that should be omitted.
+   */
+  keysToOmit?: Array<string> | null;
+};
+//#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 | null;
+  /**
+   * Import entire module as namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates standard import
+   * @default false
+   */
+  isNameSpace?: boolean | null;
+  /**
+   * When set, the import path is resolved relative to this root.
    */
-  strategy?: 'one' | 'any';
+  root?: string | null;
 };
 /**
- * Intersection schema, often from `allOf`.
+ * Represents a language-agnostic export/public API declaration.
  *
- * @example
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
  * ```ts
- * const intersectionSchema: IntersectionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'intersection',
- *   members: [],
- * }
+ * 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 IntersectionSchemaNode = CompositeSchemaNodeBase & {
+type ExportNode = BaseNode & {
+  kind: 'Export';
   /**
-   * Schema type discriminator.
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   * @example ['useState']
+   * @example 'React'
    */
-  type: 'intersection';
-};
-/**
- * One named enum item.
- */
-type EnumValueNode = {
+  name?: string | Array<string> | null;
   /**
-   * Enum item name.
+   * Path for the export.
+   * @example '@kubb/core'
    */
-  name: string;
+  path: string;
   /**
-   * Enum item value.
+   * Add type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   * @default false
    */
-  value: string | number | boolean;
+  isTypeOnly?: boolean | null;
   /**
-   * Primitive type of the enum value.
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   * @default false
    */
-  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
+  asAlias?: boolean | null;
 };
 /**
- * Enum schema node.
+ * Represents a fragment of source code within a file.
  *
- * @example
+ * @example Named exportable source
  * ```ts
- * const enumSchema: EnumSchemaNode = {
- *   kind: 'Schema',
- *   type: 'enum',
- *   enumValues: ['a', 'b'],
- * }
+ * 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 EnumSchemaNode = SchemaNodeBase & {
+type SourceNode = BaseNode & {
+  kind: 'Source';
   /**
-   * Schema type discriminator.
+   * Optional name identifying this source (used for deduplication and barrel generation).
    */
-  type: 'enum';
+  name?: string | null;
   /**
-   * Enum values in simple form.
+   * Mark this source as a type-only export.
+   * @default false
    */
-  enumValues?: Array<string | number | boolean | null>;
+  isTypeOnly?: boolean | null;
   /**
-   * Enum values in named form.
-   * If present, this is used instead of `enumValues`.
+   * Include `export` keyword in the generated source.
+   * @default false
    */
-  namedEnumValues?: Array<EnumValueNode>;
+  isExportable?: boolean | null;
+  /**
+   * Include this source in barrel/index file generation.
+   * @default false
+   */
+  isIndexable?: boolean | null;
+  /**
+   * 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>;
 };
 /**
- * Reference schema that points to another schema definition.
+ * 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 refSchema: RefSchemaNode = {
- *   kind: 'Schema',
- *   type: 'ref',
- *   ref: '#/components/schemas/Pet',
- * }
+ * 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 RefSchemaNode = SchemaNodeBase & {
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
   /**
-   * Schema type discriminator.
+   * Unique identifier derived from a SHA256 hash of the file path. Computed
+   * by `createFile`; callers do not need to provide it.
    */
-  type: 'ref';
+  id: string;
   /**
-   * Referenced schema name.
+   * File name without extension, derived from `baseName`.
+   * @link https://nodejs.org/api/path.html#pathformatpathobject
    */
-  name?: string;
+  name: string;
   /**
-   * Original `$ref` path, for example, `#/components/schemas/Order`.
-   * Used to resolve names later.
+   * File base name, including extension.
+   * Based on UNIX basename: `${name}${extname}`
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
    */
-  ref?: string;
+  baseName: `${string}.${string}`;
   /**
-   * Pattern copied from a sibling `pattern` field.
+   * Full qualified path to the file.
    */
-  pattern?: string;
+  path: 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.
+   * File extension extracted from `baseName`.
    */
-  schema?: SchemaNode;
-};
-/**
- * Datetime schema.
- *
- * @example
- * ```ts
- * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
- * ```
- */
-type DatetimeSchemaNode = SchemaNodeBase & {
+  extname: Extname;
   /**
-   * Schema type discriminator.
+   * Deduplicated list of source code fragments.
    */
-  type: 'datetime';
+  sources: Array<SourceNode>;
   /**
-   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
+   * Deduplicated list of import declarations.
    */
-  offset?: boolean;
+  imports: Array<ImportNode>;
   /**
-   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
+   * Deduplicated list of export declarations.
    */
-  local?: boolean;
-};
-/**
- * Shared base for `date` and `time` schemas.
- */
-type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
+  exports: Array<ExportNode>;
   /**
-   * Schema type discriminator.
+   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
    */
-  type: T;
+  meta?: TMeta;
   /**
-   * Output representation in generated code.
+   * Optional banner prepended to the generated file content.
+   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
    */
-  representation: 'date' | 'string';
+  banner?: string | null;
+  /**
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
+   */
+  footer?: string | null;
 };
+//#endregion
+//#region src/nodes/function.d.ts
 /**
- * Date schema node.
+ * 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.
  *
- * @example
+ * - `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
- * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
+ * createParamsType({ variant: 'reference', name: 'QueryParams' })
+ * // QueryParams
  * ```
- */
-type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
-/**
- * Time schema node.
  *
- * @example
+ * @example Struct variant
  * ```ts
- * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
+ * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
+ * // { petId: string }
  * ```
- */
-type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
-/**
- * String schema node.
  *
- * @example
+ * @example Member variant
  * ```ts
- * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
+ * createParamsType({ variant: 'member', base: 'PathParams', key: 'petId' })
+ * // PathParams['petId']
  * ```
  */
-type StringSchemaNode = SchemaNodeBase & {
+type ParamsTypeNode = BaseNode & {
   /**
-   * Schema type discriminator.
+   * Node kind.
    */
-  type: 'string';
+  kind: 'ParamsType';
+} & ({
   /**
-   * Minimum string length.
+   * Reference variant — a plain type name or identifier.
+   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
    */
-  min?: number;
+  variant: 'reference';
   /**
-   * Maximum string length.
+   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
    */
-  max?: number;
+  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;
   /**
-   * Regex pattern.
+   * The field name to access, e.g. `'petId'`.
    */
-  pattern?: string;
-};
+  key: string;
+});
 /**
- * Numeric schema (`number`, `integer`, or `bigint`).
+ * AST node for one function parameter.
  *
- * @example
- * ```ts
- * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
- * ```
+ * @example Required parameter
+ * `name: Type`
+ *
+ * @example Optional parameter
+ * `name?: Type`
+ *
+ * @example Parameter with default value
+ * `name: Type = defaultValue`
+ *
+ * @example Rest parameter
+ * `...name: Type[]`
  */
-type NumberSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'number' | 'integer' | 'bigint';
-  /**
-   * Minimum value.
-   */
-  min?: number;
+type FunctionParameterNode = BaseNode & {
   /**
-   * Maximum value.
+   * Node kind.
    */
-  max?: number;
+  kind: 'FunctionParameter';
   /**
-   * Exclusive minimum value.
+   * Parameter name in the generated signature.
    */
-  exclusiveMinimum?: number;
+  name: string;
   /**
-   * Exclusive maximum value.
+   * 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']`
    */
-  exclusiveMaximum?: number;
+  type?: ParamsTypeNode;
   /**
-   * The value must be a multiple of this number.
+   * When `true` the parameter is emitted as a rest parameter.
+   *
+   * @example Rest parameter
+   * `...name: Type[]`
    */
-  multipleOf?: number;
-};
+  rest?: boolean;
+}
 /**
- * Scalar schema with no extra constraints.
+* 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
- * ```ts
- * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
- * ```
+ * @example Required
+ * `name: Type`
+ *
+ * @example With default
+ * `name: Type = default`
  */
-type ScalarSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: ScalarSchemaType;
-};
+| {
+  optional?: false;
+  default?: string;
+});
 /**
- * URL schema node.
- * Can include an OpenAPI-style path template for template literal types.
+ * AST node for a group of related function parameters treated as a single unit.
  *
- * @example
- * ```ts
- * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
- * ```
+ * 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 UrlSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'url';
+type ParameterGroupNode = BaseNode & {
   /**
-   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
+   * Node kind.
    */
-  path?: string;
+  kind: 'ParameterGroup';
   /**
-   * Minimum string length.
+   * The individual parameters that form the group.
+   * Rendered as a destructured object or spread inline when `inline` is `true`.
    */
-  min?: number;
+  properties: Array<FunctionParameterNode>;
   /**
-   * Maximum string length.
+   * Optional explicit type annotation for the whole group.
+   * When absent, printers auto-compute it from `properties`.
    */
-  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 & {
+  type?: ParamsTypeNode;
   /**
-   * Schema type discriminator.
+   * When `true`, `properties` are emitted as individual top-level parameters instead of
+   * being wrapped in a single grouped construct.
+   *
+   * @default false
    */
-  type: 'uuid' | 'email';
+  inline?: boolean;
   /**
-   * Minimum string length.
+   * Whether the group as a whole is optional.
+   * If omitted, printers infer this from child properties.
    */
-  min?: number;
+  optional?: boolean;
   /**
-   * Maximum string length.
+   * Default value for the group, written verbatim after `=`.
+   * Commonly `'{}'` to allow omitting the argument entirely.
    */
-  max?: number;
+  default?: string;
 };
 /**
- * IPv4 address schema node.
+ * AST node for a complete function parameter list.
  *
- * @example
- * ```ts
- * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
- * ```
+ * 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 Ipv4SchemaNode = SchemaNodeBase & {
+type FunctionParametersNode = BaseNode & {
   /**
-   * Schema type discriminator.
+   * Node kind.
    */
-  type: 'ipv4';
-};
-/**
- * IPv6 address schema node.
- *
- * @example
- * ```ts
- * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
- * ```
- */
-type Ipv6SchemaNode = SchemaNodeBase & {
+  kind: 'FunctionParameters';
   /**
-   * Schema type discriminator.
+   * Ordered parameter nodes.
    */
-  type: 'ipv6';
+  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
 };
 /**
- * Mapping from schema type literals to concrete schema node types.
- * Used by `narrowSchema`.
+ * Union of all function-parameter AST node variants used by the function-parameter printer.
  */
-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;
-};
+type FunctionParamNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | ParamsTypeNode;
 /**
- * Union of all schema node types.
+ * Handler map keys — one per `FunctionParamNode` kind.
  */
-type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | ScalarSchemaNode;
+type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'paramsType';
 //#endregion
 //#region src/nodes/parameter.d.ts
 type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
@@ -1655,12 +1699,16 @@ type MediaType = 'application/json' | 'application/xml' | 'application/x-www-for
 /**
  * AST node representing one operation response variant.
  *
+ * Mirrors {@link OperationNode.requestBody}: the response body schemas live exclusively inside
+ * the `content` array (one entry per content type), so the same schema is never duplicated at the
+ * node root and inside `content`.
+ *
  * @example
  * ```ts
  * const response: ResponseNode = {
  *   kind: 'Response',
  *   statusCode: '200',
- *   schema: createSchema({ type: 'string' }),
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
@@ -1678,56 +1726,80 @@ type ResponseNode = BaseNode & {
    */
   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.
+   * All available content type entries for this response.
+   *
+   * 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 a union of response types (e.g. `application/json` and `application/xml`).
+   * Body-less responses keep a single entry whose `schema` is the empty/`void` placeholder.
+   *
+   * @example
+   * ```ts
+   * // spec response declares both application/json and application/xml
+   * response.content[0].contentType // 'application/json'
+   * response.content[1].contentType // 'application/xml'
+   * ```
    */
-  keysToOmit?: Array<string>;
+  content?: Array<ContentNode>;
 };
 //#endregion
 //#region src/nodes/operation.d.ts
 type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
 /**
- * AST node representing one API operation.
+ * Transport an operation belongs to.
+ */
+type OperationProtocol = 'http';
+/**
+ * AST node representing an operation request body.
  *
- * @example
- * ```ts
- * const operation: OperationNode = {
- *   kind: 'Operation',
- *   operationId: 'listPets',
- *   method: 'GET',
- *   path: '/pets',
- *   tags: [],
- *   parameters: [],
- *   responses: [],
+ * Body schemas live exclusively inside the `content` array (one entry per content type),
+ * mirroring {@link ResponseNode}.
+ *
+ * @example
+ * ```ts
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
-type OperationNode = BaseNode & {
+type RequestBodyNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'Operation';
+  kind: 'RequestBody';
   /**
-   * Operation identifier, usually from OpenAPI `operationId`.
+   * Human-readable request body description.
    */
-  operationId: string;
+  description?: string;
   /**
-   * HTTP Method like 'GET'
+   * Whether the request body is required (`requestBody.required: true` in the spec).
+   * When `false` or absent, the generated `data` parameter should be optional.
    */
-  method: HttpMethod;
+  required?: boolean;
   /**
-   * OpenAPI-style path string, for example `/pets/{petId}`.
-   * Path parameters retain the `{param}` notation from the original spec.
+   * 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`).
    */
-  path: string;
+  content?: Array<ContentNode>;
+};
+/**
+ * Fields shared by every operation, regardless of transport.
+ */
+type OperationNodeBase = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Operation';
+  /**
+   * Operation identifier, usually from OpenAPI `operationId`.
+   */
+  operationId: string;
   /**
    * Group labels for the operation.
    * Usually copied from OpenAPI `tags`.
@@ -1750,54 +1822,64 @@ type OperationNode = BaseNode & {
    */
   parameters: Array<ParameterNode>;
   /**
-   * Request body metadata for the operation.
+   * Request body 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>;
-    }>;
-  };
+  requestBody?: RequestBodyNode;
   /**
    * Operation responses.
    */
   responses: Array<ResponseNode>;
 };
+/**
+ * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
+ *
+ * @example
+ * ```ts
+ * const operation: HttpOperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   protocol: 'http',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
+ * ```
+ */
+type HttpOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: 'http';
+  /**
+   * HTTP method like `'GET'`.
+   */
+  method: HttpMethod;
+  /**
+   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
+   */
+  path: string;
+};
+/**
+ * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
+ */
+type GenericOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: Exclude<OperationProtocol, 'http'>;
+  method?: never;
+  path?: never;
+};
+/**
+ * AST node representing one API operation.
+ *
+ * Discriminated on `protocol`: an {@link HttpOperationNode} (`protocol: 'http'`) guarantees
+ * `method` and `path`, while a {@link GenericOperationNode} omits them. Narrow with
+ * `isHttpOperationNode(node)` or `node.protocol === 'http'` before reading `method`/`path`.
+ */
+type OperationNode = HttpOperationNode | GenericOperationNode;
 //#endregion
 //#region src/nodes/output.d.ts
 /**
@@ -1826,32 +1908,62 @@ type OutputNode = BaseNode & {
 //#endregion
 //#region src/nodes/root.d.ts
 /**
- * Basic metadata for an API document.
- * Adapters fill fields that exist in their source format.
+ * Metadata for an API document, populated by the adapter and available to every generator.
+ *
+ * All fields are plain JSON-serializable values — no `Set`, no `Map`, no class instances.
+ * Computed fields (`circularNames`, `enumNames`) are pre-calculated once during the adapter
+ * pre-scan so generators never need to iterate the full schema list themselves.
  *
  * @example
  * ```ts
- * const meta: InputMeta = { title: 'Pet API', version: '1.0.0' }
+ * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
  * ```
  */
 type InputMeta = {
   /**
-   * API title (from `info.title` in OAS/AsyncAPI).
+   * API title from `info.title` in the source document.
    */
   title?: string;
   /**
-   * API description (from `info.description` in OAS/AsyncAPI).
+   * API description from `info.description` in the source document.
    */
   description?: string;
   /**
-   * API version string (from `info.version` in OAS/AsyncAPI).
+   * API version string from `info.version` in the source document.
    */
   version?: string;
   /**
-   * Resolved API base URL.
-   * For OpenAPI and AsyncAPI, this comes from the selected server URL.
+   * Resolved base URL from the first matching server entry in the source document.
+   */
+  baseURL?: string | null;
+  /**
+   * Names of schemas that participate in a circular reference chain.
+   * Computed once during the adapter pre-scan — use this instead of calling
+   * `findCircularSchemas` per generator call.
+   *
+   * Convert to a `Set` once at the start of a generator, not per-schema,
+   * to keep lookup O(1) without repeated allocations.
+   *
+   * @example Wrap a circular schema in z.lazy()
+   * ```ts
+   * const circular = new Set(meta.circularNames)
+   * if (circular.has(schema.name)) { ... }
+   * ```
+   */
+  circularNames: ReadonlyArray<string>;
+  /**
+   * Names of schemas whose type is `enum`.
+   * Computed once during the adapter pre-scan — use this instead of filtering
+   * schemas per generator call.
+   *
+   * Convert to a `Set` once at the start of a generator when you need repeated
+   * membership checks, rather than calling `.includes()` per schema.
+   *
+   * @example Check if a referenced schema is an enum
+   * `const enums = new Set(meta.enumNames)`
+   * `const isEnum = enums.has(schemaName)`
    */
-  baseURL?: string;
+  enumNames: ReadonlyArray<string>;
 };
 /**
  * Input AST node that contains all schemas and operations for one API document.
@@ -1880,7 +1992,38 @@ type InputNode = BaseNode & {
    */
   operations: Array<OperationNode>;
   /**
-   * Optional document metadata populated by the adapter.
+   * Document metadata populated by the adapter.
+   */
+  meta: InputMeta;
+};
+/**
+ * Streaming variant of `InputNode` for memory-efficient processing of large API specs.
+ *
+ * `schemas` and `operations` are `AsyncIterable` rather than arrays — each `for await`
+ * loop creates a fresh parse pass from the cached in-memory document, so multiple
+ * consumers (plugins) can iterate independently without keeping all nodes in memory.
+ *
+ * @example
+ * ```ts
+ * for await (const schema of inputStreamNode.schemas) {
+ *   // only this one SchemaNode is live here; previous ones are GC-eligible
+ * }
+ * ```
+ */
+type InputStreamNode = {
+  kind: 'Input';
+  /**
+   * Lazily parsed schema nodes. Each `for await` creates a fresh parse pass, so
+   * multiple plugins can iterate independently without sharing state.
+   */
+  schemas: AsyncIterable<SchemaNode>;
+  /**
+   * Lazily parsed operation nodes. Each `for await` creates a fresh parse pass, so
+   * multiple plugins can iterate independently without sharing state.
+   */
+  operations: AsyncIterable<OperationNode>;
+  /**
+   * Document metadata available immediately, before the first yielded node.
    */
   meta?: InputMeta;
 };
@@ -1905,7 +2048,198 @@ type InputNode = BaseNode & {
  * }
  * ```
  */
-type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | ParamsTypeNode | FunctionNode | ArrowFunctionNode;
+type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | ParamsTypeNode | FunctionNode | ArrowFunctionNode;
+//#endregion
+//#region src/dedupe.d.ts
+/**
+ * A canonical destination for a deduplicated shape: the shared schema name and
+ * the synthetic `$ref` path that points at it.
+ */
+type DedupeCanonical = {
+  /**
+   * Canonical schema name every duplicate occurrence refers to.
+   */
+  name: string;
+  /**
+   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).
+   */
+  ref: string;
+};
+/**
+ * The result of {@link buildDedupePlan}: a lookup from structural signature to its
+ * canonical target, plus the freshly hoisted definitions that must be added to
+ * the schema list.
+ */
+type DedupePlan = {
+  /**
+   * Maps a structural signature to the canonical schema that represents it.
+   */
+  canonicalBySignature: Map<string, DedupeCanonical>;
+  /**
+   * New top-level schema definitions created for inline shapes that had no existing
+   * named component. Nested duplicates inside each definition are already collapsed.
+   */
+  hoisted: Array<SchemaNode>;
+};
+/**
+ * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
+ * The mechanics (grouping, counting, rewriting) live here; the policy lives in the caller.
+ */
+type BuildDedupePlanOptions = {
+  /**
+   * Returns `true` when a node should be deduplicated. This is the only gate, so it must
+   * reject both ineligible kinds (return `false` for anything other than, say, enums and
+   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).
+   */
+  isCandidate: (node: SchemaNode) => boolean;
+  /**
+   * Produces the canonical name for an inline shape with no existing named component.
+   * Return `null` to leave the shape inline (for example when no contextual name exists).
+   */
+  nameFor: (node: SchemaNode, signature: string) => string | null;
+  /**
+   * Builds the `$ref` path for a canonical name.
+   */
+  refFor: (name: string) => string;
+  /**
+   * Minimum number of occurrences before a shape is deduplicated.
+   *
+   * @default 2
+   */
+  minOccurrences?: number;
+};
+/**
+ * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
+ * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
+ * so nested duplicates inside a replaced shape are not visited again.
+ *
+ * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
+ * turned into a reference to itself; nested duplicates are still collapsed.
+ *
+ * @example
+ * ```ts
+ * const next = applyDedupe(operationNode, plan.canonicalBySignature)
+ * ```
+ */
+declare function applyDedupe(node: SchemaNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): SchemaNode;
+declare function applyDedupe(node: OperationNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): OperationNode;
+/**
+ * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
+ *
+ * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
+ * is a named top-level schema, that name becomes the canonical (so other top-level duplicates
+ * and inline copies turn into references to it); otherwise a new definition is hoisted using
+ * `nameFor`. The plan is then applied per node with {@link applyDedupe}.
+ *
+ * @example
+ * ```ts
+ * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
+ *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
+ *   nameFor: (node) => node.name ?? null,
+ *   refFor: (name) => `#/components/schemas/${name}`,
+ * })
+ * ```
+ */
+declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan;
+//#endregion
+//#region src/dialect.d.ts
+/**
+ * The spec-specific decisions a schema parser makes while converting a source
+ * document's schemas into Kubb AST nodes.
+ *
+ * Everything else in an adapter's schema pipeline is generic JSON Schema shared
+ * across specs; the dialect is the one seam where a spec differs — the
+ * "dialect layer" analogue of a database driver targeting Postgres vs MySQL.
+ * Pair it with {@link dispatch}: the rule table decides *which* converter runs,
+ * the dialect answers the spec-specific questions inside them.
+ *
+ * The guard methods (`isReference`, `isDiscriminator`) are type predicates so
+ * converters narrow the schema after a check; the type parameters carry those
+ * narrowed types through.
+ *
+ * Scope: this is the seam for the **JSON Schema family** — OpenAPI, AsyncAPI, and
+ * plain JSON Schema all share `$ref`, `allOf`/`oneOf`, `enum`, and `format`, and
+ * differ only in these few decisions. A spec built on a different type system
+ * (e.g. GraphQL, with non-null wrappers, interfaces, and named-type references
+ * instead of `$ref`) does not implement a `SchemaDialect`; it reuses the universal
+ * layer directly — the `Adapter` port, the AST factories, and {@link dispatch}
+ * with its own rule table — to emit the same nodes.
+ *
+ * @typeParam TSchema - The adapter's schema object type (e.g. an OpenAPI `SchemaObject`).
+ * @typeParam TRef - The narrowed `$ref` pointer type `isReference` proves.
+ * @typeParam TDiscriminated - The narrowed discriminated-schema type `isDiscriminator` proves.
+ * @typeParam TDocument - The source document `resolveRef` resolves against.
+ */
+type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
+  /** Identifies the dialect in logs and while debugging dispatch. */name: string; /** Whether a schema should be treated as nullable. */
+  isNullable: (schema?: TSchema) => boolean; /** Whether a value is a `$ref` pointer object. */
+  isReference: (value?: unknown) => value is TRef; /** Whether a schema carries a structured discriminator (polymorphism). */
+  isDiscriminator: (value?: unknown) => value is TDiscriminated; /** Whether a schema represents binary data (converted to a `blob` node). */
+  isBinary: (schema: TSchema) => boolean; /** Resolves a local `$ref` pointer against the document, or nullish when it cannot. */
+  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
+};
+/**
+ * Identity helper that types a {@link SchemaDialect} for an adapter. Like
+ * `defineParser`, it adds no runtime behavior — it pins the dialect's type for
+ * inference and gives adapter authors a discoverable anchor.
+ *
+ * @example
+ * ```ts
+ * export const oasDialect = defineSchemaDialect({
+ *   name: 'oas',
+ *   isNullable,
+ *   isReference,
+ *   isDiscriminator,
+ *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+ *   resolveRef,
+ * })
+ * ```
+ */
+declare function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
+//#endregion
+//#region src/dispatch.d.ts
+/**
+ * One entry in an ordered dispatch table: a predicate paired with a converter.
+ *
+ * @typeParam TContext - Per-input context handed to every rule. A spec adapter typically
+ *   pre-computes this once per node (the source spec node plus derived fields like a
+ *   normalized type or resolved options) so individual rules stay cheap predicates.
+ * @typeParam TNode - The node a rule produces, e.g. a Kubb AST `SchemaNode`.
+ */
+type DispatchRule<TContext, TNode> = {
+  /** Identifies the rule when reading the table or debugging which branch ran. */name: string; /** Returns `true` when this rule is responsible for the given context. */
+  match: (context: TContext) => boolean;
+  /**
+   * Produces a node for the context, or `null` to fall through to the next rule.
+   *
+   * Returning `null` lets a broad `match` defer: e.g. "has a `format`" matches many schemas,
+   * but only some formats are convertible — the rest fall through to plain `type` handling.
+   */
+  convert: (context: TContext) => TNode | null;
+};
+/**
+ * Walks an ordered list of {@link DispatchRule}s and returns the first node produced.
+ *
+ * This is the shared backbone for spec adapters (OpenAPI today, AsyncAPI and others later).
+ * The contract an adapter follows is intentionally minimal:
+ *
+ *     context → [rule.match → rule.convert] → node
+ *
+ * An adapter derives a context from a source spec node, then declares an ordered table of
+ * rules mapping spec shapes onto Kubb AST nodes. To add support for a new spec, write a new
+ * context type and a new rules table — the traversal here is reused unchanged.
+ *
+ * Order is significant: earlier rules win, so list higher-precedence or more specific shapes
+ * first (e.g. composition keywords before plain `type`). A rule whose `match` returns `true`
+ * may still `convert` to `null` to defer to later rules. When no rule produces a node this
+ * returns `null`, leaving the caller to apply its own fallback.
+ *
+ * @example
+ * ```ts
+ * const node = dispatch(schemaRules, schemaContext) ?? createSchema({ type: fallbackType })
+ * ```
+ */
+declare function dispatch<TContext, TNode>(rules: ReadonlyArray<DispatchRule<TContext, TNode>>, context: TContext): TNode | null;
 //#endregion
 //#region src/infer.d.ts
 /**
@@ -1913,15 +2247,25 @@ type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode |
  */
 type ParserOptions = {
   /**
-   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
+   * How `format: 'date-time'` schemas are represented downstream.
+   * - `false` falls through to a plain `string` (no validation).
+   * - `'string'` emits a datetime string node.
+   * - `'stringOffset'` emits a datetime node with timezone offset.
+   * - `'stringLocal'` emits a local datetime node.
+   * - `'date'` emits a `date` node (JavaScript `Date` object).
    */
   dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
   /**
-   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
+   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
+   * - `'number'` fits most JSON APIs; loses precision above `Number.MAX_SAFE_INTEGER`.
+   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
+   *
+   * @default 'number'
    */
   integerType?: 'number' | 'bigint';
   /**
-   * AST type used when no schema type can be inferred.
+   * AST type used when a schema's type cannot be inferred from the spec
+   * (`additionalProperties: true`, missing `type`, ...).
    */
   unknownType: 'any' | 'unknown' | 'void';
   /**
@@ -1929,7 +2273,8 @@ type ParserOptions = {
    */
   emptySchemaType: 'any' | 'unknown' | 'void';
   /**
-   * Suffix appended to derived enum names when building property schema names.
+   * Suffix appended to derived enum names when Kubb has to invent one
+   * (typically for inline enums on object properties).
    */
   enumSuffix: 'enum' | (string & {});
 };
@@ -1957,7 +2302,7 @@ type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
   allOf: ReadonlyArray<unknown>;
   properties: object;
 }, IntersectionSchemaNode], [{
-  allOf: readonly [unknown, unknown, ...unknown[]];
+  allOf: readonly [unknown, unknown, ...Array<unknown>];
 }, IntersectionSchemaNode], [{
   allOf: ReadonlyArray<unknown>;
 }, SchemaNode], [{
@@ -2050,10 +2395,13 @@ type InferSchema<TSchema extends object, TDateType extends ParserOptions['dateTy
 //#endregion
 //#region src/factory.d.ts
 /**
- * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ * Updates a schema's `optional` and `nullish` flags from a parent's `required`
+ * value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
+ * object properties combine "required" and "nullable" into a single AST.
  *
- * - `optional` is set for non-required, non-nullable schemas.
- * - `nullish` is set for non-required, nullable schemas.
+ * - Non-required + non-nullable → `optional: true`.
+ * - Non-required + nullable → `nullish: true`.
+ * - Required → both flags cleared.
  */
 declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
 /**
@@ -2068,6 +2416,23 @@ declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaN
  * ```
  */
 type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Identity-preserving node update: returns `node` unchanged when every field in
+ * `changes` already equals (by reference) the current value, otherwise a new node
+ * with the changes applied.
+ *
+ * Mirrors the TypeScript compiler's `factory.updateX` contract — pair it with the
+ * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
+ * downstream passes can detect "nothing changed" by identity. Comparison is
+ * shallow: a structurally-equal but newly-allocated array/object counts as a change.
+ *
+ * @example
+ * ```ts
+ * update(node, { name: node.name })        // -> same `node` reference
+ * update(node, { name: 'renamed' })        // -> new node, `name` replaced
+ * ```
+ */
+declare function update<T extends Node>(node: T, changes: Partial<T>): T;
 type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & {
   properties?: Array<PropertyNode>;
   primitive?: 'object';
@@ -2092,6 +2457,15 @@ type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
  * ```
  */
 declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
+/**
+ * Creates an `InputStreamNode` from pre-built `AsyncIterable` sources.
+ *
+ * @example
+ * ```ts
+ * const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+ * ```
+ */
+declare function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputStreamNode;
 /**
  * Creates an `OutputNode` with a stable default for `files`.
  *
@@ -2130,7 +2504,30 @@ declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): Ou
  * })
  * ```
  */
-declare function createOperation(props: Pick<OperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<OperationNode, 'kind' | 'operationId' | 'method' | 'path'>>): OperationNode;
+/**
+ * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
+ */
+type UserContent = Omit<ContentNode, 'kind'>;
+/**
+ * Creates a `ContentNode` for a single request-body or response content type.
+ */
+declare function createContent(props: UserContent): ContentNode;
+/**
+ * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ */
+type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
+  content?: Array<UserContent>;
+};
+/**
+ * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ */
+declare function createRequestBody(props: UserRequestBody): RequestBodyNode;
+declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
+  requestBody?: UserRequestBody;
+}): HttpOperationNode;
+declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
+  requestBody?: UserRequestBody;
+}): GenericOperationNode;
 /**
  * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
  * For object schemas, `properties` defaults to an empty array.
@@ -2222,16 +2619,24 @@ declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'sch
 /**
  * Creates a `ResponseNode`.
  *
+ * Response body schemas live inside `content`. For convenience a single legacy `schema`
+ * (with optional `mediaType`/`keysToOmit`) is normalized into one `content` entry, so the same
+ * schema is never stored both at the node root and inside `content`.
+ *
  * @example
  * ```ts
  * const response = createResponse({
  *   statusCode: '200',
- *   description: 'Success',
- *   schema: createSchema({ type: 'object', properties: [] }),
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
  * })
  * ```
  */
-declare function createResponse(props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>): ResponseNode;
+declare function createResponse(props: Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
+  content?: Array<UserContent>;
+  schema?: SchemaNode;
+  mediaType?: string | null;
+  keysToOmit?: Array<string> | null;
+}): ResponseNode;
 /**
  * Creates a `FunctionParameterNode`.
  *
@@ -2583,10 +2988,10 @@ declare function createJsx(value: string): JsxNode;
  * @example
  * ```ts
  * const schema = createSchema({ type: 'string' })
- * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+ * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
  * ```
  */
-declare function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | undefined;
+declare function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | null;
 /**
  * Returns `true` when the input is an `InputNode`.
  *
@@ -2620,6 +3025,17 @@ declare const isOutputNode: (node: unknown) => node is OutputNode;
  * ```
  */
 declare const isOperationNode: (node: unknown) => node is OperationNode;
+/**
+ * Narrows an `OperationNode` to an `HttpOperationNode`, guaranteeing `method` and `path`.
+ *
+ * @example
+ * ```ts
+ * if (isHttpOperationNode(node)) {
+ *   console.log(node.method, node.path)
+ * }
+ * ```
+ */
+declare function isHttpOperationNode(node: OperationNode): node is HttpOperationNode;
 /**
  * Returns `true` when the input is a `SchemaNode`.
  *
@@ -2651,7 +3067,7 @@ 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;
+  transform: (node: SchemaNode) => TOutput | null;
   /**
    * Options for this printer instance.
    */
@@ -2669,7 +3085,7 @@ type PrinterHandlerContext<TOutput, TOptions extends object> = {
  * }
  * ```
  */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null | undefined;
+type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null;
 /**
  * Partial map of per-node-type handler overrides for a printer.
  *
@@ -2732,13 +3148,13 @@ type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
    * 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;
+  transform: (node: SchemaNode) => T['output'] | null;
   /**
    * 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;
+  print: (node: SchemaNode) => T['printOutput'] | null;
 };
 /**
  * Builder function passed to `definePrinter`.
@@ -2769,22 +3185,27 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
   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.
+ * Defines a schema printer: a function that takes a `SchemaNode` and emits
+ * code in your target language. Each plugin that produces code from schemas
+ * (TypeScript types, Zod schemas, Faker factories) ships a printer built
+ * with this helper.
  *
  * The builder receives resolved options and returns:
- * - `name` — a unique identifier for the printer
- * - `options` — options stored on the returned printer instance
- * - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
- * - `print` _(optional)_ — top-level override exposed as `printer.print`
- *   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
- *   - This keeps recursion safe and avoids self-calls
  *
- * When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+ * - `name` — unique identifier for the printer.
+ * - `options` — stored on the returned printer instance.
+ * - `nodes` — map of `SchemaType` → handler. Handlers return the rendered
+ *   output (a string, a TypeScript AST node, ...) for that schema type.
+ * - `print` (optional) — top-level override exposed as `printer.print`.
+ *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
  *
- * @example Basic usage — Zod schema printer
+ * Without a `print` override, `printer.print` falls back to `printer.transform`
+ * (the node-level dispatcher).
+ *
+ * @example Tiny Zod printer
  * ```ts
+ * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
+ *
  * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
  *
  * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
@@ -2793,7 +3214,9 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  *   nodes: {
  *     string: () => 'z.string()',
  *     object(node) {
- *       const props = node.properties.map(p => `${p.name}: ${this.transform(p.schema)}`).join(', ')
+ *       const props = node.properties
+ *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
+ *         .join(', ')
  *       return `z.object({ ${props} })`
  *     },
  *   },
@@ -2811,22 +3234,22 @@ declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryO
  * )
  * ```
  */
-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"]) => {
+declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null): <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;
+    transform: (node: TNode) => T["output"] | null;
     options: T["options"];
-  }, node: TNodeByKey[K]) => T["output"] | null | undefined }>;
+  }, node: TNodeByKey[K]) => T["output"] | null }>;
   print?: (this: {
-    transform: (node: TNode) => T["output"] | null | undefined;
+    transform: (node: TNode) => T["output"] | null;
     options: T["options"];
-  }, node: TNode) => T["printOutput"] | null | undefined;
+  }, node: TNode) => T["printOutput"] | null;
 }) => (options?: T["options"]) => {
   name: T["name"];
   options: T["options"];
-  transform: (node: TNode) => T["output"] | null | undefined;
-  print: (node: TNode) => T["printOutput"] | null | undefined;
+  transform: (node: TNode) => T["output"] | null;
+  print: (node: TNode) => T["printOutput"] | null;
 };
 //#endregion
 //#region src/refs.d.ts
@@ -2860,9 +3283,36 @@ declare function collectImports<TImport>({
 }: {
   node: SchemaNode;
   nameMapping: Map<string, string>;
-  resolve: (schemaName: string) => TImport | undefined;
+  resolve: (schemaName: string) => TImport | null;
 }): Array<TImport>;
 //#endregion
+//#region src/signature.d.ts
+/**
+ * Computes a deterministic, shape-only signature (a fixed-length content hash) for a schema node.
+ *
+ * Two schemas share a signature when they are structurally identical, ignoring
+ * documentation (`name`, `title`, `description`, `example`, `default`, `deprecated`)
+ * and usage-slot flags (`optional`, `nullish`, `readOnly`, `writeOnly`). `nullable`
+ * is kept because it changes the produced type. `ref` nodes compare by target name,
+ * which also keeps the algorithm terminating on circular shapes.
+ *
+ * @example Two enums with different descriptions share a signature
+ * ```ts
+ * schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+ *   schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
+ * ```
+ */
+declare function schemaSignature(node: SchemaNode): string;
+/**
+ * Returns `true` when two schema nodes are structurally identical under shape-only equality.
+ *
+ * @example
+ * ```ts
+ * isSchemaEqual(a, b) // a and b produce the same TypeScript type
+ * ```
+ */
+declare function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean;
+//#endregion
 //#region src/transformers.d.ts
 /**
  * Replaces a discriminator property's schema with a string enum of allowed values.
@@ -2901,6 +3351,7 @@ declare function setDiscriminatorEnum({
  * ])
  * ```
  */
+declare function mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined>;
 declare function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode>;
 /**
  * Removes enum members that are covered by broader scalar primitives in the same union.
@@ -2923,7 +3374,7 @@ declare function setEnumName(propNode: SchemaNode, parentName: string | null | u
  *
  * `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]];
+type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [OperationNode, InputNode], [RequestBodyNode, OperationNode], [ContentNode, RequestBodyNode | ResponseNode], [SchemaNode, InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
 /**
  * Resolves the parent node type for a given AST node type.
  *
@@ -2970,25 +3421,40 @@ type VisitorContext<T extends Node = Node> = {
   parent?: ParentOf<T>;
 };
 /**
- * Synchronous visitor used by `transform`.
+ * Synchronous visitor consumed by `transform`. Each optional callback runs
+ * for the matching node type. Return a new node to replace it, or `undefined`
+ * to leave it untouched.
  *
- * @example
+ * Plugins typically expose `transformer` so users can supply a `Visitor` that
+ * rewrites operation IDs, drops descriptions, or otherwise tweaks the AST
+ * before printing.
+ *
+ * @example Prefix every operationId
  * ```ts
  * const visitor: Visitor = {
  *   operation(node) {
- *     return { ...node, operationId: `x_${node.operationId}` }
+ *     return { ...node, operationId: `api_${node.operationId}` }
+ *   },
+ * }
+ * ```
+ *
+ * @example Strip schema descriptions
+ * ```ts
+ * const visitor: Visitor = {
+ *   schema(node) {
+ *     return { ...node, description: undefined }
  *   },
  * }
  * ```
  */
 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;
+  input?(node: InputNode, context: VisitorContext<InputNode>): undefined | null | InputNode;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): undefined | null | OutputNode;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): undefined | null | OperationNode;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): undefined | null | SchemaNode;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): undefined | null | PropertyNode;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): undefined | null | ParameterNode;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode;
 };
 /**
  * Utility type for values that can be returned directly or asynchronously.
@@ -3007,13 +3473,13 @@ type MaybePromise<T> = T | Promise<T>;
  * ```
  */
 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>;
+  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<undefined | null | InputNode>;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<undefined | null | OutputNode>;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<undefined | null | OperationNode>;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<undefined | null | SchemaNode>;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<undefined | null | PropertyNode>;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<undefined | null | ParameterNode>;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<undefined | null | ResponseNode>;
 };
 /**
  * Visitor used by `collect`.
@@ -3028,13 +3494,13 @@ type AsyncVisitor = {
  * ```
  */
 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;
+  input?(node: InputNode, context: VisitorContext<InputNode>): T | null | undefined;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | null | undefined;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | null | undefined;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | null | undefined;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | null | undefined;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | null | undefined;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | null | undefined;
 };
 /**
  * Options for `transform`.
@@ -3101,11 +3567,14 @@ type CollectOptions<T> = CollectVisitor<T> & {
   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`).
+ * Async depth-first traversal for side effects. Visitor return values are
+ * ignored. Use `transform` when you want to rewrite nodes.
  *
- * @example
+ * Sibling nodes at each depth run concurrently up to `options.concurrency`
+ * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
+ * work; lower values reduce memory pressure.
+ *
+ * @example Log every operation
  * ```ts
  * await walk(root, {
  *   operation(node) {
@@ -3114,20 +3583,20 @@ type CollectOptions<T> = CollectVisitor<T> & {
  * })
  * ```
  *
- * @example
+ * @example Only visit the root node
  * ```ts
- * // Visit only the current node
- * await walk(root, { depth: 'shallow', root: () => {} })
+ * await walk(root, { depth: 'shallow', input: () => {} })
  * ```
  */
 declare function walk(node: Node, options: WalkOptions): Promise<void>;
 /**
- * Runs a depth-first immutable transform.
+ * Synchronous depth-first transform. Each visitor callback gets a chance to
+ * return a replacement node; `undefined` keeps the original.
  *
- * If a visitor returns a node, it replaces the current node.
- * If it returns `undefined`, the current node stays the same.
+ * The transform is immutable. The original tree is not mutated; a new tree
+ * is returned. Use `depth: 'shallow'` to skip recursion into children.
  *
- * @example
+ * @example Prefix every operationId
  * ```ts
  * const next = transform(root, {
  *   operation(node) {
@@ -3136,10 +3605,12 @@ declare function walk(node: Node, options: WalkOptions): Promise<void>;
  * })
  * ```
  *
- * @example
+ * @example Replace only the root node
  * ```ts
- * // Shallow mode: only transform the input node
- * const next = transform(root, { depth: 'shallow', root: (node) => node })
+ * const next = transform(root, {
+ *   depth: 'shallow',
+ *   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
+ * })
  * ```
  */
 declare function transform(node: InputNode, options: TransformOptions): InputNode;
@@ -3151,23 +3622,33 @@ declare function transform(node: ParameterNode, options: TransformOptions): Para
 declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
 declare function transform(node: Node, options: TransformOptions): Node;
 /**
- * Runs a depth-first synchronous collection pass.
+ * Lazy depth-first collection pass. Yields every non-null value returned by
+ * the visitor callbacks. Use `collect` for the eager array form.
  *
- * Non-`undefined` values returned by visitor callbacks are appended to the result.
- *
- * @example
+ * @example Collect every operationId
  * ```ts
- * const ids = collect(root, {
+ * const ids: string[] = []
+ * for (const id of collectLazy<string>(root, {
  *   operation(node) {
  *     return node.operationId
  *   },
- * })
+ * })) {
+ *   ids.push(id)
+ * }
  * ```
+ */
+declare function collectLazy<T>(node: Node, options: CollectOptions<T>): Generator<T, void, undefined>;
+/**
+ * Eager depth-first collection pass. Returns an array of every non-null value
+ * the visitor callbacks return.
  *
- * @example
+ * @example Collect every operationId
  * ```ts
- * // Collect from only the current node
- * const values = collect(root, { depth: 'shallow', root: () => 'root' })
+ * const ids = collect<string>(root, {
+ *   operation(node) {
+ *     return node.operationId
+ *   },
+ * })
  * ```
  */
 declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
@@ -3194,13 +3675,6 @@ declare function syncSchemaRef(node: SchemaNode): SchemaNode;
  * types, returns `true` only when `representation` is `'string'` rather than `'date'`.
  */
 declare function isStringType(node: SchemaNode): boolean;
-/**
- * Applies casing rules to parameter names and returns a new parameter array.
- *
- * Use this before passing parameters to schema builders so output property keys match
- * the desired casing while preserving `OperationNode.parameters` for other consumers.
- * The input array is not mutated. When `casing` is not set, the original array is returned unchanged.
- */
 declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
 /**
  * Creates a single-property object schema used as a discriminator literal.
@@ -3361,7 +3835,7 @@ declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): st
 /**
  * Resolves the schema name of a ref node, falling back through `ref` → `name` → nested `schema.name`.
  *
- * Returns `undefined` for non-ref nodes or when no name can be resolved. Use this to get a schema's
+ * Returns `null` for non-ref nodes or when no name can be resolved. Use this to get a schema's
  * identifier for type definitions or error messages.
  *
  * @example
@@ -3370,56 +3844,8 @@ declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): st
  * // => 'Pet'
  * ```
  */
-declare function resolveRefName(node: SchemaNode | undefined): string | undefined;
-/**
- * Collects every named schema referenced (transitively) from a node via ref edges.
- *
- * Refs are followed by name only — the resolved `node.schema` is not traversed inline.
- * Use this to determine schema dependencies, build reference graphs, or detect what schemas need to be emitted.
- *
- * @example Collect refs from a single schema
- * ```ts
- * const names = collectReferencedSchemaNames(petSchema)
- * // → Set { 'Category', 'Tag' }
- * ```
- *
- * @example Accumulate refs from multiple schemas into one set
- * ```ts
- * const out = new Set<string>()
- * for (const schema of schemas) {
- *   collectReferencedSchemaNames(schema, out)
- * }
- * ```
- */
+declare function resolveRefName(node: SchemaNode | undefined): string | null;
 declare function collectReferencedSchemaNames(node: SchemaNode | undefined, out?: Set<string>): Set<string>;
-/**
- * Collects the names of all top-level schemas transitively used by a set of operations.
- *
- * An operation uses a schema when any of its parameters, request body content, or responses
- * reference it — directly or indirectly through other named schemas.
- * The walk is iterative and safe against reference cycles.
- *
- * Use this together with `include` filters to determine which schemas from `components/schemas`
- * are reachable from the allowed operations, so that schemas used only by excluded operations
- * are not generated.
- *
- * @example Only generate schemas referenced by included operations
- * ```ts
- * const includedOps = inputNode.operations.filter(op => resolver.resolveOptions(op, { options, include }) !== null)
- * const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
- *
- * for (const schema of inputNode.schemas) {
- *   if (schema.name && !allowed.has(schema.name)) continue
- *   // … generate schema
- * }
- * ```
- *
- * @example Check whether a specific schema is needed
- * ```ts
- * const allowed = collectUsedSchemaNames(includedOps, inputNode.schemas)
- * allowed.has('OrderStatus') // false when no included operation references OrderStatus
- * ```
- */
 declare function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
 /**
  * Identifies all schemas that participate in circular dependency chains, including direct self-loops.
@@ -3447,5 +3873,5 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-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, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createResponse, createSchema, createSource, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
+export { type ArraySchemaNode, type ArrowFunctionNode, AsyncVisitor, type BaseNode, type BreakNode, BuildDedupePlanOptions, type CodeNode, CollectOptions, CollectVisitor, type ComplexSchemaType, type ConstNode, type DateSchemaNode, type DatetimeSchemaNode, DedupeCanonical, DedupePlan, DispatchRule, DistributiveOmit, type EnumSchemaNode, type EnumValueNode, type ExportNode, type FileNode, type FormatStringSchemaNode, type FunctionNode, type FunctionNodeType, type FunctionParamNode, type FunctionParameterNode, type FunctionParametersNode, type GenericOperationNode, type HttpMethod, type HttpOperationNode, type HttpStatusCode, type ImportNode, InferSchema, InferSchemaNode, type InputMeta, type InputNode, type InputStreamNode, type IntersectionSchemaNode, type Ipv4SchemaNode, type Ipv6SchemaNode, type JSDocNode, type JsxNode, type MediaType, Node, type NodeKind, type NumberSchemaNode, type ObjectSchemaNode, type OperationNode, type OperationNodeBase, OperationParamsResolver, type OperationProtocol, 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, SchemaDialect, 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, applyDedupe, buildDedupePlan, caseParams, childName, collect, collectImports, collectLazy, collectReferencedSchemaNames, collectUsedSchemaNames, containsCircularRef, createArrowFunction, createBreak, createConst, createContent, createDiscriminantNode, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createInput, createJsx, createOperation, createOperationParams, createOutput, createParameter, createParameterGroup, createParamsType, createPrinterFactory, createProperty, createRequestBody, createResponse, createSchema, createSource, createStreamInput, createText, createType, definePrinter, defineSchemaDialect, dispatch, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaEqual, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, mergeAdjacentObjectsLazy, narrowSchema, nodeKinds, resolveRefName, schemaSignature, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, update, walk };
 //# sourceMappingURL=index.d.ts.map