@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.61

package/dist/index-BzjwdK2M.d.ts

@@ -0,0 +1,2433 @@
+import { n as __name } from "./chunk-CNktS9qV.js";
+
+//#region src/nodes/base.d.ts
+/**
+ * `kind` values used by AST nodes.
+ *
+ * @example
+ * ```ts
+ * const kind: NodeKind = 'Schema'
+ * ```
+ */
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | 'FunctionParameter' | 'FunctionParameters' | 'TypeLiteral' | 'IndexedAccessType' | 'ObjectBindingPattern' | 'Type' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
+/**
+ * Base shape shared by all AST nodes.
+ *
+ * @example
+ * ```ts
+ * const base: BaseNode = { kind: 'Input' }
+ * ```
+ */
+type BaseNode = {
+  /**
+   * Node discriminator.
+   */
+  kind: NodeKind;
+};
+//#endregion
+//#region src/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> = {
+  /**
+   * Node discriminator this definition owns.
+   */
+  kind: NodeKind;
+  /**
+   * Builds a node from its input, applying `defaults` and the optional `build` hook.
+   */
+  create: (input: TInput) => TNode;
+  /**
+   * Type guard matching this node kind.
+   */
+  is: (node: unknown) => node is TNode;
+  /**
+   * Child node fields in traversal order. Feeds `VISITOR_KEYS`.
+   */
+  children?: ReadonlyArray<string>;
+  /**
+   * Visitor callback name. Feeds `VISITOR_KEY_BY_KIND`.
+   */
+  visitorKey?: VisitorKey;
+  /**
+   * When `true`, `create` is rerun after children are rebuilt so computed fields
+   * stay in sync. Feeds `nodeRebuilders`.
+   */
+  rebuild?: boolean;
+};
+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;
+};
+/**
+ * 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.
+ *
+ * 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 importDef = defineNode<ImportNode>({ kind: 'Import' })
+ * const createImport = importDef.create
+ * ```
+ *
+ * @example Node with a build hook that is rerun on transform
+ * ```ts
+ * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+ *   kind: 'Property',
+ *   build: (props) => ({ ...props, required: props.required ?? false }),
+ *   children: ['schema'],
+ *   visitorKey: 'property',
+ *   rebuild: true,
+ * })
+ * ```
+ */
+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
+/**
+ * JSDoc documentation metadata attached to code declarations.
+ */
+type JSDocNode = {
+  /**
+   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
+   *
+   * @example
+   * ```ts
+   * ['@description A pet resource', '@deprecated']
+   * ```
+   */
+  comments?: Array<string | undefined>;
+};
+/**
+ * AST node representing a TypeScript `const` declaration.
+ *
+ * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createConst({ name: 'pet', export: true, asConst: true })
+ * // export const pet = ... as const
+ * ```
+ */
+type ConstNode = BaseNode & {
+  kind: 'Const';
+  /**
+   * Name of the constant declaration.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Explicit type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
+   */
+  type?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Whether to append `as const` to the declaration.
+   */
+  asConst?: boolean | null;
+  /**
+   * Child nodes representing the value of the constant (children of the `Const` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `type` alias declaration.
+ *
+ * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
+ */
+type TypeNode = BaseNode & {
+  kind: 'Type';
+  /**
+   * Name of the type alias.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the type body (children of the `Type` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `function` declaration.
+ *
+ * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createFunctionDeclaration({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function getPet(): Promise<Pet> { ... }
+ * ```
+ */
+type FunctionNode = BaseNode & {
+  kind: 'Function';
+  /**
+   * Name of the function.
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   */
+  default?: boolean | null;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  params?: string | null;
+  /**
+   * Whether the function should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
+   */
+  async?: boolean | null;
+  /**
+   * TypeScript generic type parameters.
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
+   */
+  generics?: string | Array<string> | null;
+  /**
+   * Return type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
+   */
+  returnType?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the function body (children of the `Function` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createArrowFunctionDeclaration({ name: 'getPet', export: true, singleLine: true })
+ * // export const getPet = () => ...
+ * ```
+ */
+type ArrowFunctionNode = BaseNode & {
+  kind: 'ArrowFunction';
+  /**
+   * Name of the arrow function (used as the `const` variable name).
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   */
+  default?: boolean | null;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  params?: string | null;
+  /**
+   * Whether the arrow function should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
+   */
+  async?: boolean | null;
+  /**
+   * TypeScript generic type parameters.
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
+   */
+  generics?: string | Array<string> | null;
+  /**
+   * Return type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
+   */
+  returnType?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Render the arrow function body as a single-line expression.
+   */
+  singleLine?: boolean | null;
+  /**
+   * Child nodes representing the function body (children of the `Function.Arrow` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a raw text/string fragment in the source output.
+ *
+ * Used instead of bare `string` values so that all entries in `nodes` arrays
+ * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
+ */
+type TextNode = BaseNode & {
+  kind: 'Text';
+  /**
+   * The raw string content.
+   */
+  value: string;
+};
+/**
+ * AST node representing a line break in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. When printed it produces an empty string,
+ * so joining nodes with `\n` in `printNodes` leaves a blank line between the surrounding code.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * // prints as '' → blank line when surrounded by other nodes
+ * ```
+ */
+type BreakNode = BaseNode & {
+  kind: 'Break';
+};
+/**
+ * AST node representing a raw JSX fragment in the source output.
+ *
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
+ * (including fragments `<>…</>`) directly in generated code.
+ *
+ * @example
+ * ```ts
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+ * ```
+ */
+type JsxNode = BaseNode & {
+  kind: 'Jsx';
+  /**
+   * The raw JSX string content.
+   */
+  value: string;
+};
+/**
+ * Union of all code-generation AST nodes.
+ *
+ * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
+ * structured children in {@link SourceNode.nodes}.
+ */
+type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
+/**
+ * Definition for the {@link ConstNode}.
+ */
+declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
+/**
+ * Creates a `ConstNode` representing a TypeScript `const` declaration.
+ *
+ * @example Exported constant with type and `as const`
+ * ```ts
+ * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+ * // export const pets: Pet[] = ... as const
+ * ```
+ */
+declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
+/**
+ * Definition for the {@link TypeNode}.
+ */
+declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
+/**
+ * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
+ */
+declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
+/**
+ * Definition for the {@link FunctionNode}.
+ */
+declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
+/**
+ * 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> { ... }
+ * ```
+ */
+declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
+/**
+ * Definition for the {@link ArrowFunctionNode}.
+ */
+declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
+/**
+ * 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) => ...
+ * ```
+ */
+declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
+/**
+ * Definition for the {@link TextNode}.
+ */
+declare const textDef: NodeDef<TextNode, string>;
+/**
+ * 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)' }
+ * ```
+ */
+declare const createText: (input: string) => TextNode;
+/**
+ * Definition for the {@link BreakNode}.
+ */
+declare const breakDef: NodeDef<BreakNode, void>;
+/**
+ * Creates a {@link BreakNode} representing a line break in the source output.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
+ */
+declare function createBreak(): BreakNode;
+/**
+ * Definition for the {@link JsxNode}.
+ */
+declare const jsxDef: NodeDef<JsxNode, string>;
+/**
+ * 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</>' }
+ * ```
+ */
+declare const createJsx: (input: string) => JsxNode;
+//#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';
+  /**
+   * AST type used when a schema's type cannot be inferred from the spec
+   * (`additionalProperties: true`, missing `type`, ...).
+   */
+  unknownType: 'any' | 'unknown' | 'void';
+  /**
+   * AST type used for completely empty schemas (`{}`).
+   */
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  /**
+   * Suffix appended to derived enum names when Kubb has to invent one
+   * (typically for inline enums on object properties).
+   */
+  enumSuffix: 'enum' | (string & {});
+};
+/**
+ * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
+ */
+type DateTimeNodeByDateType = {
+  date: DateSchemaNode;
+  string: DatetimeSchemaNode;
+  stringOffset: DatetimeSchemaNode;
+  stringLocal: DatetimeSchemaNode;
+  false: StringSchemaNode;
+};
+/**
+ * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
+ */
+type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
+/**
+ * Ordered list of `[schema-shape, SchemaNode]` pairs.
+ * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
+ */
+type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
+  $ref: string;
+}, RefSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+  properties: object;
+}, IntersectionSchemaNode], [{
+  allOf: readonly [unknown, unknown, ...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/nodes/property.d.ts
+/**
+ * AST node representing one named object property.
+ *
+ * @example
+ * ```ts
+ * const property: PropertyNode = {
+ *   kind: 'Property',
+ *   name: 'id',
+ *   schema: createSchema({ type: 'integer' }),
+ *   required: true,
+ * }
+ * ```
+ */
+type PropertyNode = BaseNode & {
+  kind: 'Property';
+  /**
+   * Property key.
+   */
+  name: string;
+  /**
+   * Property schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the property is required.
+   */
+  required: boolean;
+};
+/**
+ * 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
+ * ```ts
+ * const property = createProperty({
+ *   name: 'status',
+ *   required: true,
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=true, no optional/nullish
+ * ```
+ */
+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: 'Schema';
+  /**
+   * Schema name for named definitions (for example, `"Pet"`).
+   * Inline schemas omit this field.
+   * `null` means kubb has processed this and determined there is no applicable name.
+   * `undefined` means the name has not been set yet.
+   */
+  name?: string | null;
+  /**
+   * Short schema title.
+   */
+  title?: string;
+  /**
+   * Schema description text.
+   */
+  description?: string;
+  /**
+   * Whether `null` is allowed.
+   */
+  nullable?: boolean;
+  /**
+   * Whether the field is optional.
+   */
+  optional?: boolean;
+  /**
+   * Both optional and nullable (`optional` + `nullable`).
+   */
+  nullish?: boolean;
+  /**
+   * Whether the schema is deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Whether the schema is read-only.
+   */
+  readOnly?: boolean;
+  /**
+   * Whether the schema is write-only.
+   */
+  writeOnly?: boolean;
+  /**
+   * Default value.
+   */
+  default?: unknown;
+  /**
+   * Example value.
+   */
+  example?: unknown;
+  /**
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
+   */
+  primitive?: PrimitiveSchemaType;
+  /**
+   * 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>;
+  /**
+   * Minimum number of properties allowed.
+   */
+  minProperties?: number;
+  /**
+   * Maximum number of properties allowed.
+   */
+  maxProperties?: number;
+};
+/**
+ * Array-like schema (`array` or `tuple`).
+ *
+ * @example
+ * ```ts
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
+ * }
+ * ```
+ */
+type ArraySchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator (`array` or `tuple`).
+   */
+  type: 'array' | 'tuple';
+  /**
+   * Item schemas.
+   */
+  items?: Array<SchemaNode>;
+  /**
+   * Tuple rest-item schema for elements beyond positional `items`.
+   */
+  rest?: SchemaNode;
+  /**
+   * Minimum item count (or tuple length).
+   */
+  min?: number;
+  /**
+   * Maximum item count (or tuple length).
+   */
+  max?: number;
+  /**
+   * Whether all items must be unique.
+   */
+  unique?: boolean;
+};
+/**
+ * Shared shape for union and intersection schemas.
+ */
+type CompositeSchemaNodeBase = SchemaNodeBase & {
+  /**
+   * Member schemas.
+   */
+  members?: Array<SchemaNode>;
+};
+/**
+ * Union schema, often from `oneOf` or `anyOf`.
+ *
+ * @example
+ * ```ts
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
+ * }
+ * ```
+ */
+type UnionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'union';
+  /**
+   * Discriminator property name from OpenAPI `discriminator.propertyName`.
+   */
+  discriminatorPropertyName?: string;
+  /**
+   * How many union members must be valid.
+   * - `'one'`: exactly one member, from `oneOf`
+   * - `'any'`: any number of members, from `anyOf`
+   */
+  strategy?: 'one' | 'any';
+};
+/**
+ * Intersection schema, often from `allOf`.
+ *
+ * @example
+ * ```ts
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
+ * }
+ * ```
+ */
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'intersection';
+};
+/**
+ * One named enum item.
+ */
+type EnumValueNode = {
+  /**
+   * Enum item name.
+   */
+  name: string;
+  /**
+   * Enum item value.
+   */
+  value: string | number | boolean;
+  /**
+   * Primitive type of the enum value.
+   */
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
+};
+/**
+ * Enum schema node.
+ *
+ * @example
+ * ```ts
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
+ * }
+ * ```
+ */
+type EnumSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'enum';
+  /**
+   * Enum values in simple form.
+   */
+  enumValues?: Array<string | number | boolean | null>;
+  /**
+   * Enum values in named form.
+   * If present, this is used instead of `enumValues`.
+   */
+  namedEnumValues?: Array<EnumValueNode>;
+};
+/**
+ * Reference schema that points to another schema definition.
+ *
+ * @example
+ * ```ts
+ * const refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
+ * ```
+ */
+type RefSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ref';
+  /**
+   * Referenced schema name.
+   * `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.
+   */
+  type: 'datetime';
+  /**
+   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
+   */
+  offset?: boolean;
+  /**
+   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
+   */
+  local?: boolean;
+};
+/**
+ * Shared base for `date` and `time` schemas.
+ */
+type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: T;
+  /**
+   * Output representation in generated code.
+   */
+  representation: 'date' | 'string';
+};
+/**
+ * Date schema node.
+ *
+ * @example
+ * ```ts
+ * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
+ * ```
+ */
+type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
+/**
+ * Time schema node.
+ *
+ * @example
+ * ```ts
+ * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
+ * ```
+ */
+type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
+/**
+ * String schema node.
+ *
+ * @example
+ * ```ts
+ * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
+ * ```
+ */
+type StringSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'string';
+  /**
+   * Minimum string length.
+   */
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  max?: number;
+  /**
+   * Regex pattern.
+   */
+  pattern?: string;
+};
+/**
+ * Numeric schema (`number`, `integer`, or `bigint`).
+ *
+ * @example
+ * ```ts
+ * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
+ * ```
+ */
+type NumberSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'number' | 'integer' | 'bigint';
+  /**
+   * Minimum value.
+   */
+  min?: number;
+  /**
+   * Maximum value.
+   */
+  max?: number;
+  /**
+   * Exclusive minimum value.
+   */
+  exclusiveMinimum?: number;
+  /**
+   * Exclusive maximum value.
+   */
+  exclusiveMaximum?: number;
+  /**
+   * The value must be a multiple of this number.
+   */
+  multipleOf?: number;
+};
+/**
+ * Scalar schema with no extra constraints.
+ *
+ * @example
+ * ```ts
+ * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
+ * ```
+ */
+type ScalarSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: ScalarSchemaType;
+};
+/**
+ * URL schema node.
+ * Can include an OpenAPI-style path template for template literal types.
+ *
+ * @example
+ * ```ts
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
+ * ```
+ */
+type UrlSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'url';
+  /**
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
+   */
+  path?: string;
+  /**
+   * Minimum string length.
+   */
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  max?: number;
+};
+/**
+ * Format-string schema for string-based formats that support length constraints.
+ *
+ * @example
+ * ```ts
+ * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
+ * ```
+ */
+type FormatStringSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'uuid' | 'email';
+  /**
+   * Minimum string length.
+   */
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  max?: number;
+};
+/**
+ * IPv4 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
+ * ```
+ */
+type Ipv4SchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ipv4';
+};
+/**
+ * IPv6 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
+ * ```
+ */
+type Ipv6SchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ipv6';
+};
+/**
+ * Mapping from schema type literals to concrete schema node types.
+ * Used by `narrowSchema`.
+ */
+type SchemaNodeByType = {
+  object: ObjectSchemaNode;
+  array: ArraySchemaNode;
+  tuple: ArraySchemaNode;
+  union: UnionSchemaNode;
+  intersection: IntersectionSchemaNode;
+  enum: EnumSchemaNode;
+  ref: RefSchemaNode;
+  datetime: DatetimeSchemaNode;
+  date: DateSchemaNode;
+  time: TimeSchemaNode;
+  string: StringSchemaNode;
+  number: NumberSchemaNode;
+  integer: NumberSchemaNode;
+  bigint: NumberSchemaNode;
+  boolean: ScalarSchemaNode;
+  null: ScalarSchemaNode;
+  any: ScalarSchemaNode;
+  unknown: ScalarSchemaNode;
+  void: ScalarSchemaNode;
+  never: ScalarSchemaNode;
+  uuid: FormatStringSchemaNode;
+  email: FormatStringSchemaNode;
+  url: UrlSchemaNode;
+  ipv4: Ipv4SchemaNode;
+  ipv6: Ipv6SchemaNode;
+  blob: ScalarSchemaNode;
+};
+/**
+ * Union of all schema node types.
+ */
+type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | ScalarSchemaNode;
+type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & {
+  properties?: Array<PropertyNode>;
+  primitive?: 'object';
+};
+type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>;
+type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
+  kind: 'Schema';
+};
+/**
+ * Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+ * empty array, and `primitive` is inferred from `type` when not explicitly provided.
+ */
+declare const schemaDef: NodeDef<SchemaNode, CreateSchemaInput>;
+/**
+ * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
+ *
+ * @example
+ * ```ts
+ * const scalar = createSchema({ type: 'string' })
+ * // { kind: 'Schema', type: 'string', primitive: 'string' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const object = createSchema({ type: 'object' })
+ * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
+ * ```
+ */
+declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
+declare function createSchema(props: CreateSchemaInput): SchemaNode;
+//#endregion
+//#region src/nodes/content.d.ts
+/**
+ * AST node representing one content-type entry of a request body or response.
+ *
+ * There is one entry per content type declared in the spec (e.g. `application/json`,
+ * `multipart/form-data`), and each entry holds 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;
+};
+/**
+ * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
+ */
+type UserContent = Omit<ContentNode, 'kind'>;
+/**
+ * Definition for the {@link ContentNode}.
+ */
+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
+/**
+ * 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 Named imports
+   * `['useState']`
+   *
+   * @example Default import
+   * `'React'`
+   */
+  name: ImportName;
+  /**
+   * Path for the import.
+   *
+   * @example
+   * `'@kubb/core'`
+   */
+  path: string;
+  /**
+   * Add a type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Import the entire module as a namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates a standard import
+   */
+  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 Named exports
+   * `['useState']`
+   *
+   * @example Single export
+   * `'React'`
+   */
+  name?: string | Array<string> | null;
+  /**
+   * Path for the export.
+   *
+   * @example
+   * `'@kubb/core'`
+   */
+  path: string;
+  /**
+   * Add a type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   */
+  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.
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Include the `export` keyword in the generated source.
+   */
+  isExportable?: boolean | null;
+  /**
+   * Include this source in barrel/index file generation.
+   */
+  isIndexable?: boolean | null;
+  /**
+   * Child nodes that make up this source fragment, in DOM order.
+   * Use a {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * Represents a fully resolved file in the AST.
+ *
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id   = SHA256 hash of the path
+ * // file.name = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ */
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
+  /**
+   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
+   * computes it, so 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, read by plugins during barrel generation.
+   */
+  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.
+ *
+ * @example Named import
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * // import { useState } from 'react'
+ * ```
+ */
+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.
+ *
+ * @example Named export
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet' })
+ * // export { Pet } from './Pet'
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+ * ```
+ */
+declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
+/**
+ * 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.
+ *
+ * - 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
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
+ * ```
+ */
+type TypeLiteralNode = BaseNode & {
+  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;
+  }>;
+};
+/**
+ * AST node for a single field accessed from a named group type.
+ * TypeScript renders as `objectType['indexType']`.
+ *
+ * @example
+ * ```ts
+ * createIndexedAccessType({ objectType: 'GetPetPathParams', indexType: 'petId' })
+ * // GetPetPathParams['petId']
+ * ```
+ */
+type IndexedAccessTypeNode = BaseNode & {
+  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
+ * ```ts
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
+ * ```
+ */
+type ObjectBindingPatternNode = BaseNode & {
+  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;
+  }>;
+};
+/**
+ * AST node for one function parameter.
+ *
+ * A simple parameter has a `string` name. A destructured group has an
+ * {@link ObjectBindingPatternNode} name paired with a {@link TypeLiteralNode} type.
+ *
+ * @example Required parameter
+ * `name: Type`
+ *
+ * @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 } = {}`
+ */
+type FunctionParameterNode = BaseNode & {
+  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;
+};
+/**
+ * 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
+ */
+type FunctionParametersNode = BaseNode & {
+  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
+ * ```ts
+ * 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
+ * ```ts
+ * 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
+ * ```ts
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
+ * ```
+ */
+declare const createObjectBindingPattern: (input: Pick<ObjectBindingPatternNode, "elements">) => ObjectBindingPatternNode;
+/**
+ * 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 Optional param
+ * ```ts
+ * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+ * // → params?: QueryParams
+ * ```
+ *
+ * @example Destructured group
+ * ```ts
+ * 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
+ * ```ts
+ * const empty = createFunctionParameters()
+ * // { kind: 'FunctionParameters', params: [] }
+ * ```
+ */
+declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+//#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.
+ *
+ * @example
+ * ```ts
+ * const param: ParameterNode = {
+ *   kind: 'Parameter',
+ *   name: 'petId',
+ *   in: 'path',
+ *   schema: createSchema({ type: 'string' }),
+ *   required: true,
+ * }
+ * ```
+ */
+type ParameterNode = BaseNode & {
+  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'>>;
+/**
+ * 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
+ * const param = createParameter({
+ *   name: 'petId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: createSchema({ type: 'string' }),
+ * })
+ * ```
+ */
+declare const createParameter: (input: UserParameterNode) => ParameterNode;
+//#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}.
+ *
+ * @example
+ * ```ts
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
+ * ```
+ */
+type RequestBodyNode = BaseNode & {
+  kind: 'RequestBody';
+  /**
+   * Request body description carried over from the spec.
+   */
+  description?: string;
+  /**
+   * Whether the request body is required (`requestBody.required: true` in the spec).
+   * When `false` or absent, the generated `data` parameter should be optional.
+   */
+  required?: boolean;
+  /**
+   * 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 plugins can generate code for every variant (for example, separate hooks for
+   * `application/json` and `multipart/form-data`).
+   */
+  content?: Array<ContentNode>;
+};
+/**
+ * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ */
+type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
+  content?: Array<UserContent>;
+};
+/**
+ * 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.
+ *
+ * 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`.
+ *
+ * @example
+ * ```ts
+ * const response: ResponseNode = {
+ *   kind: 'Response',
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
+ * ```
+ */
+type ResponseNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Response';
+  /**
+   * HTTP status code or `'default'` for a fallback response.
+   */
+  statusCode: StatusCode;
+  /**
+   * Optional response description.
+   */
+  description?: string;
+  /**
+   * 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>;
+/**
+ * Creates a `ResponseNode`.
+ *
+ * @example
+ * ```ts
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ * })
+ * ```
+ */
+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;
+  /**
+   * Query, path, header, and cookie parameters for the operation.
+   */
+  parameters: Array<ParameterNode>;
+  /**
+   * Request body for the operation.
+   */
+  requestBody?: RequestBodyNode;
+  /**
+   * Operation responses.
+   */
+  responses: Array<ResponseNode>;
+};
+/**
+ * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
+ *
+ * @example
+ * ```ts
+ * const operation: HttpOperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   protocol: 'http',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
+ * ```
+ */
+type HttpOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: 'http';
+  /**
+   * HTTP method like `'GET'`.
+   */
+  method: HttpMethod;
+  /**
+   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
+   */
+  path: string;
+};
+/**
+ * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
+ */
+type GenericOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: Exclude<OperationProtocol, 'http'>;
+  method?: never;
+  path?: never;
+};
+/**
+ * AST node representing one API operation.
+ *
+ * Discriminated on `protocol`: an {@link HttpOperationNode} (`protocol: 'http'`) guarantees
+ * `method` and `path`, while a {@link GenericOperationNode} omits them. Narrow with
+ * `isHttpOperationNode(node)` or `node.protocol === 'http'` before reading `method`/`path`.
+ */
+type OperationNode = HttpOperationNode | GenericOperationNode;
+type OperationInput = {
+  operationId: string;
+  method?: HttpOperationNode['method'];
+  path?: HttpOperationNode['path'];
+  requestBody?: UserRequestBody;
+  [key: string]: unknown;
+};
+/**
+ * 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`.
+ */
+declare const operationDef: NodeDef<OperationNode, OperationInput>;
+/**
+ * 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 []
+ * ```
+ */
+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
+/**
+ * Metadata for an API document, populated by the adapter and available to every generator.
+ *
+ * All fields are plain JSON-serializable values, no `Set`, no `Map`, no class instances.
+ * Computed fields (`circularNames`, `enumNames`) are pre-calculated once during the adapter
+ * pre-scan so generators never need to iterate the full schema list themselves.
+ *
+ * @example
+ * ```ts
+ * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
+ * ```
+ */
+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, so a generator never has to
+   * call `findCircularSchemas` itself.
+   *
+   * Convert to a `Set` once at the start of a generator, not per-schema,
+   * so lookups stay O(1) without repeated allocations.
+   *
+   * @example Wrap a circular schema in z.lazy()
+   * ```ts
+   * const circular = new Set(meta.circularNames)
+   * if (circular.has(schema.name)) { ... }
+   * ```
+   */
+  circularNames: ReadonlyArray<string>;
+  /**
+   * Names of schemas whose type is `enum`.
+   * Computed once during the adapter pre-scan, so a generator never has to
+   * filter the schema list itself.
+   *
+   * Convert to a `Set` once at the start of a generator when you need repeated
+   * membership checks, so each check stays O(1) instead of an array scan.
+   *
+   * @example Check if a referenced schema is an enum
+   * `const enums = new Set(meta.enumNames)`
+   * `const isEnum = enums.has(schemaName)`
+   */
+  enumNames: ReadonlyArray<string>;
+};
+/**
+ * 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.
+ *
+ * @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
+ * }
+ * ```
+ */
+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;
+});
+/**
+ * Definition for the {@link InputNode}.
+ */
+declare const inputDef: NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>>;
+/**
+ * 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 Eager
+ * ```ts
+ * const input = createInput()
+ * // { kind: 'Input', schemas: [], operations: [] }
+ * ```
+ *
+ * @example Streaming
+ * ```ts
+ * const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
+ * ```
+ */
+declare function createInput<Stream extends boolean = false>(options?: Partial<Omit<InputNode<Stream>, 'kind'>> & {
+  stream?: Stream;
+}): InputNode<Stream>;
+//#endregion
+//#region src/nodes/output.d.ts
+/**
+ * Output AST node that groups all generated file output for one API document.
+ *
+ * Produced by generators and consumed by the build pipeline to write files.
+ *
+ * @example
+ * ```ts
+ * const output: OutputNode = {
+ *   kind: 'Output',
+ *   files: [],
+ * }
+ * ```
+ */
+type OutputNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Output';
+  /**
+   * Generated file nodes.
+   */
+  files: Array<FileNode>;
+};
+/**
+ * Definition for the {@link OutputNode}.
+ */
+declare const outputDef: NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>>;
+/**
+ * Creates an `OutputNode` with a stable default for `files`.
+ *
+ * @example
+ * ```ts
+ * const output = createOutput()
+ * // { kind: 'Output', files: [] }
+ * ```
+ */
+declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): OutputNode;
+//#endregion
+//#region src/nodes/index.d.ts
+/**
+ * Union of all AST node types.
+ *
+ * This lets TypeScript narrow types in `switch (node.kind)` blocks.
+ *
+ * @example
+ * ```ts
+ * function getKind(node: Node): string {
+ *   switch (node.kind) {
+ *     case 'Input':
+ *       return 'input'
+ *     case 'Output':
+ *       return 'output'
+ *     default:
+ *       return 'other'
+ *   }
+ * }
+ * ```
+ */
+type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
+//#endregion
+export { fileDef as $, textDef as $t, FunctionParametersNode as A, InferSchemaNode as At, functionParameterDef as B, TypeNode as Bt, ParameterLocation as C, UrlSchemaNode as Ct, FunctionParamKind as D, UserPropertyNode as Dt, parameterDef as E, PropertyNode as Et, createFunctionParameter as F, ConstNode as Ft, ExportNode as G, createBreak as Gt, indexedAccessTypeDef as H, breakDef as Ht, createFunctionParameters as I, FunctionNode as It, SourceNode as J, createJsx as Jt, FileNode as K, createConst as Kt, createIndexedAccessType as L, JSDocNode as Lt, ObjectBindingPatternNode as M, ArrowFunctionNode as Mt, TypeExpression as N, BreakNode as Nt, FunctionParamNode as O, createProperty as Ot, TypeLiteralNode as P, CodeNode as Pt, exportDef as Q, jsxDef as Qt, createObjectBindingPattern as R, JsxNode as Rt, requestBodyDef as S, UnionSchemaNode as St, createParameter as T, schemaDef as Tt, objectBindingPatternDef as U, constDef as Ut, functionParametersDef as V, arrowFunctionDef as Vt, typeLiteralDef as W, createArrowFunction as Wt, createImport as X, createType as Xt, createExport as Y, createText as Yt, createSource as Z, functionDef as Zt, responseDef as _, SchemaNode as _t, InputMeta as a, BaseNode as an, createContent as at, UserRequestBody as b, StringSchemaNode as bt, inputDef as c, DatetimeSchemaNode as ct, HttpOperationNode as d, NumberSchemaNode as dt, typeDef as en, importDef as et, OperationNode as f, ObjectSchemaNode as ft, createResponse as g, ScalarSchemaType as gt, ResponseNode as h, ScalarSchemaNode as ht, outputDef as i, syncOptionality as in, contentDef as it, IndexedAccessTypeNode as j, ParserOptions as jt, FunctionParameterNode as k, propertyDef as kt, GenericOperationNode as l, EnumSchemaNode as lt, operationDef as m, RefSchemaNode as mt, OutputNode as n, NodeDef as nn, ContentNode as nt, InputNode as o, NodeKind as on, ArraySchemaNode as ot, createOperation as p, PrimitiveSchemaType as pt, ImportNode as q, createFunction as qt, createOutput as r, defineNode as rn, UserContent as rt, createInput as s, DateSchemaNode as st, Node as t, DistributiveOmit as tn, sourceDef as tt, HttpMethod as u, IntersectionSchemaNode as ut, StatusCode as v, SchemaNodeByType as vt, ParameterNode as w, createSchema as wt, createRequestBody as x, TimeSchemaNode as xt, RequestBodyNode as y, SchemaType as yt, createTypeLiteral as z, TextNode as zt };
+//# sourceMappingURL=index-BzjwdK2M.d.ts.map