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

package/dist/{index-BzjwdK2M.d.ts → index-B9cc8MBS.d.ts}

@@ -25,12 +25,16 @@ type BaseNode = {
   kind: NodeKind;
 };
 //#endregion
-//#region src/node.d.ts
+//#region src/defineNode.d.ts
 /**
- * Visitor callback names, one per traversable node kind. Kept in sync with the
- * keys of `Visitor` in `visitor.ts`.
+ * Visitor callback names, one per traversable node kind, in traversal order.
+ * Kept in sync with the keys of `Visitor` in `visitor.ts`.
  */
-type VisitorKey = 'input' | 'output' | 'operation' | 'schema' | 'property' | 'parameter' | 'response';
+declare const visitorKeys: readonly ["input", "output", "operation", "schema", "property", "parameter", "response"];
+/**
+ * One of the {@link visitorKeys} callback names.
+ */
+type VisitorKey = (typeof visitorKeys)[number];
 /**
  * Distributive `Omit` that preserves each member of a union.
  *
@@ -43,16 +47,6 @@ type VisitorKey = 'input' | 'output' | 'operation' | 'schema' | 'property' | 'pa
  * ```
  */
 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
@@ -79,11 +73,6 @@ type NodeDef<TNode extends BaseNode = BaseNode, TInput = never> = {
    * 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'];
@@ -91,31 +80,25 @@ type DefineNodeConfig<TNode extends BaseNode, TInput, TBuilt extends object> = {
   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
+ * @example Node with a build hook
  * ```ts
  * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
  *   kind: 'Property',
  *   build: (props) => ({ ...props, required: props.required ?? false }),
  *   children: ['schema'],
  *   visitorKey: 'property',
- *   rebuild: true,
  * })
  * ```
  */
@@ -234,7 +217,10 @@ type FunctionNode = BaseNode & {
    */
   default?: boolean | null;
   /**
-   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
+   *
+   * @example
+   * `'id: string, config: Config = {}'`
    */
   params?: string | null;
   /**
@@ -281,55 +267,12 @@ type FunctionNode = BaseNode & {
  * // export const getPet = () => ...
  * ```
  */
-type ArrowFunctionNode = BaseNode & {
+type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
   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.
@@ -351,16 +294,16 @@ type TextNode = BaseNode & {
   value: string;
 };
 /**
- * AST node representing a line break in the source output.
+ * AST node representing a blank line 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.
+ * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
+ * statements into one blank line. Consecutive breaks, and breaks at the start or end of
+ * the list, are folded away, so a `Break` never produces more than one blank line.
  *
  * @example
  * ```ts
  * createBreak()
  * // { kind: 'Break' }
- * // prints as '' → blank line when surrounded by other nodes
  * ```
  */
 type BreakNode = BaseNode & {
@@ -396,6 +339,30 @@ type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNo
  * Definition for the {@link ConstNode}.
  */
 declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
+/**
+ * Definition for the {@link TypeNode}.
+ */
+declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
+/**
+ * Definition for the {@link FunctionNode}.
+ */
+declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
+/**
+ * Definition for the {@link ArrowFunctionNode}.
+ */
+declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
+/**
+ * Definition for the {@link TextNode}.
+ */
+declare const textDef: NodeDef<TextNode, string>;
+/**
+ * Definition for the {@link BreakNode}.
+ */
+declare const breakDef: NodeDef<BreakNode, void>;
+/**
+ * Definition for the {@link JsxNode}.
+ */
+declare const jsxDef: NodeDef<JsxNode, string>;
 /**
  * Creates a `ConstNode` representing a TypeScript `const` declaration.
  *
@@ -406,10 +373,6 @@ declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
  * ```
  */
 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.
  *
@@ -420,10 +383,6 @@ declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
  * ```
  */
 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.
  *
@@ -434,10 +393,6 @@ declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
  * ```
  */
 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.
  *
@@ -448,10 +403,6 @@ declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNod
  * ```
  */
 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.
  *
@@ -462,10 +413,6 @@ declare const textDef: NodeDef<TextNode, string>;
  * ```
  */
 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.
  *
@@ -476,10 +423,6 @@ declare const breakDef: NodeDef<BreakNode, void>;
  * ```
  */
 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.
  *
@@ -493,7 +436,7 @@ declare const createJsx: (input: string) => JsxNode;
 //#endregion
 //#region src/infer.d.ts
 /**
- * Shared parser options used by OAS-to-AST inference and parser flows.
+ * Options that control how the adapter parser maps OpenAPI schemas to AST nodes.
  */
 type ParserOptions = {
   /**
@@ -673,8 +616,8 @@ type PropertyNode = BaseNode & {
  */
 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.
+ * Definition for the {@link PropertyNode}. `required` defaults to `false`, and the schema's
+ * `optional`/`nullish` flags are derived from it through {@link optionality}.
  */
 declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
 /**
@@ -773,7 +716,7 @@ type SchemaNodeBase = BaseNode & {
   /**
    * 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.
+   * `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;
@@ -855,7 +798,7 @@ type ObjectSchemaNode = SchemaNodeBase & {
   /**
    * Additional object properties behavior:
    * - `true`: allow any value
-   * - `false`: reject unknown properties (maps to `.strict()` in Zod)
+   * - `false`: reject unknown properties
    * - `SchemaNode`: allow values that match that schema
    * - `undefined`: no additional properties constraint (open object)
    */
@@ -1355,18 +1298,14 @@ type ContentNode = BaseNode & {
    */
   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>;
+declare const contentDef: NodeDef<ContentNode, Omit<ContentNode, "kind">>;
 /**
  * Creates a `ContentNode` for a single request-body or response content type.
  */
-declare const createContent: (input: UserContent) => ContentNode;
+declare const createContent: (input: Omit<ContentNode, "kind">) => ContentNode;
 //#endregion
 //#region src/nodes/file.d.ts
 /**
@@ -1557,13 +1496,14 @@ type FileNode<TMeta extends object = object> = BaseNode & {
   id: string;
   /**
    * File name without extension, derived from `baseName`.
-   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   *
+   * @see 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
+   * File base name, including extension, shaped like `${name}${extname}`.
+   *
+   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
    */
   baseName: `${string}.${string}`;
   /**
@@ -1605,6 +1545,19 @@ type FileNode<TMeta extends object = object> = BaseNode & {
  * Definition for the {@link ImportNode}.
  */
 declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
+/**
+ * Definition for the {@link ExportNode}.
+ */
+declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
+/**
+ * Definition for the {@link SourceNode}.
+ */
+declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
+/**
+ * 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">>;
 /**
  * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
  *
@@ -1615,10 +1568,6 @@ declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
  * ```
  */
 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.
  *
@@ -1629,10 +1578,6 @@ declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
  * ```
  */
 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.
  *
@@ -1643,10 +1588,40 @@ declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
  */
 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.
+ * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
+ * and `imports`/`exports`/`sources` are deduplicated.
  */
-declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>;
+type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
+/**
+ * Creates a fully resolved `FileNode` from a file input descriptor.
+ *
+ * Computes:
+ * - `id` SHA256 hash of the file path
+ * - `name` `baseName` without extension
+ * - `extname` extension extracted from `baseName`
+ *
+ * Deduplicates:
+ * - `sources` via `combineSources`
+ * - `exports` via `combineExports`
+ * - `imports` via `combineImports` (also filters unused imports)
+ *
+ * @throws {Error} when `baseName` has no extension.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id      = SHA256 hash of 'src/models/petStore.ts'
+ * // file.name    = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ */
+declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
 //#endregion
 //#region src/nodes/function.d.ts
 /**
@@ -1689,11 +1664,11 @@ type TypeLiteralNode = BaseNode & {
 };
 /**
  * AST node for a single field accessed from a named group type.
- * TypeScript renders as `objectType['indexType']`.
+ * TypeScript renders as `target['key']`.
  *
  * @example
  * ```ts
- * createIndexedAccessType({ objectType: 'GetPetPathParams', indexType: 'petId' })
+ * createIndexedAccessType({ target: 'GetPetPathParams', key: 'petId' })
  * // GetPetPathParams['petId']
  * ```
  */
@@ -1702,11 +1677,11 @@ type IndexedAccessTypeNode = BaseNode & {
   /**
    * Name of the type being indexed, e.g. `'GetPetPathParams'`.
    */
-  objectType: string;
+  target: string;
   /**
    * Field key to access, e.g. `'petId'`.
    */
-  indexType: string;
+  key: string;
 };
 /**
  * AST node for an object destructuring binding, used as the name of a grouped function parameter.
@@ -1807,44 +1782,14 @@ 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}.
  */
@@ -1870,6 +1815,40 @@ type FunctionParameterInput = {
  * paired with a {@link TypeLiteralNode} type.
  */
 declare const functionParameterDef: NodeDef<FunctionParameterNode, FunctionParameterInput>;
+/**
+ * Definition for the {@link FunctionParametersNode}.
+ */
+declare const functionParametersDef: NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>>;
+/**
+ * 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;
+/**
+ * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+ *
+ * @example
+ * ```ts
+ * createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })
+ * // DeletePetPathParams['petId']
+ * ```
+ */
+declare const createIndexedAccessType: (input: Omit<IndexedAccessTypeNode, "kind">) => IndexedAccessTypeNode;
+/**
+ * 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;
 /**
  * Creates a `FunctionParameterNode`. `optional` defaults to `false`.
  *
@@ -1886,10 +1865,6 @@ declare const functionParameterDef: NodeDef<FunctionParameterNode, FunctionParam
  * ```
  */
 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.
  *
@@ -1954,8 +1929,8 @@ type ParameterNode = BaseNode & {
 };
 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.
+ * Definition for the {@link ParameterNode}. `required` defaults to `false`, and the schema's
+ * `optional`/`nullish` flags are derived from it through {@link optionality}.
  */
 declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
 /**
@@ -2011,21 +1986,16 @@ type RequestBodyNode = BaseNode & {
   content?: Array<ContentNode>;
 };
 /**
- * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ * Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+ * {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
  */
-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>;
+declare const requestBodyDef: NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">>;
 /**
- * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ * Creates a `RequestBodyNode`.
  */
-declare const createRequestBody: (input: UserRequestBody) => RequestBodyNode;
+declare const createRequestBody: (input: Omit<RequestBodyNode, "kind">) => RequestBodyNode;
 //#endregion
-//#region src/nodes/http.d.ts
+//#region src/nodes/response.d.ts
 /**
  * All supported HTTP status code literals as strings, as used in API specs
  * (for example, `"200"` and `"404"`).
@@ -2043,8 +2013,6 @@ type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '2
  * ```
  */
 type StatusCode = HttpStatusCode | 'default';
-//#endregion
-//#region src/nodes/response.d.ts
 /**
  * AST node representing one operation response variant.
  *
@@ -2057,7 +2025,7 @@ type StatusCode = HttpStatusCode | 'default';
  * const response: ResponseNode = {
  *   kind: 'Response',
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
@@ -2092,7 +2060,7 @@ type ResponseNode = BaseNode & {
   content?: Array<ContentNode>;
 };
 type ResponseInput = Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
-  content?: Array<UserContent>;
+  content?: Array<ContentNode>;
   schema?: SchemaNode;
   mediaType?: string | null;
   keysToOmit?: Array<string> | null;
@@ -2109,13 +2077,16 @@ declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
  * ```ts
  * const response = createResponse({
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ *   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
  * })
  * ```
  */
 declare const createResponse: (input: ResponseInput) => ResponseNode;
 //#endregion
 //#region src/nodes/operation.d.ts
+/**
+ * HTTP method an operation responds to.
+ */
 type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
 /**
  * Transport an operation belongs to.
@@ -2217,7 +2188,7 @@ type OperationInput = {
   operationId: string;
   method?: HttpOperationNode['method'];
   path?: HttpOperationNode['path'];
-  requestBody?: UserRequestBody;
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
   [key: string]: unknown;
 };
 /**
@@ -2236,10 +2207,10 @@ declare const operationDef: NodeDef<OperationNode, OperationInput>;
  * ```
  */
 declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
-  requestBody?: UserRequestBody;
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
 }): HttpOperationNode;
 declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
-  requestBody?: UserRequestBody;
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
 }): GenericOperationNode;
 //#endregion
 //#region src/nodes/input.d.ts
@@ -2306,8 +2277,7 @@ type InputMeta = {
  * 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.
+ * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time.
  *
  * @example
  * ```ts
@@ -2339,19 +2309,19 @@ type InputNode<Stream extends boolean = false> = BaseNode & {
    * All operation nodes in the document.
    */
   operations: Streamable<OperationNode, Stream>;
-} & (Stream extends true ? {
-  meta?: InputMeta;
-} : {
+  /**
+   * Document metadata populated by the adapter.
+   */
   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`.
+ * `operations` are `AsyncIterable` sources. Otherwise it builds the eager variant with array
+ * `schemas`/`operations`. Both variants get the defaulted `meta`.
  *
  * @example Eager
  * ```ts
@@ -2429,5 +2399,5 @@ declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): Ou
  */
 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
+export { exportDef as $, textDef as $t, IndexedAccessTypeNode as A, InferSchemaNode as At, functionParametersDef as B, TypeNode as Bt, ParameterNode as C, UrlSchemaNode as Ct, FunctionParamNode as D, UserPropertyNode as Dt, FunctionParamKind as E, PropertyNode as Et, createFunctionParameters as F, ConstNode as Ft, FileNode as G, createBreak as Gt, objectBindingPatternDef as H, breakDef as Ht, createIndexedAccessType as I, FunctionNode as It, UserFileNode as J, createJsx as Jt, ImportNode as K, createConst as Kt, createObjectBindingPattern as L, JSDocNode as Lt, TypeExpression as M, ArrowFunctionNode as Mt, TypeLiteralNode as N, BreakNode as Nt, FunctionParameterNode as O, createProperty as Ot, createFunctionParameter as P, CodeNode as Pt, createSource as Q, jsxDef as Qt, createTypeLiteral as R, JsxNode as Rt, ParameterLocation as S, UnionSchemaNode as St, parameterDef as T, schemaDef as Tt, typeLiteralDef as U, constDef as Ut, indexedAccessTypeDef as V, arrowFunctionDef as Vt, ExportNode as W, createArrowFunction as Wt, createFile as X, createType as Xt, createExport as Y, createText as Yt, createImport as Z, functionDef as Zt, createResponse as _, SchemaNode as _t, InputMeta as a, NodeKind as an, createContent as at, createRequestBody as b, StringSchemaNode as bt, inputDef as c, DatetimeSchemaNode as ct, HttpOperationNode as d, NumberSchemaNode as dt, typeDef as en, fileDef as et, OperationNode as f, ObjectSchemaNode as ft, StatusCode as g, ScalarSchemaType as gt, ResponseNode as h, ScalarSchemaNode as ht, outputDef as i, BaseNode as in, contentDef as it, ObjectBindingPatternNode as j, ParserOptions as jt, FunctionParametersNode as k, propertyDef as kt, GenericOperationNode as l, EnumSchemaNode as lt, operationDef as m, RefSchemaNode as mt, OutputNode as n, NodeDef as nn, sourceDef as nt, InputNode as o, ArraySchemaNode as ot, createOperation as p, PrimitiveSchemaType as pt, SourceNode as q, createFunction as qt, createOutput as r, defineNode as rn, ContentNode as rt, createInput as s, DateSchemaNode as st, Node as t, DistributiveOmit as tn, importDef as tt, HttpMethod as u, IntersectionSchemaNode as ut, responseDef as v, SchemaNodeByType as vt, createParameter as w, createSchema as wt, requestBodyDef as x, TimeSchemaNode as xt, RequestBodyNode as y, SchemaType as yt, functionParameterDef as z, TextNode as zt };
+//# sourceMappingURL=index-B9cc8MBS.d.ts.map