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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-beta.28",
+  "version": "5.0.0-beta.29",
   "description": "Spec-agnostic AST layer for Kubb. Defines the node tree, visitor pattern, factory functions, and type guards used across all code generation plugins.",
   "keywords": [
     "ast",

package/src/factory.ts

@@ -322,21 +322,32 @@ export function createParameter(
 /**
  * Creates a `ResponseNode`.
  *
+ * Response body schemas live inside `content`. For convenience a single legacy `schema`
+ * (with optional `mediaType`/`keysToOmit`) is normalized into one `content` entry, so the same
+ * schema is never stored both at the node root and inside `content`.
+ *
  * @example
  * ```ts
  * const response = createResponse({
  *   statusCode: '200',
- *   description: 'Success',
- *   schema: createSchema({ type: 'object', properties: [] }),
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
  * })
  * ```
  */
 export function createResponse(
-  props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>,
+  props: Pick<ResponseNode, 'statusCode'> &
+    Partial<Omit<ResponseNode, 'kind' | 'statusCode'>> & {
+      schema?: SchemaNode
+      mediaType?: string | null
+      keysToOmit?: Array<string> | null
+    },
 ): ResponseNode {
+  const { schema, mediaType, keysToOmit, content, ...rest } = props
+
   return {
-    ...props,
+    ...rest,
     kind: 'Response',
+    content: content ?? (schema ? [{ contentType: mediaType ?? 'application/json', schema, keysToOmit: keysToOmit ?? null }] : undefined),
   }
 }
 

package/src/nodes/response.ts

@@ -1,16 +1,20 @@
 import type { BaseNode } from './base.ts'
-import type { MediaType, StatusCode } from './http.ts'
+import type { StatusCode } from './http.ts'
 import type { SchemaNode } from './schema.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',
- *   schema: createSchema({ type: 'string' }),
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
@@ -28,16 +32,33 @@ export type ResponseNode = BaseNode & {
    */
   description?: string
   /**
-   * Response body schema.
-   */
-  schema: SchemaNode
-  /**
-   * Response media type.
-   */
-  mediaType?: MediaType | null
-  /**
-   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
-   * Set when a referenced schema has `writeOnly` fields that should not appear in response types.
+   * All available content type entries for this response.
+   *
+   * When the adapter `contentType` option is set, this array contains exactly one entry for that
+   * content type. Otherwise it contains one entry per content type declared in the spec, so that
+   * plugins can generate a union of response types (e.g. `application/json` and `application/xml`).
+   * Body-less responses keep a single entry whose `schema` is the empty/`void` placeholder.
+   *
+   * @example
+   * ```ts
+   * // spec response declares both application/json and application/xml
+   * response.content[0].contentType // 'application/json'
+   * response.content[1].contentType // 'application/xml'
+   * ```
    */
-  keysToOmit?: Array<string> | null
+  content?: Array<{
+    /**
+     * The content type for this entry (e.g. `'application/json'`).
+     */
+    contentType: string
+    /**
+     * Response body schema for this content type.
+     */
+    schema?: SchemaNode
+    /**
+     * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+     * Set when a referenced schema has `writeOnly` fields that should not appear in response types.
+     */
+    keysToOmit?: Array<string> | null
+  }>
 }

package/src/visitor.ts

@@ -319,7 +319,11 @@ function* getChildren(node: Node, recurse: boolean): Generator<Node, void, undef
     return
   }
   if (node.kind === 'Response') {
-    if (node.schema) yield node.schema
+    if (node.content) {
+      for (const c of node.content) {
+        if (c.schema) yield c.schema
+      }
+    }
     return
   }
 }
@@ -498,7 +502,10 @@ export function transform(node: Node, options: TransformOptions): Node {
 
     return {
       ...response,
-      schema: transform(response.schema, { ...options, parent: response }),
+      content: response.content?.map((entry) => ({
+        ...entry,
+        schema: entry.schema ? transform(entry.schema, { ...options, parent: response }) : entry.schema,
+      })),
     }
   }