@kubb/ast 5.0.0-beta.29 → 5.0.0-beta.30

package/dist/index.d.ts

@@ -190,6 +190,105 @@ declare const mediaTypes: {
   readonly videoMp4: "video/mp4";
 };
 //#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/nodes/base.d.ts
 /**
  * `kind` values used by AST nodes.
@@ -199,7 +298,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.
  *
@@ -510,1087 +609,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 | null;
+  name: string;
   /**
-   * Import entire module as namespace.
-   * - `true` generates `import * as Name from './path'`
-   * - `false` generates standard import
-   * @default false
+   * Property schema.
    */
-  isNameSpace?: boolean | null;
+  schema: SchemaNode;
   /**
-   * When set, the import path is resolved relative to this root.
+   * Whether the property is required.
    */
-  root?: string | null;
+  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';
+'string'
+/**
+ * Floating-point number.
+ */
+| 'number'
+/**
+ * Integer number.
+ */
+| 'integer'
+/**
+ * Big integer number.
+ */
+| 'bigint'
+/**
+ * Boolean value.
+ */
+| 'boolean'
+/**
+ * Null value.
+ */
+| 'null'
+/**
+ * Any value.
+ */
+| 'any'
+/**
+ * Unknown value.
+ */
+| 'unknown'
+/**
+ * No value (`void`).
+ */
+| 'void'
+/**
+ * Never value.
+ */
+| 'never'
+/**
+ * Object value.
+ */
+| 'object'
+/**
+ * Array value.
+ */
+| 'array'
+/**
+ * Date value.
+ */
+| 'date';
+/**
+ * Composite schema types.
+ */
+type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
+/**
+ * Schema types that need special handling in generators.
+ */
+type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
+/**
+ * All schema type strings.
+ */
+type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+/**
+ * Scalar schema types without extra object/array/ref structure.
+ */
+type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+/**
+ * Fields shared by all schema nodes.
+ */
+type SchemaNodeBase = BaseNode & {
   /**
-   * Export name(s) to be used. When omitted, generates a wildcard export.
-   * @example ['useState']
-   * @example 'React'
+   * Node kind.
    */
-  name?: string | Array<string> | null;
+  kind: 'Schema';
   /**
-   * Path for the export.
-   * @example '@kubb/core'
+   * 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.
    */
-  path: string;
+  name?: string | null;
   /**
-   * Add type-only export prefix.
-   * - `true` generates `export type { Type } from './path'`
-   * - `false` generates `export { Type } from './path'`
-   * @default false
+   * Short schema title.
    */
-  isTypeOnly?: boolean | null;
+  title?: string;
   /**
-   * Export as an aliased namespace.
-   * - `true` generates `export * as aliasName from './path'`
-   * - `false` generates a standard export
-   * @default false
+   * Schema description text.
    */
-  asAlias?: boolean | null;
-};
-/**
- * Represents a fragment of source code within a file.
- *
- * @example Named exportable source
- * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
- * ```
- *
- * @example Inline unnamed code block
- * ```ts
- * createSource({ nodes: [createText('const x = 1')] })
- * ```
- */
-type SourceNode = BaseNode & {
-  kind: 'Source';
+  description?: string;
   /**
-   * Optional name identifying this source (used for deduplication and barrel generation).
+   * Whether `null` is allowed.
    */
-  name?: string | null;
+  nullable?: boolean;
   /**
-   * Mark this source as a type-only export.
-   * @default false
+   * Whether the field is optional.
    */
-  isTypeOnly?: boolean | null;
+  optional?: boolean;
   /**
-   * Include `export` keyword in the generated source.
-   * @default false
+   * Both optional and nullable (`optional` + `nullable`).
    */
-  isExportable?: boolean | null;
+  nullish?: boolean;
   /**
-   * Include this source in barrel/index file generation.
-   * @default false
+   * Whether the schema is deprecated.
    */
-  isIndexable?: boolean | null;
+  deprecated?: boolean;
   /**
-   * Structured child nodes representing the content of this source fragment, in DOM order.
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   * Whether the schema is read-only.
    */
-  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';
+  readOnly?: boolean;
   /**
-   * Unique identifier derived from a SHA256 hash of the file path. Computed
-   * by `createFile`; callers do not need to provide it.
+   * Whether the schema is write-only.
    */
-  id: string;
+  writeOnly?: boolean;
   /**
-   * File name without extension, derived from `baseName`.
-   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   * Default value.
    */
-  name: string;
+  default?: unknown;
   /**
-   * File base name, including extension.
-   * Based on UNIX basename: `${name}${extname}`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   * Example value.
    */
-  baseName: `${string}.${string}`;
+  example?: unknown;
   /**
-   * Full qualified path to the file.
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
    */
-  path: string;
+  primitive?: PrimitiveSchemaType;
   /**
-   * File extension extracted from `baseName`.
+   * Schema `format` value.
    */
-  extname: Extname;
+  format?: string;
+};
+/**
+ * Object schema with ordered properties.
+ *
+ * @example
+ * ```ts
+ * const objectSchema: ObjectSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'object',
+ *   properties: [],
+ * }
+ * ```
+ */
+type ObjectSchemaNode = SchemaNodeBase & {
   /**
-   * Deduplicated list of source code fragments.
+   * Schema type discriminator.
    */
-  sources: Array<SourceNode>;
+  type: 'object';
   /**
-   * Deduplicated list of import declarations.
+   * Primitive type — always `'object'` for object schemas.
    */
-  imports: Array<ImportNode>;
+  primitive: 'object';
   /**
-   * Deduplicated list of export declarations.
+   * Ordered object properties.
    */
-  exports: Array<ExportNode>;
+  properties: Array<PropertyNode>;
   /**
-   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
+   * 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)
    */
-  meta?: TMeta;
+  additionalProperties?: SchemaNode | boolean;
   /**
-   * Optional banner prepended to the generated file content.
-   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
+   * Pattern-based property schemas.
    */
-  banner?: string | null;
+  patternProperties?: Record<string, SchemaNode>;
   /**
-   * Optional footer appended to the generated file content.
-   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
+   * Minimum number of properties allowed.
    */
-  footer?: string | null;
+  minProperties?: number;
+  /**
+   * Maximum number of properties allowed.
+   */
+  maxProperties?: number;
 };
