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

package/dist/{types-BL7RpQAE.d.ts → ast-ClnJg9BN.d.ts}

@@ -1,166 +1,125 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
+import { n as __name } from "./chunk-CNktS9qV.js";
 
-//#region src/constants.d.ts
+//#region src/nodes/base.d.ts
 /**
- * Traversal depth for AST visitor utilities.
+ * `kind` values used by AST nodes.
  *
- * - `'shallow'` visits only the immediate node, skipping children.
- * - `'deep'` recursively visits all descendant nodes.
+ * @example
+ * ```ts
+ * const kind: NodeKind = 'Schema'
+ * ```
  */
-type VisitorDepth = 'shallow' | 'deep';
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | 'FunctionParameter' | 'FunctionParameters' | 'TypeLiteral' | 'IndexedAccessType' | 'ObjectBindingPattern' | 'Type' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
 /**
- * Schema type discriminators used by all AST schema nodes.
+ * Base shape shared by all AST nodes.
  *
- * These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).
- * Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),
- * and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.
+ * @example
+ * ```ts
+ * const base: BaseNode = { kind: 'Input' }
+ * ```
  */
-declare const schemaTypes: {
-  /**
-   * Text value.
-   */
-  readonly string: "string";
-  /**
-   * Floating-point number (`float`, `double`).
-   */
-  readonly number: "number";
-  /**
-   * Whole number (`int32`). Use `bigint` for `int64`.
-   */
-  readonly integer: "integer";
-  /**
-   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
-   */
-  readonly bigint: "bigint";
-  /**
-   * Boolean value
-   */
-  readonly boolean: "boolean";
-  /**
-   * Explicit null value.
-   */
-  readonly null: "null";
-  /**
-   * Any value (no type restriction).
-   */
-  readonly any: "any";
-  /**
-   * Unknown value (must be narrowed before usage).
-   */
-  readonly unknown: "unknown";
-  /**
-   * No return value (`void`).
-   */
-  readonly void: "void";
-  /**
-   * Object with named properties.
-   */
-  readonly object: "object";
-  /**
-   * Sequential list of items.
-   */
-  readonly array: "array";
-  /**
-   * Fixed-length list with position-specific items.
-   */
-  readonly tuple: "tuple";
-  /**
-   * "One of" multiple schema members.
-   */
-  readonly union: "union";
-  /**
-   * "All of" multiple schema members.
-   */
-  readonly intersection: "intersection";
-  /**
-   * Enum schema.
-   */
-  readonly enum: "enum";
-  /**
-   * Reference to another schema.
-   */
-  readonly ref: "ref";
-  /**
-   * Calendar date (for example `2026-03-24`).
-   */
-  readonly date: "date";
-  /**
-   * Date-time value (for example `2026-03-24T09:00:00Z`).
-   */
-  readonly datetime: "datetime";
-  /**
-   * Time-only value (for example `09:00:00`).
-   */
-  readonly time: "time";
+type BaseNode = {
   /**
-   * UUID value.
+   * Node discriminator.
    */
-  readonly uuid: "uuid";
+  kind: NodeKind;
+};
+//#endregion
+//#region src/node.d.ts
+/**
+ * Visitor callback names, one per traversable node kind. Kept in sync with the
+ * keys of `Visitor` in `visitor.ts`.
+ */
+type VisitorKey = 'input' | 'output' | 'operation' | 'schema' | 'property' | 'parameter' | 'response';
+/**
+ * Distributive `Omit` that preserves each member of a union.
+ *
+ * @example
+ * ```ts
+ * type A = { kind: 'a'; keep: string; drop: number }
+ * type B = { kind: 'b'; keep: boolean; drop: number }
+ * type Result = DistributiveOmit<A | B, 'drop'>
+ * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
+ * ```
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Updates a schema's `optional` and `nullish` flags from a parent's `required`
+ * value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
+ * object properties combine "required" and "nullable" into a single AST.
+ *
+ * - Non-required + non-nullable → `optional: true`.
+ * - Non-required + nullable → `nullish: true`.
+ * - Required → both flags cleared.
+ */
+declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
+/**
+ * The single definition derived from one {@link defineNode} call: the node's
+ * `create` builder, its `is` guard, and the traversal metadata the registry
+ * collects into the visitor tables.
+ */
+type NodeDef<TNode extends BaseNode = BaseNode, TInput = never> = {
   /**
-   * Email address value.
+   * Node discriminator this definition owns.
    */
-  readonly email: "email";
+  kind: NodeKind;
   /**
-   * URL value.
+   * Builds a node from its input, applying `defaults` and the optional `build` hook.
    */
-  readonly url: "url";
+  create: (input: TInput) => TNode;
   /**
-   * IPv4 address value.
+   * Type guard matching this node kind.
    */
-  readonly ipv4: "ipv4";
+  is: (node: unknown) => node is TNode;
   /**
-   * IPv6 address value.
+   * Child node fields in traversal order. Feeds `VISITOR_KEYS`.
    */
-  readonly ipv6: "ipv6";
+  children?: ReadonlyArray<string>;
   /**
-   * Binary/blob value.
+   * Visitor callback name. Feeds `VISITOR_KEY_BY_KIND`.
    */
-  readonly blob: "blob";
+  visitorKey?: VisitorKey;
   /**
-   * Impossible value (`never`).
+   * When `true`, `create` is rerun after children are rebuilt so computed fields
+   * stay in sync. Feeds `nodeRebuilders`.
    */
-  readonly never: "never";
+  rebuild?: boolean;
 };
-/**
- * HTTP method identifiers used by operation nodes.
- *
- * Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).
- */
-declare const httpMethods: {
-  readonly get: "GET";
-  readonly post: "POST";
-  readonly put: "PUT";
-  readonly patch: "PATCH";
-  readonly delete: "DELETE";
-  readonly head: "HEAD";
-  readonly options: "OPTIONS";
-  readonly trace: "TRACE";
+type DefineNodeConfig<TNode extends BaseNode, TInput, TBuilt extends object> = {
+  kind: TNode['kind'];
+  defaults?: Partial<TNode>;
+  build?: (input: TInput) => TBuilt;
+  children?: ReadonlyArray<string>;
+  visitorKey?: VisitorKey;
+  rebuild?: boolean;
 };
-//#endregion
-//#region src/nodes/base.d.ts
 /**
- * `kind` values used by AST nodes.
+ * Defines a node once and derives its `create` builder, `is` guard, and traversal
+ * metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
+ * `kind`, so node construction lives in one place without scattered `as` casts.
  *
- * @example
+ * Set `rebuild: true` when the `build` hook derives fields from children. After a
+ * transform rewrites those children, the registry reruns `create` so the derived
+ * fields stay correct.
+ *
+ * @example Simple node
  * ```ts
- * const kind: NodeKind = 'Schema'
+ * const importDef = defineNode<ImportNode>({ kind: 'Import' })
+ * const createImport = importDef.create
  * ```
- */
-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.
  *
- * @example
+ * @example Node with a build hook that is rerun on transform
  * ```ts
- * const base: BaseNode = { kind: 'Input' }
+ * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+ *   kind: 'Property',
+ *   build: (props) => ({ ...props, required: props.required ?? false }),
+ *   children: ['schema'],
+ *   visitorKey: 'property',
+ *   rebuild: true,
+ * })
  * ```
  */
-type BaseNode = {
-  /**
-   * Node discriminator.
-   */
-  kind: NodeKind;
-};
+declare function defineNode<TNode extends BaseNode, TInput = Omit<TNode, 'kind'>, TBuilt extends object = Omit<TNode, 'kind'>>(config: DefineNodeConfig<TNode, TInput, TBuilt>): NodeDef<TNode, TInput>;
 //#endregion
 //#region src/nodes/code.d.ts
 /**
@@ -451,1877 +410,905 @@ type JsxNode = BaseNode & {
  * structured children in {@link SourceNode.nodes}.
  */
 type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
-//#endregion
-//#region src/nodes/property.d.ts
 /**
- * AST node representing one named object property.
+ * Definition for the {@link ConstNode}.
+ */
+declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
+/**
+ * Creates a `ConstNode` representing a TypeScript `const` declaration.
  *
- * @example
+ * @example Exported constant with type and `as const`
  * ```ts
- * const property: PropertyNode = {
- *   kind: 'Property',
- *   name: 'id',
- *   schema: createSchema({ type: 'integer' }),
- *   required: true,
- * }
+ * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+ * // export const pets: Pet[] = ... as const
  * ```
  */
-type PropertyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Property';
-  /**
-   * Property key.
-   */
-  name: string;
-  /**
-   * Property schema.
-   */
-  schema: SchemaNode;
-  /**
-   * Whether the property is required.
-   */
-  required: boolean;
-};
-//#endregion
-//#region src/nodes/schema.d.ts
-type PrimitiveSchemaType =
-/**
- * Text value.
- */
-'string'
-/**
- * Floating-point number.
- */
-| 'number'
-/**
- * Integer number.
- */
-| 'integer'
-/**
- * Big integer number.
- */
-| 'bigint'
-/**
- * Boolean value.
- */
-| 'boolean'
+declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
 /**
- * Null value.
+ * Definition for the {@link TypeNode}.
  */
-| 'null'
+declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
 /**
- * Any value.
+ * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
  */
-| 'any'
+declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
 /**
- * Unknown value.
+ * Definition for the {@link FunctionNode}.
  */
-| 'unknown'
+declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
 /**
- * No value (`void`).
+ * Creates a `FunctionNode` representing a TypeScript `function` declaration.
+ *
+ * @example
+ * ```ts
+ * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function fetchPet(): Promise<Pet> { ... }
+ * ```
  */
-| 'void'
+declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
 /**
- * Never value.
+ * Definition for the {@link ArrowFunctionNode}.
  */
-| 'never'
+declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
 /**
- * Object value.
+ * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
+ *
+ * @example
+ * ```ts
+ * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+ * // export const double = (n: number) => ...
+ * ```
  */
-| 'object'
+declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
 /**
- * Array value.
+ * Definition for the {@link TextNode}.
  */
-| 'array'
+declare const textDef: NodeDef<TextNode, string>;
 /**
- * Date value.
+ * Creates a {@link TextNode} representing a raw string fragment in the source output.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
  */
-| 'date';
+declare const createText: (input: string) => TextNode;
 /**
- * Composite schema types.
+ * Definition for the {@link BreakNode}.
  */
-type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
+declare const breakDef: NodeDef<BreakNode, void>;
 /**
- * Schema types that need special handling in generators.
+ * Creates a {@link BreakNode} representing a line break in the source output.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
  */
-type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
+declare function createBreak(): BreakNode;
 /**
- * All schema type strings.
+ * Definition for the {@link JsxNode}.
  */
-type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+declare const jsxDef: NodeDef<JsxNode, string>;
 /**
- * Scalar schema types without extra object/array/ref structure.
+ * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+ *
+ * @example
+ * ```ts
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+ * ```
  */
-type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+declare const createJsx: (input: string) => JsxNode;
+//#endregion
+//#region src/infer.d.ts
 /**
- * Fields shared by all schema nodes.
+ * Shared parser options used by OAS-to-AST inference and parser flows.
  */
-type SchemaNodeBase = BaseNode & {
+type ParserOptions = {
   /**
-   * Node kind.
+   * 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).
    */
-  kind: 'Schema';
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
   /**
-   * 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.
+   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
+   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
+   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
+   *
+   * @default 'bigint'
    */
-  name?: string | null;
+  integerType?: 'number' | 'bigint';
   /**
-   * Short schema title.
+   * AST type used when a schema's type cannot be inferred from the spec
+   * (`additionalProperties: true`, missing `type`, ...).
    */
-  title?: string;
-  /**
-   * Schema description text.
-   */
-  description?: string;
-  /**
-   * Whether `null` is allowed.
-   */
-  nullable?: boolean;
-  /**
-   * Whether the field is optional.
-   */
-  optional?: boolean;
-  /**
-   * Both optional and nullable (`optional` + `nullable`).
-   */
-  nullish?: boolean;
-  /**
-   * Whether the schema is deprecated.
-   */
-  deprecated?: boolean;
-  /**
-   * Whether the schema is read-only.
-   */
-  readOnly?: boolean;
-  /**
-   * Whether the schema is write-only.
-   */
-  writeOnly?: boolean;
-  /**
-   * Default value.
-   */
-  default?: unknown;
-  /**
-   * Example value.
-   */
-  example?: unknown;
-  /**
-   * Base primitive type.
-   * For example, this is `'string'` for a `uuid` schema.
-   */
-  primitive?: PrimitiveSchemaType;
-  /**
-   * Schema `format` value.
-   */
-  format?: string;
-};
-/**
- * Object schema with ordered properties.
- *
- * @example
- * ```ts
- * const objectSchema: ObjectSchemaNode = {
- *   kind: 'Schema',
- *   type: 'object',
- *   properties: [],
- * }
- * ```
- */
-type ObjectSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'object';
-  /**
-   * Primitive type, always `'object'` for object schemas.
-   */
-  primitive: 'object';
-  /**
-   * Ordered object properties.
-   */
-  properties: Array<PropertyNode>;
-  /**
-   * Additional object properties behavior:
-   * - `true`: allow any value
-   * - `false`: reject unknown properties (maps to `.strict()` in Zod)
-   * - `SchemaNode`: allow values that match that schema
-   * - `undefined`: no additional properties constraint (open object)
-   */
-  additionalProperties?: SchemaNode | boolean;
-  /**
-   * Pattern-based property schemas.
-   */
-  patternProperties?: Record<string, SchemaNode>;
+  unknownType: 'any' | 'unknown' | 'void';
   /**
-   * Minimum number of properties allowed.
+   * AST type used for completely empty schemas (`{}`).
    */
-  minProperties?: number;
+  emptySchemaType: 'any' | 'unknown' | 'void';
   /**
-   * Maximum number of properties allowed.
+   * Suffix appended to derived enum names when Kubb has to invent one
+   * (typically for inline enums on object properties).
    */
-  maxProperties?: number;
+  enumSuffix: 'enum' | (string & {});
 };
 /**
- * Array-like schema (`array` or `tuple`).
- *
- * @example
- * ```ts
- * const arraySchema: ArraySchemaNode = {
- *   kind: 'Schema',
- *   type: 'array',
- *   items: [],
- * }
- * ```
+ * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
  */
-type ArraySchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator (`array` or `tuple`).
-   */
-  type: 'array' | 'tuple';
-  /**
-   * Item schemas.
-   */
-  items?: Array<SchemaNode>;
-  /**
-   * Tuple rest-item schema for elements beyond positional `items`.
-   */
-  rest?: SchemaNode;
-  /**
-   * Minimum item count (or tuple length).
-   */
-  min?: number;
-  /**
-   * Maximum item count (or tuple length).
-   */
-  max?: number;
-  /**
-   * Whether all items must be unique.
-   */
-  unique?: boolean;
+type DateTimeNodeByDateType = {
+  date: DateSchemaNode;
+  string: DatetimeSchemaNode;
+  stringOffset: DatetimeSchemaNode;
+  stringLocal: DatetimeSchemaNode;
+  false: StringSchemaNode;
 };
 /**
- * Shared shape for union and intersection schemas.
+ * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
  */
-type CompositeSchemaNodeBase = SchemaNodeBase & {
-  /**
-   * Member schemas.
-   */
-  members?: Array<SchemaNode>;
-};
+type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
 /**
- * Union schema, often from `oneOf` or `anyOf`.
- *
- * @example
- * ```ts
- * const unionSchema: UnionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'union',
- *   members: [],
- * }
- * ```
+ * Ordered list of `[schema-shape, SchemaNode]` pairs.
+ * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
  */
-type UnionSchemaNode = CompositeSchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
+type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
+  $ref: string;
+}, RefSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+  properties: object;
+}, IntersectionSchemaNode], [{
+  allOf: readonly [unknown, unknown, ...Array<unknown>];
+}, IntersectionSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+}, SchemaNode], [{
+  oneOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  anyOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  const: null;
+}, ScalarSchemaNode], [{
+  const: string | number | boolean;
+}, EnumSchemaNode], [{
+  type: ReadonlyArray<string>;
+}, UnionSchemaNode], [{
+  type: 'array';
+  enum: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  enum: ReadonlyArray<unknown>;
+}, EnumSchemaNode], [{
+  type: 'enum';
+}, EnumSchemaNode], [{
   type: 'union';
-  /**
-   * Discriminator property name from OpenAPI `discriminator.propertyName`.
-   */
-  discriminatorPropertyName?: string;
-  /**
-   * Logical strategy applied to union members: 'one' means exactly one member must be valid (from `oneOf`),
-   * 'any' means any number of members can be valid (from `anyOf`).
-   */
-  strategy?: 'one' | 'any';
-};
-/**
- * Intersection schema, often from `allOf`.
- *
- * @example
- * ```ts
- * const intersectionSchema: IntersectionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'intersection',
- *   members: [],
- * }
- * ```
- */
-type IntersectionSchemaNode = CompositeSchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
+}, UnionSchemaNode], [{
   type: 'intersection';
-};
-/**
- * One named enum item.
- */
-type EnumValueNode = {
-  /**
-   * Enum item name.
-   */
-  name: string;
-  /**
-   * Enum item value.
-   */
-  value: string | number | boolean;
-  /**
-   * Primitive type of the enum value.
-   */
-  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
-};
-/**
- * Enum schema node.
- *
- * @example
- * ```ts
- * const enumSchema: EnumSchemaNode = {
- *   kind: 'Schema',
- *   type: 'enum',
- *   enumValues: ['a', 'b'],
- * }
- * ```
- */
-type EnumSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'enum';
-  /**
-   * Enum values in simple form.
-   */
-  enumValues?: Array<string | number | boolean | null>;
-  /**
-   * Enum values in named form.
-   * If present, this is used instead of `enumValues`.
-   */
-  namedEnumValues?: Array<EnumValueNode>;
-};
-/**
- * Reference schema that points to another schema definition.
- *
- * @example
- * ```ts
- * const refSchema: RefSchemaNode = {
- *   kind: 'Schema',
- *   type: 'ref',
- *   ref: '#/components/schemas/Pet',
- * }
- * ```
- */
-type RefSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
+}, IntersectionSchemaNode], [{
+  type: 'tuple';
+}, ArraySchemaNode], [{
   type: 'ref';
-  /**
-   * Referenced schema name.
-   * `null` means Kubb has processed this and determined there is no applicable name.
-   */
-  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 this ref resolves to, so its structure (`primitive`, `properties`)
-   * can be read without following the reference. Populated during OAS parsing when the
-   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
-   * resolution has not been attempted.
-   */
-  schema?: SchemaNode | null;
-};
-/**
- * Datetime schema.
- *
- * @example
- * ```ts
- * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
- * ```
- */
-type DatetimeSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
+}, RefSchemaNode], [{
   type: 'datetime';
-  /**
-   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
-   */
-  offset?: boolean;
-  /**
-   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
-   */
-  local?: boolean;
-};
-/**
- * Shared base for `date` and `time` schemas.
- */
-type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: T;
-  /**
-   * Output representation in generated code.
-   */
-  representation: 'date' | 'string';
-};
-/**
- * Date schema node.
- *
- * @example
- * ```ts
- * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
- * ```
- */
-type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
-/**
- * Time schema node.
- *
- * @example
- * ```ts
- * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
- * ```
- */
-type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
-/**
- * String schema node.
- *
- * @example
- * ```ts
- * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
- * ```
- */
-type StringSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'string';
-  /**
-   * Minimum string length.
-   */
-  min?: number;
-  /**
-   * Maximum string length.
-   */
-  max?: number;
-  /**
-   * Regex pattern.
-   */
-  pattern?: string;
-};
-/**
- * Numeric schema (`number`, `integer`, or `bigint`).
- *
- * @example
- * ```ts
- * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
- * ```
- */
-type NumberSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'number' | 'integer' | 'bigint';
-  /**
-   * Minimum value.
-   */
-  min?: number;
-  /**
-   * Maximum value.
-   */
-  max?: number;
-  /**
-   * Exclusive minimum value.
-   */
-  exclusiveMinimum?: number;
-  /**
-   * Exclusive maximum value.
-   */
-  exclusiveMaximum?: number;
-  /**
-   * The value must be a multiple of this number.
-   */
-  multipleOf?: number;
-};
-/**
- * Scalar schema with no extra constraints.
- *
- * @example
- * ```ts
- * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
- * ```
- */
-type ScalarSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: ScalarSchemaType;
-};
-/**
- * URL schema node.
- * Can include an OpenAPI-style path template for template literal types.
- *
- * @example
- * ```ts
- * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
- * ```
- */
-type UrlSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
+}, DatetimeSchemaNode], [{
+  type: 'date';
+}, DateSchemaNode], [{
+  type: 'time';
+}, TimeSchemaNode], [{
   type: 'url';
-  /**
-   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
-   */
-  path?: string;
-  /**
-   * Minimum string length.
-   */
-  min?: number;
-  /**
-   * Maximum string length.
-   */
-  max?: number;
-};
+}, UrlSchemaNode], [{
+  type: 'object';
+}, ObjectSchemaNode], [{
+  additionalProperties: boolean | {};
+}, ObjectSchemaNode], [{
+  type: 'array';
+}, ArraySchemaNode], [{
+  items: object;
+}, ArraySchemaNode], [{
+  prefixItems: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  type: string;
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  type: string;
+  format: 'date';
+}, DateSchemaNode], [{
+  type: string;
+  format: 'time';
+}, TimeSchemaNode], [{
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  format: 'date';
+}, DateSchemaNode], [{
+  format: 'time';
+}, TimeSchemaNode], [{
+  type: 'string';
+}, StringSchemaNode], [{
+  type: 'number';
+}, NumberSchemaNode], [{
+  type: 'integer';
+}, NumberSchemaNode], [{
+  type: 'bigint';
+}, NumberSchemaNode], [{
+  type: string;
+}, ScalarSchemaNode], [{
+  minLength: number;
+}, StringSchemaNode], [{
+  maxLength: number;
+}, StringSchemaNode], [{
+  pattern: string;
+}, StringSchemaNode], [{
+  minimum: number;
+}, NumberSchemaNode], [{
+  maximum: number;
+}, NumberSchemaNode]];
 /**
- * Format-string schema for string-based formats that support length constraints.
- *
- * @example
- * ```ts
- * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
- * ```
- */
-type FormatStringSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'uuid' | 'email';
-  /**
-   * Minimum string length.
-   */
-  min?: number;
-  /**
-   * Maximum string length.
-   */
-  max?: number;
-};
-/**
- * IPv4 address schema node.
- *
- * @example
- * ```ts
- * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
- * ```
- */
-type Ipv4SchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'ipv4';
-};
-/**
- * IPv6 address schema node.
- *
- * @example
- * ```ts
- * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
- * ```
- */
-type Ipv6SchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'ipv6';
-};
-/**
- * Mapping from schema type literals to concrete schema node types.
- * Used by `narrowSchema`.
- */
-type SchemaNodeByType = {
-  object: ObjectSchemaNode;
-  array: ArraySchemaNode;
-  tuple: ArraySchemaNode;
-  union: UnionSchemaNode;
-  intersection: IntersectionSchemaNode;
-  enum: EnumSchemaNode;
-  ref: RefSchemaNode;
-  datetime: DatetimeSchemaNode;
-  date: DateSchemaNode;
-  time: TimeSchemaNode;
-  string: StringSchemaNode;
-  number: NumberSchemaNode;
-  integer: NumberSchemaNode;
-  bigint: NumberSchemaNode;
-  boolean: ScalarSchemaNode;
-  null: ScalarSchemaNode;
-  any: ScalarSchemaNode;
-  unknown: ScalarSchemaNode;
-  void: ScalarSchemaNode;
-  never: ScalarSchemaNode;
-  uuid: FormatStringSchemaNode;
-  email: FormatStringSchemaNode;
-  url: UrlSchemaNode;
-  ipv4: Ipv4SchemaNode;
-  ipv6: Ipv6SchemaNode;
-  blob: ScalarSchemaNode;
-};
-/**
- * Union of all schema node types.
- */
-type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | ScalarSchemaNode;
-//#endregion
-//#region src/nodes/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 content: ContentNode = {
- *   kind: 'Content',
- *   contentType: 'application/json',
- *   schema: createSchema({ type: 'string' }),
- * }
- * ```
- */
-type ContentNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Content';
-  /**
-   * The content type for this entry (e.g. `'application/json'`).
-   */
-  contentType: string;
-  /**
-   * 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.
-   */
-  root?: string | null;
-};
-/**
- * Represents a language-agnostic export/public API declaration.
- *
- * @example Named export (TypeScript: `export { Pets } from './Pets'`)
- * ```ts
- * createExport({ name: ['Pets'], path: './Pets' })
- * ```
- *
- * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
- * ```ts
- * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
- * ```
- *
- * @example Wildcard export (TypeScript: `export * from './utils'`)
- * ```ts
- * createExport({ path: './utils' })
- * ```
- *
- * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
- * ```ts
- * createExport({ name: 'utils', path: './utils', asAlias: true })
- * ```
- */
-type ExportNode = BaseNode & {
-  kind: 'Export';
-  /**
-   * Export name(s) to be used. When omitted, generates a wildcard export.
-   * @example ['useState']
-   * @example 'React'
-   */
-  name?: string | Array<string> | null;
-  /**
-   * 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 | null;
-  /**
-   * Export as an aliased namespace.
-   * - `true` generates `export * as aliasName from './path'`
-   * - `false` generates a standard export
-   * @default false
-   */
-  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';
-  /**
-   * 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;
-  /**
-   * Include `export` keyword in the generated source.
-   * @default false
-   */
-  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>;
-};
+ * Infers the matching AST `SchemaNode` type from an input schema shape.
+ */
+type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>] ? TSchema extends TEntry[0] ? TEntry[1] : InferSchemaNode<TSchema, TDateType, TRest> : SchemaNode;
+//#endregion
+//#region src/nodes/property.d.ts
 /**
- * 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`.
+ * AST node representing one named object property.
  *
  * @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'
