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

package/dist/index.d.ts

@@ -1663,12 +1663,16 @@ type MediaType = 'application/json' | 'application/xml' | 'application/x-www-for
 /**
  * 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' }) }],
  * }
  * ```
  */
@@ -1686,18 +1690,35 @@ 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;
+  }>;
 };
 //#endregion
 //#region src/nodes/operation.d.ts
@@ -2314,16 +2335,23 @@ declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'sch
 /**
  * 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: [] }) }],
  * })
  * ```
  */
-declare function createResponse(props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>): ResponseNode;
+declare function createResponse(props: Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode'>> & {
+  schema?: SchemaNode;
+  mediaType?: string | null;
+  keysToOmit?: Array<string> | null;
+}): ResponseNode;
 /**
  * Creates a `FunctionParameterNode`.
  *

package/dist/index.js

@@ -582,7 +582,9 @@ function* getChildren(node, recurse) {
 		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;
 	}
 }
@@ -718,10 +720,13 @@ function transform(node, options) {
 		const response = visitor.response?.(node, { parent }) ?? 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
+			}))
 		};
 	}
 	return node;
@@ -1641,19 +1646,28 @@ function createParameter(props) {
 /**
 * 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: [] }) }],
 * })
 * ```
 */
 function createResponse(props) {
+	const { schema, mediaType, keysToOmit, content, ...rest } = props;
 	return {
-		...props,
-		kind: "Response"
+		...rest,
+		kind: "Response",
+		content: content ?? (schema ? [{
+			contentType: mediaType ?? "application/json",
+			schema,
+			keysToOmit: keysToOmit ?? null
+		}] : void 0)
 	};
 }
 /**