-//#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 }
- * ```
+ * Array-like schema (`array` or `tuple`).
  *
- * @example Member variant
+ * @example
  * ```ts
- * createParamsType({ variant: 'member', base: 'PathParams', key: 'petId' })
- * // PathParams['petId']
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
+ * }
  * ```
  */
-type ParamsTypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'ParamsType';
-} & ({
+type ArraySchemaNode = SchemaNodeBase & {
   /**
-   * Reference variant — a plain type name or identifier.
-   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
+   * Schema type discriminator (`array` or `tuple`).
    */
-  variant: 'reference';
+  type: 'array' | 'tuple';
   /**
-   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
+   * Item schemas.
    */
-  name: string;
-} | {
+  items?: Array<SchemaNode>;
   /**
-   * Struct variant — an inline anonymous type grouping named fields.
-   * TypeScript renders as `{ key: Type; other?: OtherType }`.
+   * Tuple rest-item schema for elements beyond positional `items`.
    */
-  variant: 'struct';
+  rest?: SchemaNode;
   /**
-   * Properties of the struct type.
+   * Minimum item count (or tuple length).
    */
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
+  min?: number;
   /**
-   * Member variant — a single named field accessed from a group type.
-   * TypeScript renders as `Base['key']`.
+   * Maximum item count (or tuple length).
    */
-  variant: 'member';
+  max?: number;
   /**
-   * Base type name, e.g. `'DeletePetPathParams'`.
+   * Whether all items must be unique.
    */
-  base: string;
+  unique?: boolean;
+};
+/**
+ * Shared shape for union and intersection schemas.
+ */
+type CompositeSchemaNodeBase = SchemaNodeBase & {
   /**
-   * The field name to access, e.g. `'petId'`.
+   * Member schemas.
    */
-  key: string;
-});
+  members?: Array<SchemaNode>;
+};
 /**
- * AST node for one function parameter.
- *
- * @example Required parameter
- * `name: Type`
- *
- * @example Optional parameter
- * `name?: Type`
- *
- * @example Parameter with default value
- * `name: Type = defaultValue`
+ * Union schema, often from `oneOf` or `anyOf`.
  *
- * @example Rest parameter
- * `...name: Type[]`
+ * @example
+ * ```ts
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
+ * }
+ * ```
  */
-type FunctionParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'FunctionParameter';
+type UnionSchemaNode = CompositeSchemaNodeBase & {
   /**
-   * Parameter name in the generated signature.
+   * Schema type discriminator.
    */
-  name: string;
+  type: 'union';
   /**
-   * 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']`
+   * Discriminator property name from OpenAPI `discriminator.propertyName`.
    */