+ * const property: PropertyNode = {
+ *   kind: 'Property',
+ *   name: 'id',
+ *   schema: createSchema({ type: 'integer' }),
+ *   required: true,
+ * }
  * ```
  */
-type FileNode<TMeta extends object = object> = BaseNode & {
-  kind: 'File';
+type PropertyNode = BaseNode & {
   /**
-   * Unique identifier derived from a SHA256 hash of the file path. Computed
-   * by `createFile`; callers do not need to provide it.
+   * Node kind.
    */
-  id: string;
+  kind: 'Property';
   /**
-   * File name without extension, derived from `baseName`.
-   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   * Property key.
    */
   name: string;
   /**
-   * File base name, including extension.
-   * Based on UNIX basename: `${name}${extname}`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
-   */
-  baseName: `${string}.${string}`;
-  /**
-   * Full qualified path to the file.
-   */
-  path: string;
-  /**
-   * File extension extracted from `baseName`.
-   */
-  extname: Extname;
-  /**
-   * Deduplicated list of source code fragments.
-   */
-  sources: Array<SourceNode>;
-  /**
-   * Deduplicated list of import declarations.
-   */
-  imports: Array<ImportNode>;
-  /**
-   * Deduplicated list of export declarations.
-   */
-  exports: Array<ExportNode>;
-  /**
-   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
-   */
-  meta?: TMeta;
-  /**
-   * Optional banner prepended to the generated file content.
-   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
+   * Property schema.
    */
-  banner?: string | null;
+  schema: SchemaNode;
   /**
-   * Optional footer appended to the generated file content.
-   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
+   * Whether the property is required.
    */
-  footer?: string | null;
+  required: boolean;
 };
-//#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 }
- * ```
+ * Loosely-typed property accepted by `createProperty`, with `required` optional.
+ */
+type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
+/**
+ * Definition for the {@link PropertyNode}. `required` defaults to `false` and the
+ * schema's `optional`/`nullish` flags are kept in sync with it.
+ */
+declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
+/**
+ * Creates a `PropertyNode`.
  *
- * @example Member variant
+ * @example
  * ```ts
- * createParamsType({ variant: 'member', base: 'PathParams', key: 'petId' })
- * // PathParams['petId']
+ * const property = createProperty({
+ *   name: 'status',
+ *   required: true,
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=true, no optional/nullish
  * ```
  */
-type ParamsTypeNode = BaseNode & {
+declare const createProperty: (input: UserPropertyNode) => PropertyNode;
+//#endregion
+//#region src/nodes/schema.d.ts
+type PrimitiveSchemaType =
+/**
+ * Text value.
+ */
+'string'
+/**
+ * Floating-point number.
+ */
+| 'number'
+/**
+ * Integer number.
+ */
+| 'integer'
+/**
+ * Big integer number.
+ */
+| 'bigint'
+/**
+ * Boolean value.
+ */
+| 'boolean'
+/**
+ * Null value.
+ */
+| 'null'
+/**
+ * Any value.
+ */
+| 'any'
+/**
+ * Unknown value.
+ */
+| 'unknown'
+/**
+ * No value (`void`).
+ */
+| 'void'
+/**
+ * Never value.
+ */
+| 'never'
+/**
+ * Object value.
+ */
+| 'object'
+/**
+ * Array value.
+ */
+| 'array'
+/**
+ * Date value.
+ */
+| 'date';
+/**
+ * Composite schema types.
+ */
+type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
+/**
+ * Schema types that need special handling in generators.
+ */
+type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
+/**
+ * All schema type strings.
+ */
+type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+/**
+ * Scalar schema types without extra object/array/ref structure.
+ */
+type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+/**
+ * Fields shared by all schema nodes.
+ */
+type SchemaNodeBase = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'ParamsType';
-} & ({
+  kind: 'Schema';
   /**
-   * Reference variant, a plain type name or identifier.
-   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
+   * 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.
    */
-  variant: 'reference';
+  name?: string | null;
   /**
-   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
+   * Short schema title.
    */
-  name: string;
-} | {
+  title?: string;
   /**
-   * Struct variant, an inline anonymous type grouping named fields.
-   * TypeScript renders as `{ key: Type; other?: OtherType }`.
+   * Schema description text.
    */
-  variant: 'struct';
+  description?: string;
   /**
-   * Properties of the struct type.
+   * Whether `null` is allowed.
    */
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
+  nullable?: boolean;
+  /**
+   * Whether the field is optional.
+   */
+  optional?: boolean;
   /**
-   * Member variant, a single named field accessed from a group type.
-   * TypeScript renders as `Base['key']`.
+   * Both optional and nullable (`optional` + `nullable`).
    */
-  variant: 'member';
+  nullish?: boolean;
   /**
-   * Base type name, e.g. `'DeletePetPathParams'`.
+   * Whether the schema is deprecated.
    */
-  base: string;
+  deprecated?: boolean;
   /**
-   * The field name to access, e.g. `'petId'`.
+   * Whether the schema is read-only.
    */
-  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 & {
+  readOnly?: boolean;
   /**
-   * Node kind.
+   * Whether the schema is write-only.
    */
-  kind: 'FunctionParameter';
+  writeOnly?: boolean;
   /**
-   * Parameter name in the generated signature.
+   * Default value.
    */
-  name: string;
+  default?: unknown;
   /**
-   * 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']`
+   * Example value.
    */
-  type?: ParamsTypeNode;
+  example?: unknown;
   /**
-   * When `true` the parameter is emitted as a rest parameter.
-   *
-   * @example Rest parameter
-   * `...name: Type[]`
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
    */
-  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;
-});
+  primitive?: PrimitiveSchemaType;
+  /**
+   * Schema `format` value.
+   */
+  format?: 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 } = {}`
+ * Object schema with ordered properties.
  *
- * @example Inline (spread as individual parameters)
- * `id: string, name: string`
+ * @example
+ * ```ts
+ * const objectSchema: ObjectSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'object',
+ *   properties: [],
+ * }
+ * ```
  */
-type ParameterGroupNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'ParameterGroup';
+type ObjectSchemaNode = SchemaNodeBase & {
   /**
-   * The individual parameters that form the group.
-   * Rendered as a destructured object or spread inline when `inline` is `true`.
+   * Schema type discriminator.
    */
-  properties: Array<FunctionParameterNode>;
+  type: 'object';
   /**
-   * Optional explicit type annotation for the whole group.
-   * When absent, printers auto-compute it from `properties`.
+   * Primitive type, always `'object'` for object schemas.
    */
-  type?: ParamsTypeNode;
+  primitive: 'object';
   /**
-   * When `true`, `properties` are emitted as individual top-level parameters instead of
-   * being wrapped in a single grouped construct.
-   *
-   * @default false
+   * Ordered object properties.
    */
-  inline?: boolean;
+  properties: Array<PropertyNode>;
   /**
-   * Whether the group as a whole is optional.
-   * If omitted, printers infer this from child properties.
+   * 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)
    */
-  optional?: boolean;
+  additionalProperties?: SchemaNode | boolean;
   /**
-   * Default value for the group, written verbatim after `=`.
-   * Commonly `'{}'` to allow omitting the argument entirely.
+   * Pattern-based property schemas.
    */
-  default?: string;
-};
-/**
- * AST node for a complete function parameter list.
- *
- * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
- * Nodes are plain immutable data.
- *
- * Renders differently depending on the output mode:
- * - `declaration` → `(id: string, config: Config = {})` function declaration parameters
- * - `call`        → `(id, { method, url })` function call arguments
- * - `keys`        → `{ id, config }` key names only (for destructuring)
- * - `values`      → `{ id: id, config: config }` key → value pairs
- */
-type FunctionParametersNode = BaseNode & {
+  patternProperties?: Record<string, SchemaNode>;
   /**
-   * Node kind.
+   * Minimum number of properties allowed.
    */
-  kind: 'FunctionParameters';
+  minProperties?: number;
   /**
-   * Ordered parameter nodes.
+   * Maximum number of properties allowed.
    */
-  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
+  maxProperties?: number;
 };
 /**
- * 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 ../../internals/utils/src/promise.d.ts
-/**
- * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.
- *
- * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large
- * collections can be produced lazily without holding every item in memory. Pairs with
- * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.
- *
- * @example
- * ```ts
- * type Eager = Streamable<number> // Array<number>
- * type Lazy = Streamable<number, true> // AsyncIterable<number>
- * ```
- */
-type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>;
-//#endregion
-//#region src/nodes/parameter.d.ts
-type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
-/**
- * AST node representing one operation parameter.
+ * Array-like schema (`array` or `tuple`).
  *
  * @example
  * ```ts
- * const param: ParameterNode = {
- *   kind: 'Parameter',
- *   name: 'petId',
- *   in: 'path',
- *   schema: createSchema({ type: 'string' }),
- *   required: true,
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
  * }
  * ```
  */
-type ParameterNode = BaseNode & {
+type ArraySchemaNode = SchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator (`array` or `tuple`).
    */
-  kind: 'Parameter';
+  type: 'array' | 'tuple';
   /**
-   * Parameter name.
+   * Item schemas.
    */
-  name: string;
+  items?: Array<SchemaNode>;
   /**
-   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   * Tuple rest-item schema for elements beyond positional `items`.
    */
-  in: ParameterLocation;
+  rest?: SchemaNode;
   /**
-   * Parameter schema.
+   * Minimum item count (or tuple length).
    */
-  schema: SchemaNode;
+  min?: number;
   /**
-   * Whether the parameter is required.
+   * Maximum item count (or tuple length).
    */
-  required: boolean;
+  max?: number;
+  /**
+   * Whether all items must be unique.
+   */
+  unique?: boolean;
 };
-//#endregion
-//#region src/nodes/requestBody.d.ts
 /**
- * AST node representing an operation request body.
- *
- * Body schemas live exclusively inside the `content` array (one entry per content type),
- * mirroring {@link ResponseNode}.
+ * Shared shape for union and intersection schemas.
+ */
+type CompositeSchemaNodeBase = SchemaNodeBase & {
+  /**
+   * Member schemas.
+   */
+  members?: Array<SchemaNode>;
+};
+/**
+ * Union schema, often from `oneOf` or `anyOf`.
  *
  * @example
  * ```ts
- * const requestBody: RequestBodyNode = {
- *   kind: 'RequestBody',
- *   required: true,
- *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
  * }
  * ```
  */
-type RequestBodyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'RequestBody';
+type UnionSchemaNode = CompositeSchemaNodeBase & {
   /**
-   * Human-readable request body description.
+   * Schema type discriminator.
    */
-  description?: string;
+  type: 'union';
   /**
-   * Whether the request body is required (`requestBody.required: true` in the spec).
-   * When `false` or absent, the generated `data` parameter should be optional.
+   * Discriminator property name from OpenAPI `discriminator.propertyName`.
    */
-  required?: boolean;
+  discriminatorPropertyName?: string;
   /**
-   * 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`).
+   * 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`).
    */
-  content?: Array<ContentNode>;
+  strategy?: 'one' | 'any';
 };
-//#endregion
-//#region src/nodes/http.d.ts
-/**
- * All supported HTTP status code literals as strings, as used in API specs
- * (for example, `"200"` and `"404"`).
- */
-type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
-/**
- * Response status code literal used by operations.
- *
- * Includes specific HTTP status code strings and `"default"` for catch-all responses.
- *
- * @example
- * ```ts
- * const status: StatusCode = '200'
- * const fallback: StatusCode = 'default'
- * ```
- */
-type StatusCode = HttpStatusCode | 'default';
-//#endregion
-//#region src/nodes/response.d.ts
 /**
- * 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`.
+ * Intersection schema, often from `allOf`.
  *
  * @example
  * ```ts
- * const response: ResponseNode = {
- *   kind: 'Response',
- *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
  * }
  * ```
  */
-type ResponseNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Response';
-  /**
-   * HTTP status code or `'default'` for a fallback response.
-   */
-  statusCode: StatusCode;
-  /**
-   * Optional response description.
-   */
-  description?: string;
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
   /**
-   * 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'
-   * ```
+   * Schema type discriminator.
    */
-  content?: Array<ContentNode>;
+  type: 'intersection';
 };
-//#endregion
-//#region src/nodes/operation.d.ts
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
 /**
- * Transport an operation belongs to.
- */
-type OperationProtocol = 'http';
-/**
- * Fields shared by every operation, regardless of transport.
+ * One named enum item.
  */
-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`.
-   */
-  tags: Array<string>;
-  /**
-   * Short one-line operation summary.
-   */
-  summary?: string;
-  /**
-   * Full operation description.
-   */
-  description?: string;
-  /**
-   * Marks the operation as deprecated.
-   */
-  deprecated?: boolean;
+type EnumValueNode = {
   /**
-   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   * Enum item name.
    */
-  parameters: Array<ParameterNode>;
+  name: string;
   /**
-   * Request body for the operation.
+   * Enum item value.
    */
-  requestBody?: RequestBodyNode;
+  value: string | number | boolean;
   /**
-   * Operation responses.
+   * Primitive type of the enum value.
    */
-  responses: Array<ResponseNode>;
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
 };
 /**
- * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
+ * Enum schema node.
  *
  * @example
  * ```ts
- * const operation: HttpOperationNode = {
- *   kind: 'Operation',
- *   operationId: 'listPets',
- *   protocol: 'http',
- *   method: 'GET',
- *   path: '/pets',
- *   tags: [],
- *   parameters: [],
- *   responses: [],
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
  * }
  * ```
  */
-type HttpOperationNode = OperationNodeBase & {
-  /**
-   * Transport the operation belongs to.
-   */
-  protocol?: 'http';
+type EnumSchemaNode = SchemaNodeBase & {
   /**
-   * HTTP method like `'GET'`.
+   * Schema type discriminator.
    */
-  method: HttpMethod;
+  type: 'enum';
   /**
-   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
+   * Enum values in simple form.
    */
-  path: string;
-};
-/**
- * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
- */
-type GenericOperationNode = OperationNodeBase & {
+  enumValues?: Array<string | number | boolean | null>;
   /**
-   * Transport the operation belongs to.
+   * Enum values in named form.
+   * If present, this is used instead of `enumValues`.
    */
-  protocol?: Exclude<OperationProtocol, 'http'>;
-  method?: never;
-  path?: never;
+  namedEnumValues?: Array<EnumValueNode>;
 };
 /**
- * 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/input.d.ts
-/**
- * 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.
+ * Reference schema that points to another schema definition.
  *
  * @example
  * ```ts
- * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
+ * const refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
  * ```
  */
-type InputMeta = {
-  /**
-   * API title from `info.title` in the source document.
-   */
-  title?: string;
+type RefSchemaNode = SchemaNodeBase & {
   /**
-   * API description from `info.description` in the source document.
+   * Schema type discriminator.
    */
-  description?: string;
+  type: 'ref';
   /**
-   * API version string from `info.version` in the source document.
+   * Referenced schema name.
+   * `null` means Kubb has processed this and determined there is no applicable name.
    */
-  version?: string;
+  name?: string | null;
   /**
-   * Resolved base URL from the first matching server entry in the source document.
+   * Original `$ref` path, for example, `#/components/schemas/Order`.
+   * Used to resolve names later.
    */
-  baseURL?: string | null;
+  ref?: string;
   /**
-   * 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)) { ... }
-   * ```
+   * Pattern copied from a sibling `pattern` field.
    */
-  circularNames: ReadonlyArray<string>;
+  pattern?: 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)`
+   * The fully-parsed schema this ref resolves to, so its structure (`primitive`, `properties`)
+   * can be read without following the reference. Populated during OAS parsing when the
+   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
+   * resolution has not been attempted.
    */
-  enumNames: ReadonlyArray<string>;
+  schema?: SchemaNode | null;
 };
 /**
- * Input AST node that contains all schemas and operations for one API document.
- * Produced by the adapter and consumed by all Kubb plugins.
- *
- * `Stream` switches `schemas` and `operations` between eager `Array`s (the default) and lazy
- * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time and makes
- * `meta` optional, since the adapter can emit metadata before the first node is parsed.
+ * Datetime schema.
  *
  * @example
  * ```ts
- * const input: InputNode = {
- *   kind: 'Input',
- *   schemas: [],
- *   operations: [],
- *   meta: { circularNames: [], enumNames: [] },
- * }
- * ```
- *
- * @example Streaming variant for large specs
- * ```ts
- * for await (const schema of inputNode.schemas) {
- *   // only this one SchemaNode is live here. Previous ones are GC-eligible
- * }
+ * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
  * ```
  */
-type InputNode<Stream extends boolean = false> = BaseNode & {
+type DatetimeSchemaNode = SchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'Input';
+  type: 'datetime';
   /**
-   * All schema nodes in the document.
+   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
    */
-  schemas: Streamable<SchemaNode, Stream>;
+  offset?: boolean;
   /**
-   * All operation nodes in the document.
+   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
    */
-  operations: Streamable<OperationNode, Stream>;
-} & (Stream extends true ? {
-  meta?: InputMeta;
-} : {
-  meta: InputMeta;
-});
-//#endregion
-//#region src/nodes/output.d.ts
+  local?: boolean;
+};
 /**
- * Output AST node that groups all generated file output for one API document.
- *
- * Produced by generators and consumed by the build pipeline to write files.
- *
- * @example
- * ```ts
- * const output: OutputNode = {
- *   kind: 'Output',
- *   files: [],
- * }
- * ```
+ * Shared base for `date` and `time` schemas.
  */
-type OutputNode = BaseNode & {
+type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'Output';
+  type: T;
   /**
-   * Generated file nodes.
+   * Output representation in generated code.
    */
-  files: Array<FileNode>;
+  representation: 'date' | 'string';
 };
-//#endregion
-//#region src/nodes/index.d.ts
 /**
- * Union of all AST node types.
+ * Date schema node.
  *
- * This lets TypeScript narrow types in `switch (node.kind)` blocks.
+ * @example
+ * ```ts
+ * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
+ * ```
+ */
+type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
+/**
+ * Time schema node.
  *
  * @example
  * ```ts
- * function getKind(node: Node): string {
- *   switch (node.kind) {
- *     case 'Input':
- *       return 'input'
- *     case 'Output':
- *       return 'output'
- *     default:
- *       return 'other'
- *   }
- * }
+ * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
  * ```
  */
-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
+type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
 /**
- * A canonical destination for a deduplicated shape: the shared schema name and
- * the synthetic `$ref` path that points at it.
+ * String schema node.
+ *
+ * @example
+ * ```ts
+ * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
+ * ```
  */
-type DedupeCanonical = {
-  /**
-   * Canonical schema name every duplicate occurrence refers to.
-   */
-  name: string;
+type StringSchemaNode = SchemaNodeBase & {
   /**
-   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).
+   * Schema type discriminator.
    */
-  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 = {
+  type: 'string';
   /**
-   * Maps a structural signature to the canonical schema that represents it.
+   * Minimum string length.
    */
-  canonicalBySignature: Map<string, DedupeCanonical>;
+  min?: number;
   /**
-   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
-   * references to the duplicate can be repointed at the first schema with the same content.
+   * Maximum string length.
    */
-  aliasNames: Map<string, DedupeCanonical>;
+  max?: number;
   /**
-   * New top-level schema definitions created for inline shapes that had no existing
-   * named component. Nested duplicates inside each definition are already collapsed.
+   * Regex pattern.
    */
-  hoisted: Array<SchemaNode>;
+  pattern?: string;
 };
 /**
- * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
- */
-type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>;
-/**
- * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
- * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
+ * Numeric schema (`number`, `integer`, or `bigint`).
+ *
+ * @example
+ * ```ts
+ * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
+ * ```
  */
-type BuildDedupePlanOptions = {
+type NumberSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'number' | 'integer' | 'bigint';
+  /**
+   * Minimum value.
+   */
+  min?: number;
   /**
-   * 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).
+   * Maximum value.
    */
-  isCandidate: (node: SchemaNode) => boolean;
+  max?: number;
   /**
-   * 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).
+   * Exclusive minimum value.
    */
-  nameFor: (node: SchemaNode, signature: string) => string | null;
+  exclusiveMinimum?: number;
   /**
-   * Builds the `$ref` path for a canonical name.
+   * Exclusive maximum value.
    */
-  refFor: (name: string) => string;
+  exclusiveMaximum?: number;
   /**
-   * Minimum number of occurrences before a shape is deduplicated.
-   *
-   * @default 2
+   * The value must be a multiple of this number.
    */
-  minOccurrences?: number;
+  multipleOf?: 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. A `ref` that points
- * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
- * the same content.
- *
- * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
- * turned into a reference to itself. Nested duplicates are still collapsed.
+ * Scalar schema with no extra constraints.
  *
  * @example
  * ```ts
- * const next = applyDedupe(operationNode, plan)
+ * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
  * ```
  */
-declare function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode;
-declare function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode;
+type ScalarSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: ScalarSchemaType;
+};
 /**
- * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
- *
- * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
- * is a named top-level schema, the first one becomes the canonical (so other top-level
- * duplicates and inline copies turn into references to it). Every other top-level name with
- * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
- * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
- * per node with {@link applyDedupe}.
+ * URL schema node.
+ * Can include an OpenAPI-style path template for template literal types.
  *
  * @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}`,
- * })
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
  * ```
  */
-declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan;
-//#endregion
-//#region src/dialect.d.ts
-/**
- * The spec-specific questions a schema parser answers while turning a source document into Kubb
- * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
- * OpenAPI, AsyncAPI, and plain JSON Schema differ.
- */
-type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
-  /**
-   * Identifies the dialect in logs and diagnostics.
-   */
-  name: string;
-  /**
-   * Whether the schema is nullable.
-   */
-  isNullable: (schema?: TSchema) => boolean;
+type UrlSchemaNode = SchemaNodeBase & {
   /**
-   * Whether the value is a `$ref` pointer.
+   * Schema type discriminator.
    */
-  isReference: (value?: unknown) => value is TRef;
+  type: 'url';
   /**
-   * Whether the schema carries a discriminator for polymorphism.
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
    */
-  isDiscriminator: (value?: unknown) => value is TDiscriminated;
+  path?: string;
   /**
-   * Whether the schema is binary data, converted to a `blob` node.
+   * Minimum string length.
    */
-  isBinary: (schema: TSchema) => boolean;
+  min?: number;
   /**
-   * Resolves a local `$ref` against the document, or nullish when it cannot.
+   * Maximum string length.
    */
-  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
+  max?: number;
 };
 /**
- * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
- * dialect's type for inference.
+ * Format-string schema for string-based formats that support length constraints.
  *
  * @example
  * ```ts
- * export const oasDialect = defineSchemaDialect({
- *   name: 'oas',
- *   isNullable,
- *   isReference,
- *   isDiscriminator,
- *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
- *   resolveRef,
- * })
+ * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
  * ```
  */
-declare function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
-//#endregion
-//#region src/infer.d.ts
-/**
- * Shared parser options used by OAS-to-AST inference and parser flows.
- */
-type ParserOptions = {
-  /**
-   * How `format: 'date-time'` schemas are represented 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';
-  /**
-   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
-   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
-   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
-   *
-   * @default 'bigint'
-   */
-  integerType?: 'number' | 'bigint';
+type FormatStringSchemaNode = SchemaNodeBase & {
   /**
-   * AST type used when a schema's type cannot be inferred from the spec
-   * (`additionalProperties: true`, missing `type`, ...).
+   * Schema type discriminator.
    */
-  unknownType: 'any' | 'unknown' | 'void';
+  type: 'uuid' | 'email';
   /**
-   * AST type used for completely empty schemas (`{}`).
+   * Minimum string length.
    */
-  emptySchemaType: 'any' | 'unknown' | 'void';
+  min?: number;
   /**
-   * Suffix appended to derived enum names when Kubb has to invent one
-   * (typically for inline enums on object properties).
+   * Maximum string length.
    */
-  enumSuffix: 'enum' | (string & {});
-};
-/**
- * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
- */
-type DateTimeNodeByDateType = {
-  date: DateSchemaNode;
-  string: DatetimeSchemaNode;
-  stringOffset: DatetimeSchemaNode;
-  stringLocal: DatetimeSchemaNode;
-  false: StringSchemaNode;
+  max?: number;
 };
 /**
- * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
- */
-type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
-/**
- * Ordered list of `[schema-shape, SchemaNode]` pairs.
- * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
- */
-type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
-  $ref: string;
-}, RefSchemaNode], [{
-  allOf: ReadonlyArray<unknown>;
-  properties: object;
-}, IntersectionSchemaNode], [{
-  allOf: readonly [unknown, unknown, ...Array<unknown>];
-}, IntersectionSchemaNode], [{
-  allOf: ReadonlyArray<unknown>;
-}, SchemaNode], [{
-  oneOf: ReadonlyArray<unknown>;
-}, UnionSchemaNode], [{
-  anyOf: ReadonlyArray<unknown>;
-}, UnionSchemaNode], [{
-  const: null;
-}, ScalarSchemaNode], [{
-  const: string | number | boolean;
-}, EnumSchemaNode], [{
-  type: ReadonlyArray<string>;
-}, UnionSchemaNode], [{
-  type: 'array';
-  enum: ReadonlyArray<unknown>;
-}, ArraySchemaNode], [{
-  enum: ReadonlyArray<unknown>;
-}, EnumSchemaNode], [{
-  type: 'enum';
-}, EnumSchemaNode], [{
-  type: 'union';
-}, UnionSchemaNode], [{
-  type: 'intersection';
-}, IntersectionSchemaNode], [{
-  type: 'tuple';
-}, ArraySchemaNode], [{
-  type: 'ref';
-}, RefSchemaNode], [{
-  type: 'datetime';
-}, DatetimeSchemaNode], [{
-  type: 'date';
-}, DateSchemaNode], [{
-  type: 'time';
-}, TimeSchemaNode], [{
-  type: 'url';
-}, UrlSchemaNode], [{
-  type: 'object';
-}, ObjectSchemaNode], [{
-  additionalProperties: boolean | {};
-}, ObjectSchemaNode], [{
-  type: 'array';
-}, ArraySchemaNode], [{
-  items: object;
-}, ArraySchemaNode], [{
-  prefixItems: ReadonlyArray<unknown>;
-}, ArraySchemaNode], [{
-  type: string;
-  format: 'date-time';
-}, ResolveDateTimeNode<TDateType>], [{
-  type: string;
-  format: 'date';
-}, DateSchemaNode], [{
-  type: string;
-  format: 'time';
-}, TimeSchemaNode], [{
-  format: 'date-time';
-}, ResolveDateTimeNode<TDateType>], [{
-  format: 'date';
-}, DateSchemaNode], [{
-  format: 'time';
-}, TimeSchemaNode], [{
-  type: 'string';
-}, StringSchemaNode], [{
-  type: 'number';
-}, NumberSchemaNode], [{
-  type: 'integer';
-}, NumberSchemaNode], [{
-  type: 'bigint';
-}, NumberSchemaNode], [{
-  type: string;
-}, ScalarSchemaNode], [{
-  minLength: number;
-}, StringSchemaNode], [{
-  maxLength: number;
-}, StringSchemaNode], [{
-  pattern: string;
-}, StringSchemaNode], [{
-  minimum: number;
-}, NumberSchemaNode], [{
-  maximum: number;
-}, NumberSchemaNode]];
-/**
- * Infers the matching AST `SchemaNode` type from an input schema shape.
- */
-type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>] ? TSchema extends TEntry[0] ? TEntry[1] : InferSchemaNode<TSchema, TDateType, TRest> : SchemaNode;
-//#endregion
-//#region src/factory.d.ts
-/**
- * Updates a schema's `optional` and `nullish` flags from a parent's `required`
- * value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
- * object properties combine "required" and "nullable" into a single AST.
- *
- * - Non-required + non-nullable → `optional: true`.
- * - Non-required + nullable → `nullish: true`.
- * - Required → both flags cleared.
- */
-declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
-/**
- * Distributive `Omit` that preserves each member of a union.
+ * IPv4 address schema node.
  *
  * @example
  * ```ts