-  type?: ParamsTypeNode;
+  discriminatorPropertyName?: string;
   /**
-   * When `true` the parameter is emitted as a rest parameter.
-   *
-   * @example Rest parameter
-   * `...name: Type[]`
+   * 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`).
    */
-  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;
-}
+  strategy?: 'one' | 'any';
+};
 /**
- * Required parameter, or a parameter with a default value.
- *
- * @example Required
- * `name: Type`
+ * Intersection schema, often from `allOf`.
  *
- * @example With default
- * `name: Type = default`
+ * @example
+ * ```ts
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
+ * }
+ * ```
  */
-| {
-  optional?: false;
-  default?: string;
-});
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'intersection';
+};
 /**
- * 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`
+ * One named enum item.
  */
-type ParameterGroupNode = BaseNode & {
+type EnumValueNode = {
   /**
-   * Node kind.
+   * Enum item name.
    */
-  kind: 'ParameterGroup';
+  name: string;
   /**
-   * The individual parameters that form the group.
-   * Rendered as a destructured object or spread inline when `inline` is `true`.
+   * Enum item value.
    */
-  properties: Array<FunctionParameterNode>;
+  value: string | number | boolean;
   /**
-   * Optional explicit type annotation for the whole group.
-   * When absent, printers auto-compute it from `properties`.
+   * Primitive type of the enum value.
    */
-  type?: ParamsTypeNode;
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
+};
+/**
+ * Enum schema node.
+ *
+ * @example
+ * ```ts
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
+ * }
+ * ```
+ */
+type EnumSchemaNode = SchemaNodeBase & {
   /**
-   * When `true`, `properties` are emitted as individual top-level parameters instead of
-   * being wrapped in a single grouped construct.
-   *
-   * @default false
+   * Schema type discriminator.
    */
-  inline?: boolean;
+  type: 'enum';
   /**
-   * Whether the group as a whole is optional.
-   * If omitted, printers infer this from child properties.
+   * Enum values in simple form.
    */
-  optional?: boolean;
+  enumValues?: Array<string | number | boolean | null>;
   /**
-   * Default value for the group, written verbatim after `=`.
-   * Commonly `'{}'` to allow omitting the argument entirely.
+   * Enum values in named form.
+   * If present, this is used instead of `enumValues`.
    */
-  default?: string;
+  namedEnumValues?: Array<EnumValueNode>;
 };
 /**
- * AST node for a complete function parameter list.
- *
- * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
- * Nodes are plain immutable data.
+ * Reference schema that points to another schema definition.
  *
- * 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 refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
+ * ```
  */
-type FunctionParametersNode = BaseNode & {
+type RefSchemaNode = SchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'FunctionParameters';
+  type: 'ref';
   /**
-   * Ordered parameter nodes.
+   * Referenced schema name.
+   * `null` means Kubb has processed this and determined there is no applicable name.
    */
-  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
+  name?: string | null;
+  /**
+   * Original `$ref` path, for example, `#/components/schemas/Order`.
+   * Used to resolve names later.
+   */
+  ref?: string;
+  /**
+   * Pattern copied from a sibling `pattern` field.
+   */
+  pattern?: string;
+  /**
+   * The fully-parsed schema that this ref resolves to.
+   * Populated during OAS parsing when the referenced definition can be resolved.
+   * `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.
+   */
+  schema?: SchemaNode | null;
 };
 /**
- * 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.
+ * Datetime schema.
  *
  * @example
  * ```ts
- * const property: PropertyNode = {
- *   kind: 'Property',
- *   name: 'id',
- *   schema: createSchema({ type: 'integer' }),
- *   required: true,
- * }
+ * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
  * ```
  */
-type PropertyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Property';
+type DatetimeSchemaNode = SchemaNodeBase & {
   /**
-   * Property key.
+   * Schema type discriminator.
    */
-  name: string;
+  type: 'datetime';
   /**
-   * Property schema.
+   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
    */
-  schema: SchemaNode;
+  offset?: boolean;
   /**
-   * Whether the property is required.
+   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
    */
-  required: boolean;
+  local?: 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.
+ * Shared base for `date` and `time` schemas.
  */
-type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
+type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: T;
+  /**
+   * Output representation in generated code.
+   */
+  representation: 'date' | 'string';
+};
 /**
- * All schema type strings.
+ * Date schema node.
+ *
+ * @example
+ * ```ts
+ * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
+ * ```
  */
-type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
 /**
- * Scalar schema types without extra object/array/ref structure.
+ * Time schema node.
+ *
+ * @example
+ * ```ts
+ * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
+ * ```
  */
-type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
 /**
- * Fields shared by all schema nodes.
+ * String schema node.
+ *
+ * @example
+ * ```ts
+ * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
+ * ```
  */
-type SchemaNodeBase = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Schema';
-  /**
-   * Schema name for named definitions (for example, `"Pet"`).
-   * Inline schemas omit this field.
-   * `null` means kubb has processed this and determined there is no applicable name.
-   * `undefined` means the name has not been set yet.
-   */
-  name?: string | null;
-  /**
-   * Short schema title.
-   */
-  title?: string;
-  /**
-   * Schema description text.
-   */
-  description?: string;
+type StringSchemaNode = SchemaNodeBase & {
   /**
-   * Whether `null` is allowed.
+   * Schema type discriminator.
    */
-  nullable?: boolean;
+  type: 'string';
   /**
-   * Whether the field is optional.
+   * Minimum string length.
    */
-  optional?: boolean;
+  min?: number;
   /**
-   * Both optional and nullable (`optional` + `nullable`).
+   * Maximum string length.
    */
-  nullish?: boolean;
+  max?: number;
   /**
-   * Whether the schema is deprecated.
+   * Regex pattern.
    */
-  deprecated?: boolean;
+  pattern?: string;
+};
+/**
+ * Numeric schema (`number`, `integer`, or `bigint`).
+ *
+ * @example
+ * ```ts
+ * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
+ * ```
+ */
+type NumberSchemaNode = SchemaNodeBase & {
   /**
-   * Whether the schema is read-only.
+   * Schema type discriminator.
    */
-  readOnly?: boolean;
+  type: 'number' | 'integer' | 'bigint';
   /**
-   * Whether the schema is write-only.
+   * Minimum value.
    */
-  writeOnly?: boolean;
+  min?: number;
   /**
-   * Default value.
+   * Maximum value.
    */
-  default?: unknown;
+  max?: number;
   /**
-   * Example value.
+   * Exclusive minimum value.
    */
-  example?: unknown;
+  exclusiveMinimum?: number;
   /**
-   * Base primitive type.
-   * For example, this is `'string'` for a `uuid` schema.
+   * Exclusive maximum value.
    */
-  primitive?: PrimitiveSchemaType;
+  exclusiveMaximum?: number;
   /**
-   * Schema `format` value.
+   * The value must be a multiple of this number.
    */
-  format?: string;
+  multipleOf?: number;
 };
 /**
- * Object schema with ordered properties.
+ * Scalar schema with no extra constraints.
  *
  * @example
  * ```ts
- * const objectSchema: ObjectSchemaNode = {
- *   kind: 'Schema',
- *   type: 'object',
- *   properties: [],
- * }
+ * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
  * ```
  */
-type ObjectSchemaNode = SchemaNodeBase & {
+type ScalarSchemaNode = SchemaNodeBase & {
   /**
    * Schema type discriminator.
    */
-  type: 'object';
-  /**
-   * Primitive type — always `'object'` for object schemas.
-   */
-  primitive: 'object';
-  /**
-   * Ordered object properties.
-   */
-  properties: Array<PropertyNode>;
+  type: ScalarSchemaType;
+};
+/**
+ * URL schema node.
+ * Can include an OpenAPI-style path template for template literal types.
+ *
+ * @example
+ * ```ts
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
+ * ```
+ */
+type UrlSchemaNode = SchemaNodeBase & {
   /**
-   * 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)
+   * Schema type discriminator.
    */
-  additionalProperties?: SchemaNode | boolean;
+  type: 'url';
   /**
-   * Pattern-based property schemas.
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
    */
-  patternProperties?: Record<string, SchemaNode>;
+  path?: string;
   /**
-   * Minimum number of properties allowed.
+   * Minimum string length.
    */
-  minProperties?: number;
+  min?: number;
   /**
-   * Maximum number of properties allowed.
+   * Maximum string length.
    */
-  maxProperties?: number;
+  max?: number;
 };
 /**
- * Array-like schema (`array` or `tuple`).
+ * Format-string schema for string-based formats that support length constraints.
  *
  * @example
  * ```ts
- * const arraySchema: ArraySchemaNode = {
- *   kind: 'Schema',
- *   type: 'array',
- *   items: [],
- * }
+ * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
  * ```
  */
-type ArraySchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator (`array` or `tuple`).
-   */
-  type: 'array' | 'tuple';
-  /**
-   * Item schemas.
-   */
-  items?: Array<SchemaNode>;
+type FormatStringSchemaNode = SchemaNodeBase & {
   /**
-   * Tuple rest-item schema for elements beyond positional `items`.
+   * Schema type discriminator.
    */
-  rest?: SchemaNode;
+  type: 'uuid' | 'email';
   /**
-   * Minimum item count (or tuple length).
+   * 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.
    */
-  strategy?: 'one' | 'any';
+  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
 /**
- * Intersection schema, often from `allOf`.
+ * 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
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
  * ```ts
- * const intersectionSchema: IntersectionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'intersection',
- *   members: [],
- * }
+ * 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 IntersectionSchemaNode = CompositeSchemaNodeBase & {
+type ImportNode = BaseNode & {
+  kind: 'Import';
   /**
-   * Schema type discriminator.
+   * Import name(s) to be used.
+   * @example ['useState']
+   * @example 'React'
    */
-  type: 'intersection';
+  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.
+   */
+  root?: string | null;
 };
 /**
- * One named enum item.
+ * Represents a language-agnostic export/public API declaration.
+ *
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
+ * ```ts
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
+ *
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * ```
+ *
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
+ * ```ts
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * ```
  */
-type EnumValueNode = {
+type ExportNode = BaseNode & {
+  kind: 'Export';
   /**
-   * Enum item name.
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   * @example ['useState']
+   * @example 'React'
    */
-  name: string;
+  name?: string | Array<string> | null;
   /**
-   * Enum item value.
+   * Path for the export.
+   * @example '@kubb/core'
    */
-  value: string | number | boolean;
+  path: string;
   /**
-   * Primitive type of the enum value.
+   * Add type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   * @default false
    */
-  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
+  isTypeOnly?: boolean | null;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   * @default false
+   */
+  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';
+  /**
+   * Optional name identifying this source (used for deduplication and barrel generation).
+   */
+  name?: string | null;
+  /**
+   * Mark this source as a type-only export.
+   * @default false
+   */
+  isTypeOnly?: boolean | null;
   /**
-   * Schema type discriminator.
+   * Include `export` keyword in the generated source.
+   * @default false
    */
-  type: 'enum';
+  isExportable?: boolean | null;
   /**
-   * Enum values in simple form.
+   * Include this source in barrel/index file generation.
+   * @default false
    */
-  enumValues?: Array<string | number | boolean | null>;
+  isIndexable?: boolean | null;
   /**
-   * Enum values in named form.
-   * If present, this is used instead of `enumValues`.
+   * 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.
    */
-  namedEnumValues?: Array<EnumValueNode>;
+  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.
-   * `null` means Kubb has processed this and determined there is no applicable name.
+   * File name without extension, derived from `baseName`.
+   * @link https://nodejs.org/api/path.html#pathformatpathobject
    */
-  name?: string | null;
+  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.
-   * `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.
+   * File extension extracted from `baseName`.
    */
-  schema?: SchemaNode | null;
-};
-/**
- * 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;
+} | {
   /**
-   * Regex pattern.
+   * Struct variant — an inline anonymous type grouping named fields.
+   * TypeScript renders as `{ key: Type; other?: OtherType }`.
    */
-  pattern?: string;
-};
-/**
- * Numeric schema (`number`, `integer`, or `bigint`).
- *
- * @example
- * ```ts
- * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
- * ```
- */
-type NumberSchemaNode = SchemaNodeBase & {
+  variant: 'struct';
   /**
-   * Schema type discriminator.
+   * Properties of the struct type.
    */
-  type: 'number' | 'integer' | 'bigint';
+  properties: Array<{
+    name: string;
+    optional: boolean;
+    type: ParamsTypeNode;
+  }>;
+} | {
   /**
-   * Minimum value.
+   * Member variant — a single named field accessed from a group type.
+   * TypeScript renders as `Base['key']`.
    */
-  min?: number;
+  variant: 'member';
   /**
-   * Maximum value.
+   * Base type name, e.g. `'DeletePetPathParams'`.
    */
-  max?: number;
+  base: string;
   /**
-   * Exclusive minimum value.
+   * The field name to access, e.g. `'petId'`.
    */
-  exclusiveMinimum?: number;
+  key: string;
+});
+/**
+ * AST node for one function parameter.
+ *
+ * @example Required parameter
+ * `name: Type`
+ *
+ * @example Optional parameter
+ * `name?: Type`
+ *
+ * @example Parameter with default value
+ * `name: Type = defaultValue`
+ *
+ * @example Rest parameter
+ * `...name: Type[]`
+ */
+type FunctionParameterNode = BaseNode & {
   /**
-   * Exclusive maximum value.
+   * Node kind.
    */
-  exclusiveMaximum?: number;
+  kind: 'FunctionParameter';
   /**
-   * The value must be a multiple of this number.
+   * Parameter name in the generated signature.
    */
-  multipleOf?: number;
-};
+  name: string;
+  /**
+   * Type annotation as a structured {@link ParamsTypeNode}.
+   * Omit for untyped output.
+   *
+   * @example Reference type node
+   * `{ kind: 'ParamsType', variant: 'reference', name: 'string' }` → `petId: string`
+   *
+   * @example Struct type node
+   * `{ kind: 'ParamsType', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
+   *
+   * @example Member type node
+   * `{ kind: 'ParamsType', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
+   */
+  type?: ParamsTypeNode;
+  /**
+   * When `true` the parameter is emitted as a rest parameter.
+   *
+   * @example Rest parameter
+   * `...name: Type[]`
+   */
+  rest?: boolean;
+}
 /**
- * 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';
@@ -1704,59 +1839,66 @@ type ResponseNode = BaseNode & {
    * response.content[1].contentType // 'application/xml'
    * ```
    */
-  content?: Array<{
-    /**
-     * The content type for this entry (e.g. `'application/json'`).
-     */
-    contentType: string;
-    /**
-     * Response 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 `writeOnly` fields that should not appear in response types.
-     */
-    keysToOmit?: Array<string> | null;
-  }>;
+  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.
+ *
+ * Body schemas live exclusively inside the `content` array (one entry per content type),
+ * mirroring {@link ResponseNode}.
  *
  * @example
  * ```ts
- * const operation: OperationNode = {
- *   kind: 'Operation',
- *   operationId: 'listPets',
- *   method: 'GET',
- *   path: '/pets',
- *   tags: [],
- *   parameters: [],
- *   responses: [],
+ * 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`.
@@ -1779,54 +1921,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> | null;
-    }>;
-  };
+  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
 /**
@@ -1995,7 +2147,7 @@ type InputStreamNode = {
  * }
  * ```
  */
-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/infer.d.ts
 /**
@@ -2172,6 +2324,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';
@@ -2243,7 +2412,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.
@@ -2347,7 +2539,8 @@ declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'sch
  * })
  * ```
  */
-declare function createResponse(props: Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode'>> & {
+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;
@@ -2740,6 +2933,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`.
  *
@@ -3051,7 +3255,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.
  *
@@ -3550,5 +3754,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 InputStreamNode, 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, collectLazy, 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, createStreamInput, createText, createType, definePrinter, enumPropName, extractRefName, extractStringsFromNodes, findCircularSchemas, findDiscriminator, httpMethods, isInputNode, isOperationNode, isOutputNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, mergeAdjacentObjectsLazy, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, walk };
+export { type ArraySchemaNode, type ArrowFunctionNode, AsyncVisitor, type BaseNode, type BreakNode, type CodeNode, CollectOptions, CollectVisitor, type ComplexSchemaType, type ConstNode, type DateSchemaNode, type DatetimeSchemaNode, 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, 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, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, mergeAdjacentObjectsLazy, narrowSchema, nodeKinds, resolveRefName, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, syncSchemaRef, transform, update, walk };
 //# sourceMappingURL=index.d.ts.map