- * type A = { kind: 'a'; keep: string; drop: number }
- * type B = { kind: 'b'; keep: boolean; drop: number }
- * type Result = DistributiveOmit<A | B, 'drop'>
- * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
+ * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
  * ```
  */
-type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+type Ipv4SchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ipv4';
+};
 /**
- * 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.
+ * IPv6 address schema node.
  *
  * @example
  * ```ts
- * update(node, { name: node.name })        // -> same `node` reference
- * update(node, { name: 'renamed' })        // -> new node, `name` replaced
+ * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
  * ```
  */
-declare function update<T extends Node>(node: T, changes: Partial<T>): T;
+type Ipv6SchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ipv6';
+};
+/**
+ * Mapping from schema type literals to concrete schema node types.
+ * Used by `narrowSchema`.
+ */
+type SchemaNodeByType = {
+  object: ObjectSchemaNode;
+  array: ArraySchemaNode;
+  tuple: ArraySchemaNode;
+  union: UnionSchemaNode;
+  intersection: IntersectionSchemaNode;
+  enum: EnumSchemaNode;
+  ref: RefSchemaNode;
+  datetime: DatetimeSchemaNode;
+  date: DateSchemaNode;
+  time: TimeSchemaNode;
+  string: StringSchemaNode;
+  number: NumberSchemaNode;
+  integer: NumberSchemaNode;
+  bigint: NumberSchemaNode;
+  boolean: ScalarSchemaNode;
+  null: ScalarSchemaNode;
+  any: ScalarSchemaNode;
+  unknown: ScalarSchemaNode;
+  void: ScalarSchemaNode;
+  never: ScalarSchemaNode;
+  uuid: FormatStringSchemaNode;
+  email: FormatStringSchemaNode;
+  url: UrlSchemaNode;
+  ipv4: Ipv4SchemaNode;
+  ipv6: Ipv6SchemaNode;
+  blob: ScalarSchemaNode;
+};
+/**
+ * Union of all schema node types.
+ */
+type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | ScalarSchemaNode;
 type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & {
   properties?: Array<PropertyNode>;
   primitive?: 'object';
@@ -2331,88 +1318,12 @@ type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
   kind: 'Schema';
 };
 /**
- * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
- *
- * @example
- * ```ts
- * const input = createInput()
- * // { kind: 'Input', schemas: [], operations: [] }
- * ```
- *
- * @example
- * ```ts
- * const input = createInput({ schemas: [petSchema] })
- * // keeps default operations: []
- * ```
- */
-declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
-/**
- * Creates a streaming `InputNode<true>` 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): InputNode<true>;
-/**
- * Creates an `OutputNode` with a stable default for `files`.
- *
- * @example
- * ```ts
- * const output = createOutput()
- * // { kind: 'Output', files: [] }
- * ```
- *
- * @example
- * ```ts
- * const output = createOutput({ files: [petFile] })
- * ```
- */
-declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): OutputNode;
-/**
- * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
- *
- * @example
- * ```ts
- * const operation = createOperation({
- *   operationId: 'getPetById',
- *   method: 'GET',
- *   path: '/pet/{petId}',
- * })
- * // tags, parameters, and responses are []
- * ```
- *
- * @example
- * ```ts
- * const operation = createOperation({
- *   operationId: 'findPets',
- *   method: 'GET',
- *   path: '/pet/findByStatus',
- *   tags: ['pet'],
- * })
- * ```
- */
-/**
- * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
- */
-type UserContent = Omit<ContentNode, 'kind'>;
-/**
- * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ * Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+ * empty array, and `primitive` is inferred from `type` when not explicitly provided.
  */
-type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
-  content?: Array<UserContent>;
-};
-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;
+declare const schemaDef: NodeDef<SchemaNode, CreateSchemaInput>;
 /**
  * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
- * For object schemas, `properties` defaults to an empty array.
- * `primitive` is automatically inferred from `type` when not explicitly provided.
  *
  * @example
  * ```ts
@@ -2422,220 +1333,293 @@ declare function createOperation(props: Pick<GenericOperationNode, 'operationId'
  *
  * @example
  * ```ts
- * const uuid = createSchema({ type: 'uuid' })
- * // { kind: 'Schema', type: 'uuid', primitive: 'string' }
- * ```
- *
- * @example
- * ```ts
  * const object = createSchema({ type: 'object' })
  * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
  * ```
- *
- * @example
- * ```ts
- * const enumSchema = createSchema({
- *   type: 'enum',
- *   primitive: 'string',
- *   enumValues: ['available', 'pending'],
- * })
- * ```
  */
 declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
 declare function createSchema(props: CreateSchemaInput): SchemaNode;
-type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
+//#endregion
+//#region src/nodes/content.d.ts
 /**
- * Creates a `PropertyNode`.
+ * AST node representing one content-type entry of a request body or response.
  *
- * `required` defaults to `false`.
- * `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
+ * 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 property = createProperty({
- *   name: 'status',
+ * const content: ContentNode = {
+ *   kind: 'Content',
+ *   contentType: 'application/json',
  *   schema: createSchema({ type: 'string' }),
- * })
- * // required=false, schema.optional=true
- * ```
- *
- * @example
- * ```ts
- * const property = createProperty({
- *   name: 'status',
- *   required: true,
- *   schema: createSchema({ type: 'string', nullable: true }),
- * })
- * // required=true, no optional/nullish
+ * }
  * ```
  */
-declare function createProperty(props: UserPropertyNode): PropertyNode;
+type ContentNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Content';
+  /**
+   * The content type for this entry (e.g. `'application/json'`).
+   */
+  contentType: string;
+  /**
+   * 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;
+};
 /**
- * Creates a `ParameterNode`.
- *
- * `required` defaults to `false`.
- * Nested schema flags are set from `required` and `schema.nullable`.
- *
- * @example
- * ```ts
- * const param = createParameter({
- *   name: 'petId',
- *   in: 'path',
- *   required: true,
- *   schema: createSchema({ type: 'string' }),
- * })
- * ```
- *
- * @example
- * ```ts
- * const param = createParameter({
- *   name: 'status',
- *   in: 'query',
- *   schema: createSchema({ type: 'string', nullable: true }),
- * })
- * // required=false, schema.nullish=true
- * ```
+ * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
  */
-declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>): ParameterNode;
+type UserContent = Omit<ContentNode, 'kind'>;
 /**
- * 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',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
- * })
- * ```
+ * Definition for the {@link ContentNode}.
  */
-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;
+declare const contentDef: NodeDef<ContentNode, UserContent>;
+/**
+ * Creates a `ContentNode` for a single request-body or response content type.
+ */
+declare const createContent: (input: UserContent) => ContentNode;
+//#endregion
+//#region src/nodes/file.d.ts
 /**
- * Creates a `FunctionParameterNode`.
+ * 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.
  *
- * `optional` defaults to `false`.
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * ```
  *
- * @example Required typed param
+ * @example Default import (TypeScript: `import React from 'react'`)
  * ```ts
- * createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
- * // → petId: string
+ * createImport({ name: 'React', path: 'react' })
  * ```
  *
- * @example Optional param
+ * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
  * ```ts
- * createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
- * // → params?: QueryParams
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
  * ```
  *
- * @example Param with default (implicitly optional. Cannot combine with `optional: true`)
+ * @example Namespace import (TypeScript: `import * as React from 'react'`)
  * ```ts
- * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
- * // → config: RequestConfig = {}
+ * createImport({ name: 'React', path: 'react', isNameSpace: true })
  * ```
  */
-declare function createFunctionParameter(props: {
-  name: string;
-  type?: ParamsTypeNode;
-  rest?: boolean;
-} & ({
-  optional: true;
-  default?: never;
-} | {
-  optional?: false;
-  default?: string;
-})): FunctionParameterNode;
+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.
+   */
+  root?: string | null;
+};
 /**
- * Creates a {@link TypeNode} representing a language-agnostic structured type expression.
+ * Represents a language-agnostic export/public API declaration.
  *
- * Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
- * named field accessed from a group type. Each language's printer renders the variant
- * into its own syntax (TypeScript, Python, C#, Kotlin, …).
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
+ * ```ts
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
  *
- * @example Reference type (TypeScript: `QueryParams`)
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
  * ```ts
- * createParamsType({ variant: 'reference', name: 'QueryParams' })
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
  * ```
  *
- * @example Struct type (TypeScript: `{ petId: string }`)
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
  * ```ts
- * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
+ * createExport({ path: './utils' })
  * ```
  *
- * @example Member type (TypeScript: `DeletePetPathParams['petId']`)
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
  * ```ts
- * createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
  * ```
  */
-declare function createParamsType(props: {
-  variant: 'reference';
-  name: string;
-} | {
-  variant: 'struct';
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
-  variant: 'member';
-  base: string;
-  key: string;
-}): ParamsTypeNode;
+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> | null;
+  /**
+   * 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 | null;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   * @default false
+   */
+  asAlias?: boolean | null;
+};
 /**
- * Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
+ * Represents a fragment of source code within a file.
  *
- * @example Grouped param (TypeScript declaration)
+ * @example Named exportable source
  * ```ts
- * createParameterGroup({
- *   properties: [
- *     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
- *   ],
- *   default: '{}',
- * })
- * // declaration → { id, name? }: { id: string; name?: string } = {}
- * // call        → { id, name }
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
  * ```
  *
- * @example Inline (spread), children emitted as individual top-level parameters
+ * @example Inline unnamed code block
  * ```ts
- * createParameterGroup({
- *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
- *   inline: true,
- * })
- * // declaration → petId: string
- * // call        → petId
+ * createSource({ nodes: [createText('const x = 1')] })
  * ```
  */
-declare function createParameterGroup(props: Pick<ParameterGroupNode, 'properties'> & Partial<Omit<ParameterGroupNode, 'kind' | 'properties'>>): ParameterGroupNode;
+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;
+  /**
+   * Include `export` keyword in the generated source.
+   * @default false
+   */
+  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>;
+};
 /**
- * Creates a `FunctionParametersNode` from an ordered list of parameters.
+ * Represents a fully resolved file in the AST.
  *
- * @example
- * ```ts
- * createFunctionParameters({
- *   params: [
- *     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
- *   ],
- * })
- * ```
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
  *
  * @example
  * ```ts
- * const empty = createFunctionParameters()
- * // { kind: 'FunctionParameters', params: [] }
+ * 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'
  * ```
  */
-declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
+  /**
+   * Unique identifier derived from a SHA256 hash of the file path. Computed
+   * by `createFile`; callers do not need to provide it.
+   */
+  id: string;
+  /**
+   * File name without extension, derived from `baseName`.
+   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string;
+  /**
+   * File base name, including extension.
+   * Based on UNIX basename: `${name}${extname}`
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   */
+  baseName: `${string}.${string}`;
+  /**
+   * Full qualified path to the file.
+   */
+  path: string;
+  /**
+   * File extension extracted from `baseName`.
+   */
+  extname: Extname;
+  /**
+   * Deduplicated list of source code fragments.
+   */
+  sources: Array<SourceNode>;
+  /**
+   * Deduplicated list of import declarations.
+   */
+  imports: Array<ImportNode>;
+  /**
+   * Deduplicated list of export declarations.
+   */
+  exports: Array<ExportNode>;
+  /**
+   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
+   */
+  meta?: TMeta;
+  /**
+   * Optional banner prepended to the generated file content.
+   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
+   */
+  banner?: string | null;
+  /**
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
+   */
+  footer?: string | null;
+};
+/**
+ * Definition for the {@link ImportNode}.
+ */
+declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
 /**
  * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
  *
@@ -2644,14 +1628,12 @@ declare function createFunctionParameters(props?: Partial<Omit<FunctionParameter
  * createImport({ name: ['useState'], path: 'react' })
  * // import { useState } from 'react'
  * ```
- *
- * @example Type-only import
- * ```ts
- * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
- * // import type { FC } from 'react'
- * ```
  */
-declare function createImport(props: Omit<ImportNode, 'kind'>): ImportNode;
+declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
+/**
+ * Definition for the {@link ExportNode}.
+ */
+declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
 /**
  * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
  *
@@ -2660,14 +1642,12 @@ declare function createImport(props: Omit<ImportNode, 'kind'>): ImportNode;
  * createExport({ name: ['Pet'], path: './Pet' })
  * // export { Pet } from './Pet'
  * ```
- *
- * @example Wildcard export
- * ```ts
- * createExport({ path: './utils' })
- * // export * from './utils'
- * ```
  */
-declare function createExport(props: Omit<ExportNode, 'kind'>): ExportNode;
+declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
+/**
+ * Definition for the {@link SourceNode}.
+ */
+declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
 /**
  * Creates a `SourceNode` representing a fragment of source code within a file.
  *
@@ -2676,663 +1656,814 @@ declare function createExport(props: Omit<ExportNode, 'kind'>): ExportNode;
  * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
  * ```
  */
-declare function createSource(props: Omit<SourceNode, 'kind'>): SourceNode;
-type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
+declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
 /**
- * Creates a fully resolved `FileNode` from a file input descriptor.
- *
- * Computes:
- * - `id` SHA256 hash of the file path
- * - `name` `baseName` without extension
- * - `extname` extension extracted from `baseName`
- *
- * Deduplicates:
- * - `sources` via `combineSources`
- * - `exports` via `combineExports`
- * - `imports` via `combineImports` (also filters unused imports)
+ * Definition for the {@link FileNode}. The fully resolved builder lives in
+ * `createFile`, so this definition only supplies the guard.
+ */
+declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>;
+//#endregion
+//#region src/nodes/function.d.ts
+/**
+ * A language-agnostic type expression used as a function parameter type annotation.
  *
- * @throws {Error} when `baseName` has no extension.
+ * - a plain `string` is a type reference rendered as-is, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`
+ * - a {@link TypeLiteralNode} is an inline anonymous type, e.g. `{ petId: string; name?: string }`
+ * - an {@link IndexedAccessTypeNode} is a single field accessed from a named type, e.g. `PathParams['petId']`
+ */
+type TypeExpression = string | TypeLiteralNode | IndexedAccessTypeNode;
+/**
+ * AST node for an inline anonymous object type grouping named fields.
+ * TypeScript renders as `{ key: Type; other?: OtherType }`.
  *
  * @example
  * ```ts
- * const file = createFile({
- *   baseName: 'petStore.ts',
- *   path: 'src/models/petStore.ts',
- *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
- *   imports: [createImport({ name: ['z'], path: 'zod' })],
- *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
- * })
- * // file.id      = SHA256 hash of 'src/models/petStore.ts'
- * // file.name    = 'petStore'
- * // file.extname = '.ts'
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
  * ```
  */
-declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
+type TypeLiteralNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'TypeLiteral';
+  /**
+   * Members of the object type, rendered in order.
+   */
+  members: Array<{
+    /**
+     * Member key.
+     */
+    name: string;
+    /**
+     * Member type expression.
+     */
+    type: TypeExpression;
+    /**
+     * Whether the member is optional, rendered with `?`.
+     */
+    optional?: boolean;
+  }>;
+};
 /**
- * Creates a `ConstNode` representing a TypeScript `const` declaration.
- *
- * Mirrors the `Const` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple constant
- * ```ts
- * createConst({ name: 'pet' })
- * // const pet = ...
- * ```
+ * AST node for a single field accessed from a named group type.
+ * TypeScript renders as `objectType['indexType']`.
  *
- * @example Exported constant with type and `as const`
+ * @example
  * ```ts
- * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
- * // export const pets: Pet[] = ... as const
+ * createIndexedAccessType({ objectType: 'GetPetPathParams', indexType: 'petId' })
+ * // GetPetPathParams['petId']
  * ```
+ */
+type IndexedAccessTypeNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'IndexedAccessType';
+  /**
+   * Name of the type being indexed, e.g. `'GetPetPathParams'`.
+   */
+  objectType: string;
+  /**
+   * Field key to access, e.g. `'petId'`.
+   */
+  indexType: string;
+};
+/**
+ * AST node for an object destructuring binding, used as the name of a grouped function parameter.
+ * TypeScript renders as `{ id, name }` or `{ id: renamed }` when `propertyName` differs.
  *
- * @example With JSDoc and child nodes
+ * @example
  * ```ts
- * createConst({
- *   name: 'config',
- *   export: true,
- *   JSDoc: { comments: ['@description App configuration'] },
- *   nodes: [],
- * })
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
  * ```
  */
-declare function createConst(props: Omit<ConstNode, 'kind'>): ConstNode;
+type ObjectBindingPatternNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'ObjectBindingPattern';
+  /**
+   * Bound elements, rendered in order.
+   */
+  elements: Array<{
+    /**
+     * Local binding name.
+     */
+    name: string;
+    /**
+     * Source key when it differs from the binding name, rendered as `propertyName: name`.
+     */
+    propertyName?: string;
+  }>;
+};
 /**
- * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+ * AST node for one function parameter.
  *
- * Mirrors the `Type` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
+ * A simple parameter has a `string` name. A destructured group has an
+ * {@link ObjectBindingPatternNode} name paired with a {@link TypeLiteralNode} type.
  *
- * @example Simple type alias
- * ```ts
- * createType({ name: 'Pet' })
- * // type Pet = ...
- * ```
+ * @example Required parameter
+ * `name: Type`
  *
- * @example Exported type with JSDoc
- * ```ts
- * createType({
- *   name: 'PetStatus',
- *   export: true,
- *   JSDoc: { comments: ['@description Status of a pet'] },
- * })
- * // export type PetStatus = ...
- * ```
+ * @example Optional parameter
+ * `name?: Type`
+ *
+ * @example Parameter with default value
+ * `name: Type = defaultValue`
+ *
+ * @example Rest parameter
+ * `...name: Type[]`
+ *
+ * @example Destructured group
+ * `{ id, name? }: { id: string; name?: string } = {}`
  */
-declare function createType(props: Omit<TypeNode, 'kind'>): TypeNode;
+type FunctionParameterNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'FunctionParameter';
+  /**
+   * Parameter name, or an {@link ObjectBindingPatternNode} for a destructured group.
+   */
+  name: string | ObjectBindingPatternNode;
+  /**
+   * Type annotation as a {@link TypeExpression}. Omit for untyped output.
+   */
+  type?: TypeExpression;
+  /**
+   * Whether the parameter is optional, rendered with `?`.
+   */
+  optional?: boolean;
+  /**
+   * Default value, written verbatim after `=`. Commonly `'{}'` for a destructured group.
+   */
+  default?: string;
+  /**
+   * When `true` the parameter is emitted as a rest parameter, e.g. `...name: Type[]`.
+   */
+  rest?: boolean;
+};
 /**
- * Creates a `FunctionNode` representing a TypeScript `function` declaration.
+ * AST node for a complete function parameter list.
+ *
+ * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
+ * Nodes are plain immutable data.
  *
- * Mirrors the `Function` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
+ * Renders differently depending on the output mode:
+ * - `declaration` → `(id: string, config: Config = {})` function declaration parameters
+ * - `call`        → `(id, { method, url })` function call arguments
+ */
+type FunctionParametersNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'FunctionParameters';
+  /**
+   * Ordered parameter nodes.
+   */
+  params: ReadonlyArray<FunctionParameterNode>;
+};
+/**
+ * Union of all function-parameter AST node variants used by the function-parameter printer.
+ */
+type FunctionParamNode = FunctionParameterNode | FunctionParametersNode | TypeLiteralNode | IndexedAccessTypeNode | ObjectBindingPatternNode;
+/**
+ * Handler-map keys for the function-parameter printer, one per {@link FunctionParamNode} kind.
+ */
+type FunctionParamKind = FunctionParamNode['kind'];
+/**
+ * Definition for the {@link TypeLiteralNode}.
+ */
+declare const typeLiteralDef: NodeDef<TypeLiteralNode, Pick<TypeLiteralNode, "members">>;
+/**
+ * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
  *
- * @example Simple function
+ * @example
  * ```ts
- * createFunction({ name: 'getPet' })
- * // function getPet() { ... }
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
  * ```
+ */
+declare const createTypeLiteral: (input: Pick<TypeLiteralNode, "members">) => TypeLiteralNode;
+/**
+ * Definition for the {@link IndexedAccessTypeNode}.
+ */
+declare const indexedAccessTypeDef: NodeDef<IndexedAccessTypeNode, Omit<IndexedAccessTypeNode, "kind">>;
+/**
+ * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
  *
- * @example Exported async function with return type
+ * @example
  * ```ts
- * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
- * // export async function fetchPet(): Promise<Pet> { ... }
+ * createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
+ * // DeletePetPathParams['petId']
  * ```
+ */
+declare const createIndexedAccessType: (input: Omit<IndexedAccessTypeNode, "kind">) => IndexedAccessTypeNode;
+/**
+ * Definition for the {@link ObjectBindingPatternNode}.
+ */
+declare const objectBindingPatternDef: NodeDef<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, "elements">>;
+/**
+ * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
  *
- * @example Function with generics and params
+ * @example
  * ```ts
- * createFunction({
- *   name: 'identity',
- *   export: true,
- *   generics: ['T'],
- *   params: 'value: T',
- *   returnType: 'T',
- * })
- * // export function identity<T>(value: T): T { ... }
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
  * ```
  */
-declare function createFunction(props: Omit<FunctionNode, 'kind'>): FunctionNode;
+declare const createObjectBindingPattern: (input: Pick<ObjectBindingPatternNode, "elements">) => ObjectBindingPatternNode;
 /**
- * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
- *
- * Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
+ * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.
+ */
+type FunctionParameterProperty = {
+  name: string;
+  type: TypeExpression;
+  optional?: boolean;
+};
+type FunctionParameterInput = {
+  name: string;
+  type?: TypeExpression;
+  optional?: boolean;
+  default?: string;
+  rest?: boolean;
+} | {
+  properties: Array<FunctionParameterProperty>;
+  optional?: boolean;
+  default?: string;
+};
+/**
+ * Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
+ * Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+ * paired with a {@link TypeLiteralNode} type.
+ */
+declare const functionParameterDef: NodeDef<FunctionParameterNode, FunctionParameterInput>;
+/**
+ * Creates a `FunctionParameterNode`. `optional` defaults to `false`.
  *
- * @example Simple arrow function
+ * @example Optional param
  * ```ts
- * createArrowFunction({ name: 'getPet' })
- * // const getPet = () => { ... }
+ * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+ * // → params?: QueryParams
  * ```
  *
- * @example Single-line exported arrow function
+ * @example Destructured group
  * ```ts
- * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
- * // export const double = (n: number) => ...
+ * createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+ * // → { id, name }: { id: string; name?: string } = {}
  * ```
+ */
+declare const createFunctionParameter: (input: FunctionParameterInput) => FunctionParameterNode;
+/**
+ * Definition for the {@link FunctionParametersNode}.
+ */
+declare const functionParametersDef: NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>>;
+/**
+ * Creates a `FunctionParametersNode` from an ordered list of parameters.
  *
- * @example Async arrow function with generics
+ * @example
  * ```ts
- * createArrowFunction({
- *   name: 'fetchPet',
- *   export: true,
- *   async: true,
- *   generics: ['T'],
- *   params: 'id: string',
- *   returnType: 'T',
- * })
- * // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
+ * const empty = createFunctionParameters()
+ * // { kind: 'FunctionParameters', params: [] }
  * ```
  */
-declare function createArrowFunction(props: Omit<ArrowFunctionNode, 'kind'>): ArrowFunctionNode;
+declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+//#endregion
+//#region ../../internals/utils/src/promise.d.ts
 /**
- * Creates a {@link TextNode} representing a raw string fragment in the source output.
+ * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.
  *
- * Use this instead of bare strings when building `nodes` arrays so that every
- * entry in the array is a typed {@link CodeNode}.
+ * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large
+ * collections can be produced lazily without holding every item in memory. Pairs with
+ * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.
  *
  * @example
  * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
+ * type Eager = Streamable<number> // Array<number>
+ * type Lazy = Streamable<number, true> // AsyncIterable<number>
  * ```
  */
-declare function createText(value: string): TextNode;
+type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>;
+//#endregion
+//#region src/nodes/parameter.d.ts
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
 /**
- * Creates a {@link BreakNode} representing a line break in the source output.
- *
- * Corresponds to `<br/>` in JSX components. Prints as an empty string which,
- * when joined with `\n` by `printNodes`, produces a blank line.
+ * AST node representing one operation parameter.
  *
  * @example
  * ```ts
- * createBreak()
- * // { kind: 'Break' }
+ * const param: ParameterNode = {
+ *   kind: 'Parameter',
+ *   name: 'petId',
+ *   in: 'path',
+ *   schema: createSchema({ type: 'string' }),
+ *   required: true,
+ * }
  * ```
  */
-declare function createBreak(): BreakNode;
+type ParameterNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Parameter';
+  /**
+   * Parameter name.
+   */
+  name: string;
+  /**
+   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   */
+  in: ParameterLocation;
+  /**
+   * Parameter schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the parameter is required.
+   */
+  required: boolean;
+};
+type UserParameterNode = Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>;
 /**
- * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
- *
- * Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
+ * Definition for the {@link ParameterNode}. `required` defaults to `false` and the
+ * schema's `optional`/`nullish` flags are kept in sync with it.
+ */
+declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
+/**
+ * Creates a `ParameterNode`.
  *
  * @example
  * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+ * const param = createParameter({
+ *   name: 'petId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: createSchema({ type: 'string' }),
+ * })
  * ```
  */
-declare function createJsx(value: string): JsxNode;
+declare const createParameter: (input: UserParameterNode) => ParameterNode;
 //#endregion
-//#region src/printer.d.ts
+//#region src/nodes/requestBody.d.ts
 /**
- * Runtime context passed as `this` to printer handlers.
+ * AST node representing an operation request body.
  *
- * `this.transform` dispatches to node-level handlers from `nodes`.
+ * Body schemas live exclusively inside the `content` array (one entry per content type),
+ * mirroring {@link ResponseNode}.
  *
  * @example
  * ```ts
- * const context: PrinterHandlerContext<string, {}> = {
- *   options: {},
- *   transform: () => 'value',
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
-type PrinterHandlerContext<TOutput, TOptions extends object> = {
+type RequestBodyNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'RequestBody';
+  /**
+   * Human-readable request body description.
+   */
+  description?: string;
   /**
-   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
-   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
+   * Whether the request body is required (`requestBody.required: true` in the spec).
+   * When `false` or absent, the generated `data` parameter should be optional.
    */
-  transform: (node: SchemaNode) => TOutput | null;
+  required?: boolean;
   /**
-   * Options for this printer instance.
+   * 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`).
    */
-  options: TOptions;
+  content?: Array<ContentNode>;
+};
+/**
+ * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ */
+type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
+  content?: Array<UserContent>;
 };
 /**
- * Handler for one schema node type.
+ * Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
+ */
+declare const requestBodyDef: NodeDef<RequestBodyNode, UserRequestBody>;
+/**
+ * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ */
+declare const createRequestBody: (input: UserRequestBody) => RequestBodyNode;
+//#endregion
+//#region src/nodes/http.d.ts
+/**
+ * All supported HTTP status code literals as strings, as used in API specs
+ * (for example, `"200"` and `"404"`).
+ */
+type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
+/**
+ * Response status code literal used by operations.
  *
- * Use a regular function (not an arrow function) if you need `this`.
+ * Includes specific HTTP status code strings and `"default"` for catch-all responses.
  *
  * @example
  * ```ts
- * const handler: PrinterHandler<string, {}, 'string'> = function () {
- *   return 'string'
- * }
+ * const status: StatusCode = '200'
+ * const fallback: StatusCode = 'default'
  * ```
  */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null;
+type StatusCode = HttpStatusCode | 'default';
+//#endregion
+//#region src/nodes/response.d.ts
 /**
- * Partial map of per-node-type handler overrides for a printer.
+ * AST node representing one operation response variant.
  *
- * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
- * Supply only the handlers you want to replace. The printer's built-in
- * defaults fill in the rest.
+ * 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
- * pluginZod({
- *   printer: {
- *     nodes: {
- *       date(): string {
- *         return 'z.string().date()'
- *       },
- *     } satisfies PrinterPartial<string, PrinterZodOptions>,
- *   },
- * })
+ * const response: ResponseNode = {
+ *   kind: 'Response',
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
  * ```
  */
-type PrinterPartial<TOutput, TOptions extends object> = Partial<{ [K in SchemaType]: PrinterHandler<TOutput, TOptions, K> }>;
+type ResponseNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Response';
+  /**
+   * HTTP status code or `'default'` for a fallback response.
+   */
+  statusCode: StatusCode;
+  /**
+   * Optional response description.
+   */
+  description?: string;
+  /**
+   * 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'
+   * ```
+   */
+  content?: Array<ContentNode>;
+};
+type ResponseInput = Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
+  content?: Array<UserContent>;
+  schema?: SchemaNode;
+  mediaType?: string | null;
+  keysToOmit?: Array<string> | null;
+};
+/**
+ * Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+ * `mediaType`/`keysToOmit`) is normalized into one `content` entry.
+ */
+declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
 /**
- * Generic shape used by `definePrinter`.
- *
- * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions` options passed to and stored on the printer instance
- * - `TOutput` the type emitted by node handlers
- * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)
+ * Creates a `ResponseNode`.
  *
  * @example
  * ```ts
- * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ * })
  * ```
  */
-type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
-  name: TName;
-  options: TOptions;
-  output: TOutput;
-  printOutput: TPrintOutput;
+declare const createResponse: (input: ResponseInput) => ResponseNode;
+//#endregion
+//#region src/nodes/operation.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
+/**
+ * Transport an operation belongs to.
+ */
+type OperationProtocol = 'http';
+/**
+ * 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`.
+   */
+  tags: Array<string>;
+  /**
+   * Short one-line operation summary.
+   */
+  summary?: string;
+  /**
+   * Full operation description.
+   */
+  description?: string;
+  /**
+   * Marks the operation as deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   */
+  parameters: Array<ParameterNode>;
+  /**
+   * Request body for the operation.
+   */
+  requestBody?: RequestBodyNode;
+  /**
+   * Operation responses.
+   */
+  responses: Array<ResponseNode>;
 };
 /**
- * Printer instance returned by a printer factory.
+ * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
  *
  * @example
  * ```ts
- * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
+ * const operation: HttpOperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   protocol: 'http',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
  * ```
  */
-type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
-  /**
-   * Unique identifier supplied at creation time.
-   */
-  name: T['name'];
+type HttpOperationNode = OperationNodeBase & {
   /**
-   * Options for this printer instance.
+   * Transport the operation belongs to.
    */
-  options: T['options'];
+  protocol?: 'http';
   /**
-   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
-   * Always dispatches through the `nodes` map. Never calls the `print` override.
-   * Use this when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
+   * HTTP method like `'GET'`.
    */
-  transform: (node: SchemaNode) => T['output'] | null;
+  method: HttpMethod;
   /**
-   * 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.
+   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
    */
-  print: (node: SchemaNode) => T['printOutput'] | null;
+  path: string;
 };
 /**
- * Builder function passed to `definePrinter`.
- *
- * It receives resolved options and returns:
- * - `name`
- * - `options`
- * - `nodes` handlers
- * - optional top-level `print` override
- *
- * @example
- * ```ts
- * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
- * ```
+ * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
  */
-type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
-  name: T['name'];
-  /**
-   * Options to store on the printer.
-   */
-  options: T['options'];
-  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K> }>;
+type GenericOperationNode = OperationNodeBase & {
   /**
-   * Optional root-level print override. When provided, becomes the public `printer.print`.
-   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
-   * not the override itself, so recursion is safe.
+   * Transport the operation belongs to.
    */
-  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
+  protocol?: Exclude<OperationProtocol, 'http'>;
+  method?: never;
+  path?: never;
 };
 /**
- * Defines a schema printer: a function that takes a `SchemaNode` and emits
- * code in your target language. Each plugin that produces code from schemas
- * (TypeScript types, Zod schemas, Faker factories) ships a printer built
- * with this helper.
- *
- * The builder receives resolved options and returns:
- *
- * - `name` unique identifier for the printer.
- * - `options` stored on the returned printer instance.
- * - `nodes` map of `SchemaType` → handler. Handlers return the rendered
- *   output (a string, a TypeScript AST node, ...) for that schema type.
- * - `print` (optional), top-level override exposed as `printer.print`.
- *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
- *
- * Without a `print` override, `printer.print` falls back to `printer.transform`
- * (the node-level dispatcher).
- *
- * @example Tiny Zod printer
- * ```ts
- * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
- *
- * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+ * AST node representing one API operation.
  *
- * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
- *   name: 'zod',
- *   options: { strict: options.strict ?? true },
- *   nodes: {
- *     string: () => 'z.string()',
- *     object(node) {
- *       const props = node.properties
- *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
- *         .join(', ')
- *       return `z.object({ ${props} })`
- *     },
- *   },
- * }))
- * ```
+ * 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`.
  */
-declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
-/**
- * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
- **
- * @example
- * ```ts
- * export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
- *   (node) => kindToHandlerKey[node.kind],
- * )
- * ```
- */
-declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | 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;
-    options: T["options"];
-  }, node: TNodeByKey[K]) => T["output"] | null }>;
-  print?: (this: {
-    transform: (node: TNode) => T["output"] | null;
-    options: T["options"];
-  }, node: TNode) => T["printOutput"] | null;
-}) => (options?: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  transform: (node: TNode) => T["output"] | null;
-  print: (node: TNode) => T["printOutput"] | null;
+type OperationNode = HttpOperationNode | GenericOperationNode;
+type OperationInput = {
+  operationId: string;
+  method?: HttpOperationNode['method'];
+  path?: HttpOperationNode['path'];
+  requestBody?: UserRequestBody;
+  [key: string]: unknown;
 };
-//#endregion
-//#region src/visitor.d.ts
 /**
- * Ordered mapping of `[NodeType, ParentType]` pairs.
- *
- * `ParentOf` uses this map to find parent types.
+ * Definition for the {@link OperationNode}. HTTP operations (those carrying both
+ * `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
+ * normalized into a `RequestBodyNode`.
  */
-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]];
+declare const operationDef: NodeDef<OperationNode, OperationInput>;
 /**
- * Resolves the parent node type for a given AST node type.
- *
- * This is used by visitor context so `ctx.parent` is correctly typed
- * for each callback.
- *
- * @example
- * ```ts
- * type InputParent = ParentOf<InputNode>
- * // undefined
- * ```
- *
- * @example
- * ```ts
- * type PropertyParent = ParentOf<PropertyNode>
- * // SchemaNode
- * ```
+ * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
  *
  * @example
  * ```ts
- * type SchemaParent = ParentOf<SchemaNode>
- * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
+ * const operation = createOperation({ operationId: 'getPetById', method: 'GET', path: '/pet/{petId}' })
+ * // tags, parameters, and responses are []
  * ```
  */
-type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [infer TEntry extends [Node, unknown], ...infer TRest extends ReadonlyArray<[Node, unknown]>] ? T extends TEntry[0] ? TEntry[1] : ParentOf<T, TRest> : Node;
+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;
+//#endregion
+//#region src/nodes/input.d.ts
 /**
- * Traversal context passed as the second argument to every visitor callback.
- * `parent` is typed from the current node type.
+ * 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 visitor: Visitor = {
- *   schema(node, { parent }) {
- *     // parent type is narrowed by node kind
- *   },
- * }
+ * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
  * ```
  */
-type VisitorContext<T extends Node = Node> = {
+type InputMeta = {
+  /**
+   * API title from `info.title` in the source document.
+   */
+  title?: string;
+  /**
+   * API description from `info.description` in the source document.
+   */
+  description?: string;
+  /**
+   * API version string from `info.version` in the source document.
+   */
+  version?: string;
+  /**
+   * 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>;
   /**
-   * Parent node of the currently visited node.
-   * For `InputNode`, this is `undefined`.
+   * 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)`
    */
-  parent?: ParentOf<T>;
+  enumNames: ReadonlyArray<string>;
 };
 /**
- * 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.
+ * Input AST node that contains all schemas and operations for one API document.
+ * Produced by the adapter and consumed by all Kubb plugins.
  *
- * Plugins typically expose `transformer` so users can supply a `Visitor` that
- * rewrites operation IDs, drops descriptions, or otherwise tweaks the AST
- * before printing.
+ * `Stream` switches `schemas` and `operations` between eager `Array`s (the default) and lazy
+ * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time and makes
+ * `meta` optional, since the adapter can emit metadata before the first node is parsed.
  *
- * @example Prefix every operationId
+ * @example
  * ```ts
- * const visitor: Visitor = {
- *   operation(node) {
- *     return { ...node, operationId: `api_${node.operationId}` }
- *   },
+ * const input: InputNode = {
+ *   kind: 'Input',
+ *   schemas: [],
+ *   operations: [],
+ *   meta: { circularNames: [], enumNames: [] },
  * }
  * ```
  *
- * @example Strip schema descriptions
+ * @example Streaming variant for large specs
  * ```ts
- * const visitor: Visitor = {
- *   schema(node) {
- *     return { ...node, description: undefined }
- *   },
+ * for await (const schema of inputNode.schemas) {
+ *   // only this one SchemaNode is live here. Previous ones are GC-eligible
  * }
  * ```
  */
-type Visitor = {
-  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;
-};
+type InputNode<Stream extends boolean = false> = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Input';
+  /**
+   * All schema nodes in the document.
+   */
+  schemas: Streamable<SchemaNode, Stream>;
+  /**
+   * All operation nodes in the document.
+   */
+  operations: Streamable<OperationNode, Stream>;
+} & (Stream extends true ? {
+  meta?: InputMeta;
+} : {
+  meta: InputMeta;
+});
 /**
- * Utility type for values that can be returned directly or asynchronously.
+ * Definition for the {@link InputNode}.
  */
-type MaybePromise<T> = T | Promise<T>;
+declare const inputDef: NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>>;
 /**
- * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
+ * Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
+ * `operations` are `AsyncIterable` sources and whose `meta` is optional. Otherwise it builds the
+ * eager variant with array `schemas`/`operations` and the defaulted `meta`.
  *
- * @example
+ * @example Eager
  * ```ts
- * const visitor: AsyncVisitor = {
- *   async operation(node) {
- *     await Promise.resolve(node.operationId)
- *   },
- * }
+ * const input = createInput()
+ * // { kind: 'Input', schemas: [], operations: [] }
  * ```
- */
-type AsyncVisitor = {
-  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`.
  *
- * @example
+ * @example Streaming
  * ```ts
- * const visitor: CollectVisitor<string> = {
- *   operation(node) {
- *     return node.operationId
- *   },
- * }
+ * const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
  * ```
  */
-type CollectVisitor<T> = {
-  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;
-};
+declare function createInput<Stream extends boolean = false>(options?: Partial<Omit<InputNode<Stream>, 'kind'>> & {
+  stream?: Stream;
+}): InputNode<Stream>;
+//#endregion
+//#region src/nodes/output.d.ts
 /**
- * Options for `transform`.
+ * Output AST node that groups all generated file output for one API document.
  *
- * @example
- * ```ts
- * const options: TransformOptions = { depth: 'deep', schema: (node) => node }
- * ```
+ * Produced by generators and consumed by the build pipeline to write files.
  *
  * @example
  * ```ts
- * // Only transform the current node, not nested children
- * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
+ * const output: OutputNode = {
+ *   kind: 'Output',
+ *   files: [],
+ * }
  * ```
  */
-type TransformOptions = Visitor & {
+type OutputNode = BaseNode & {
   /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
+   * Node kind.
    */
-  depth?: VisitorDepth;
+  kind: 'Output';
   /**
-   * Internal parent override used during recursion.
+   * Generated file nodes.
    */
-  parent?: Node;
+  files: Array<FileNode>;
 };
 /**
- * Options for `walk`.
- *
- * @example
- * ```ts
- * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }
- * ```
+ * Definition for the {@link OutputNode}.
  */
-type WalkOptions = AsyncVisitor & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Maximum number of sibling nodes visited concurrently.
-   * @default 30
-   */
-  concurrency?: number;
-};
+declare const outputDef: NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>>;
 /**
- * Options for `collect`.
+ * Creates an `OutputNode` with a stable default for `files`.
  *
  * @example
  * ```ts
- * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
- * ```
- */
-type CollectOptions<T> = CollectVisitor<T> & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
-/**
- * Async depth-first traversal for side effects. Visitor return values are
- * ignored. Use `transform` when you want to rewrite nodes.
- *
- * Sibling nodes at each depth run concurrently up to `options.concurrency`
- * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
- * work. Lower values reduce memory pressure.
- *
- * @example Log every operation
- * ```ts
- * await walk(root, {
- *   operation(node) {
- *     console.log(node.operationId)
- *   },
- * })
- * ```
- *
- * @example Only visit the root node
- * ```ts
- * await walk(root, { depth: 'shallow', input: () => {} })
+ * const output = createOutput()
+ * // { kind: 'Output', files: [] }
  * ```
  */
-declare function walk(node: Node, options: WalkOptions): Promise<void>;
+declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): OutputNode;
+//#endregion
+//#region src/nodes/index.d.ts
 /**
- * Synchronous depth-first transform. Each visitor callback gets a chance to
- * return a replacement node; `undefined` keeps the original.
- *
- * The transform is immutable. The original tree is not mutated. A new tree
- * is returned. Use `depth: 'shallow'` to skip recursion into children.
- *
- * @example Prefix every operationId
- * ```ts
- * const next = transform(root, {
- *   operation(node) {
- *     return { ...node, operationId: `prefixed_${node.operationId}` }
- *   },
- * })
- * ```
+ * Union of all AST node types.
  *
- * @example Replace only the root node
- * ```ts
- * const next = transform(root, {
- *   depth: 'shallow',
- *   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
- * })
- * ```
- */
-declare function transform(node: InputNode, options: TransformOptions): InputNode;
-declare function transform(node: OutputNode, options: TransformOptions): OutputNode;
-declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
-declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
-declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
-declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
-declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
-declare function transform(node: Node, options: TransformOptions): Node;
-/**
- * Eager depth-first collection pass. Returns an array of every non-null value
- * the visitor callbacks return.
+ * This lets TypeScript narrow types in `switch (node.kind)` blocks.
  *
- * @example Collect every operationId
+ * @example
  * ```ts
- * const ids = collect<string>(root, {
- *   operation(node) {
- *     return node.operationId
- *   },
- * })
+ * function getKind(node: Node): string {
+ *   switch (node.kind) {
+ *     case 'Input':
+ *       return 'input'
+ *     case 'Output':
+ *       return 'output'
+ *     default:
+ *       return 'other'
+ *   }
+ * }
  * ```
  */
-declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
+type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
 //#endregion
 //#region src/utils/ast.d.ts
 /**
@@ -3373,6 +2504,19 @@ declare function createDiscriminantNode({
   propertyName: string;
   value: string;
 }): SchemaNode;
+/**
+ * Named type for a group of parameters (query or header) emitted as a single typed parameter.
+ */
+type ParamGroupType = {
+  /**
+   * Type expression for the group, a plain group-name reference.
+   */
+  type: TypeExpression;
+  /**
+   * Whether the parameter group is optional.
+   */
+  optional: boolean;
+};
 /**
  * Resolver interface for {@link createOperationParams}.
  *
@@ -3458,7 +2602,7 @@ type CreateOperationParamsOptions = {
    * extraParams: [createFunctionParameter({ name: 'options', type: 'Partial<RequestOptions>', default: '{}' })]
    * ```
    */
-  extraParams?: Array<FunctionParameterNode | ParameterGroupNode>;
+  extraParams?: Array<FunctionParameterNode>;
   /**
    * Override the default parameter names used for body, query, header, and rest-path groups.
    *
@@ -3497,22 +2641,65 @@ type CreateOperationParamsOptions = {
    */
   typeWrapper?: (type: string) => string;
 };
+/**
+ * Resolves the {@link TypeExpression} for an individual parameter.
+ *
+ * Without a resolver, falls back to the schema primitive (a plain type-name string).
+ * When the parameter belongs to a named group, emits an {@link IndexedAccessTypeNode}
+ * (`GroupParams['petId']`); otherwise the resolved individual name as a plain string.
+ */
+declare function resolveParamType({
+  node,
+  param,
+  resolver
+}: {
+  node: OperationNode;
+  param: ParameterNode;
+  resolver: OperationParamsResolver | undefined;
+}): TypeExpression;
 /**
  * Converts an `OperationNode` into function parameters for code generation.
  *
- * Centralizes parameter grouping logic for all plugins. Provide a `resolver` for type name resolution
- * and `extraParams` for plugin-specific trailing parameters (e.g., `options` objects).
- * Supports three grouping modes: `object` (single destructured param), `inline` (separate params),
- * and `inlineSpread` (rest parameter). Use `CreateOperationParamsOptions` to fine-tune output.
+ * Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
+ * destructured object parameter (`object`) and separate top-level parameters (`inline`), while
+ * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
+ * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
  */
 declare function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
 /**
- * Extracts all string content from a `CodeNode` tree recursively.
+ * Shared arguments for building a query or header parameter group.
+ */
+type BuildGroupArgs = {
+  name: string;
+  node: OperationNode;
+  params: Array<ParameterNode>;
+  groupType: ParamGroupType | null;
+  resolver: OperationParamsResolver | undefined;
+  wrapType: (type: string) => string;
+};
+/**
+ * Builds a single {@link FunctionParameterNode} for a query or header group.
+ * Returns an empty array when there are no params to emit.
  *
- * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
- * and nested node content. Used internally to build the full source string for import filtering.
+ * A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+ * {@link TypeLiteralNode} from the individual params.
  */
-declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
+declare function buildGroupParam(args: BuildGroupArgs): Array<FunctionParameterNode>;
+/**
+ * Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
+ *
+ * Used when query or header parameters have no dedicated group type name.
+ * Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
+ */
+declare function buildTypeLiteral({
+  node,
+  params,
+  resolver
+}: {
+  node: OperationNode;
+  params: Array<ParameterNode>;
+  resolver: OperationParamsResolver | undefined;
+}): TypeLiteralNode;
 declare function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
 /**
  * Identifies all schemas that participate in circular dependency chains, including direct self-loops.
@@ -3540,5 +2727,5 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-export { DedupeCanonical as $, schemaTypes as $t, createFunctionParameter as A, NumberSchemaNode as At, createProperty as B, UnionSchemaNode as Bt, UserFileNode as C, ImportNode as Ct, createExport as D, DatetimeSchemaNode as Dt, createConst as E, DateSchemaNode as Et, createOperation as F, SchemaNode as Ft, createText as G, ConstNode as Gt, createSchema as H, PropertyNode as Ht, createOutput as I, SchemaNodeByType as It, update as J, JsxNode as Jt, createType as K, FunctionNode as Kt, createParameter as L, SchemaType as Lt, createImport as M, PrimitiveSchemaType as Mt, createInput as N, RefSchemaNode as Nt, createFile as O, EnumSchemaNode as Ot, createJsx as P, ScalarSchemaType as Pt, defineSchemaDialect as Q, httpMethods as Qt, createParameterGroup as R, StringSchemaNode as Rt, DistributiveOmit as S, FileNode as St, createBreak as T, ArraySchemaNode as Tt, createSource as U, ArrowFunctionNode as Ut, createResponse as V, UrlSchemaNode as Vt, createStreamInput as W, CodeNode as Wt, ParserOptions as X, TypeNode as Xt, InferSchemaNode as Y, TextNode as Yt, SchemaDialect as Z, NodeKind as Zt, Printer as _, FunctionParameterNode as _t, createDiscriminantNode as a, OutputNode as at, createPrinterFactory as b, ParamsTypeNode as bt, findCircularSchemas as c, HttpMethod as ct, ParentOf as d, ResponseNode as dt, DedupeLookups as et, Visitor as f, StatusCode as ft, walk as g, FunctionParamNode as gt, transform as h, FunctionNodeType as ht, containsCircularRef as i, Node as it, createFunctionParameters as j, ObjectSchemaNode as jt, createFunction as k, IntersectionSchemaNode as kt, isStringType as l, HttpOperationNode as lt, collect as m, ParameterNode as mt, caseParams as n, applyDedupe as nt, createOperationParams as o, InputMeta as ot, VisitorContext as p, ParameterLocation as pt, syncOptionality as q, JSDocNode as qt, collectUsedSchemaNames as r, buildDedupePlan as rt, extractStringsFromNodes as s, InputNode as st, OperationParamsResolver as t, DedupePlan as tt, syncSchemaRef as u, OperationNode as ut, PrinterFactoryOptions as v, FunctionParametersNode as vt, createArrowFunction as w, SourceNode as wt, definePrinter as x, ExportNode as xt, PrinterPartial as y, ParameterGroupNode as yt, createParamsType as z, TimeSchemaNode as zt };
-//# sourceMappingURL=types-BL7RpQAE.d.ts.map
+export { functionParametersDef as $, createBreak as $t, responseDef as A, StringSchemaNode as At, FunctionParamNode as B, ParserOptions as Bt, HttpMethod as C, ObjectSchemaNode as Ct, operationDef as D, SchemaNode as Dt, createOperation as E, ScalarSchemaType as Et, ParameterLocation as F, schemaDef as Ft, TypeExpression as G, JSDocNode as Gt, FunctionParametersNode as H, CodeNode as Ht, ParameterNode as I, PropertyNode as It, createFunctionParameters as J, TypeNode as Jt, TypeLiteralNode as K, JsxNode as Kt, createParameter as L, createProperty as Lt, RequestBodyNode as M, UnionSchemaNode as Mt, createRequestBody as N, UrlSchemaNode as Nt, ResponseNode as O, SchemaNodeByType as Ot, requestBodyDef as P, createSchema as Pt, functionParameterDef as Q, createArrowFunction as Qt, parameterDef as R, propertyDef as Rt, inputDef as S, NumberSchemaNode as St, OperationNode as T, RefSchemaNode as Tt, IndexedAccessTypeNode as U, ConstNode as Ut, FunctionParameterNode as V, ArrowFunctionNode as Vt, ObjectBindingPatternNode as W, FunctionNode as Wt, createObjectBindingPattern as X, breakDef as Xt, createIndexedAccessType as Y, arrowFunctionDef as Yt, createTypeLiteral as Z, constDef as Zt, createOutput as _, ArraySchemaNode as _t, buildTypeLiteral as a, functionDef as an, ImportNode as at, InputNode as b, EnumSchemaNode as bt, containsCircularRef as c, typeDef as cn, createImport as ct, findCircularSchemas as d, defineNode as dn, fileDef as dt, createConst as en, indexedAccessTypeDef as et, isStringType as f, syncOptionality as fn, importDef as ft, OutputNode as g, createContent as gt, Node as h, contentDef as ht, buildGroupParam as i, createType as in, FileNode as it, StatusCode as j, TimeSchemaNode as jt, createResponse as k, SchemaType as kt, createDiscriminantNode as l, DistributiveOmit as ln, createSource as lt, syncSchemaRef as m, ContentNode as mt, OperationParamsResolver as n, createJsx as nn, typeLiteralDef as nt, caseParams as o, jsxDef as on, SourceNode as ot, resolveParamType as p, NodeKind as pn, sourceDef as pt, createFunctionParameter as q, TextNode as qt, ParamGroupType as r, createText as rn, ExportNode as rt, collectUsedSchemaNames as s, textDef as sn, createExport as st, BuildGroupArgs as t, createFunction as tn, objectBindingPatternDef as tt, createOperationParams as u, NodeDef as un, exportDef as ut, outputDef as v, DateSchemaNode as vt, HttpOperationNode as w, PrimitiveSchemaType as wt, createInput as x, IntersectionSchemaNode as xt, InputMeta as y, DatetimeSchemaNode as yt, FunctionParamKind as z, InferSchemaNode as zt };
+//# sourceMappingURL=ast-ClnJg9BN.d.ts.map