@kubb/plugin-ts 5.5.0-canary.20261111T122006 → 5.5.1

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { Diagnostics, Resolver, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, isStringType, pascalCase, setMacros, setResolver, syncSchemaRef } from "@kubb/kit";
+import { Diagnostics, Resolver, addGenerator, ast, casing, createPrinter, createResolver, defineExtension, defineGenerator, setMacros, setResolver, text } from "@kubb/kit";
 import { File, jsxRenderer } from "@kubb/renderer-jsx";
 import { generate } from "yuku-codegen";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
@@ -9,49 +9,15 @@ var __name = (target, value) => __defProp(target, "name", {
 	value,
 	configurable: true
 });
-var __exportAll = (all, no_symbols) => {
-	let target = {};
+var __exportAll = (all, flags) => {
+	let target = Object.setPrototypeOf({}, null);
 	for (var name in all) __defProp(target, name, {
 		get: all[name],
 		enumerable: true
 	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
+	if (!(flags & 1)) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return flags & 2 ? target : Object.preventExtensions(target);
 };
-// ../../internals/utils/src/casing.ts
-const wordStart = /(?<=[a-z\d])(?=[A-Z])|(?<=[A-Z]{2})(?=[A-Z][a-z]{2})/;
-/**
-* Splits `text` into words on separators (whitespace, hyphens, underscores, dots, slashes, colons)
-* and on {@link wordStart}. A segment without lowercase letters, such as `COOL` or `2D`, is one word,
-* so snake case leaves a name that is already in it unchanged.
-*/
-function words(text) {
-	return text.split(/[\s\-_./\\:]+/).filter(Boolean).flatMap((segment) => segment === segment.toUpperCase() ? segment : segment.split(wordStart));
-}
-/**
-* Converts `text` to snake_case.
-*
-* @example From camelCase
-* `snakeCase('helloWorld') // 'hello_world'`
-*
-* @example From mixed separators
-* `snakeCase('Hello-World') // 'hello_world'`
-*/
-function snakeCase(text, { prefix = "", suffix = "" } = {}) {
-	return words(`${prefix} ${text} ${suffix}`).map((word) => word.replace(/[^a-zA-Z0-9]/g, "").toLowerCase()).filter(Boolean).join("_");
-}
-/**
-* Converts `text` to SCREAMING_SNAKE_CASE.
-*
-* @example From camelCase
-* `screamingSnakeCase('helloWorld') // 'HELLO_WORLD'`
-*/
-function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
-	return snakeCase(text, {
-		prefix,
-		suffix
-	}).toUpperCase();
-}
 // ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -191,53 +157,6 @@ function ensureValidVarName(name) {
 function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-// ../../internals/utils/src/strings.ts
-/**
-* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
-* Returns the string unchanged when no balanced quote pair is found.
-*
-* @example
-* ```ts
-* trimQuotes('"hello"') // 'hello'
-* trimQuotes('hello')   // 'hello'
-* ```
-*/
-function trimQuotes(text) {
-	if (text.length >= 2) {
-		const first = text[0];
-		const last = text[text.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
-	}
-	return text;
-}
-/**
-* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
-*
-* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
-* code matches the repo style without a formatter.
-*
-* @example
-* ```ts
-* stringify('hello')   // "'hello'"
-* stringify('"hello"') // "'hello'"
-* ```
-*/
-function stringify(value) {
-	if (value === void 0 || value === null) return "''";
-	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
-}
-/**
-* Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.
-* Editors render `\@` as `@` in hovers.
-*
-* @example
-* ```ts
-* jsDocEscape('intro\n@example value') // 'intro\n\\@example value'
-* ```
-*/
-function jsDocEscape(input) {
-	return `${input}`.replace(/^(\s*)@/gm, "$1\\@");
-}
 // ../../internals/utils/src/fs.ts
 /**
 * Builds a nested file path from a dotted name. Splits on dots that precede a letter
@@ -258,9 +177,22 @@ function jsDocEscape(input) {
 * @example Suffix applied to the final segment only
 * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-function toFilePath(name, caseLast = camelCase) {
+function toFilePath(name, caseLast = casing.camel) {
 	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : casing.camel(part)).filter(Boolean).join("/");
+}
+// ../../internals/utils/src/strings.ts
+/**
+* Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.
+* Editors render `\@` as `@` in hovers.
+*
+* @example
+* ```ts
+* jsDocEscape('intro\n@example value') // 'intro\n\\@example value'
+* ```
+*/
+function jsDocEscape(input) {
+	return `${input}`.replace(/^(\s*)@/gm, "$1\\@");
 }
 // src/factory.ts
 var factory_exports = /* @__PURE__ */ __exportAll({
@@ -346,12 +278,6 @@ function propertyName(name) {
 	return isValidIdentifier(name) ? identifier(name) : literal(name);
 }
 /**
-* Indents every non-empty line of `text` by two spaces.
-*/
-function indent(text) {
-	return text.split("\n").map((line) => line ? `  ${line}` : line).join("\n");
-}
-/**
 * Creates a TypeScript intersection type.
 * Returns the single type if only one is provided. `yuku-codegen` adds the parentheses a union member needs.
 */
@@ -512,12 +438,12 @@ function valueToExpression(value, asNumber = isNumber(value)) {
 /**
 * Apply casing transformation to enum keys
 */
-function applyEnumKeyCasing(key, casing = "none") {
-	if (casing === "none") return key;
-	if (casing === "screamingSnakeCase") return screamingSnakeCase(key);
-	if (casing === "snakeCase") return snakeCase(key);
-	if (casing === "pascalCase") return pascalCase(key);
-	if (casing === "camelCase") return camelCase(key);
+function applyEnumKeyCasing(key, keyCasing = "none") {
+	if (keyCasing === "none") return key;
+	if (keyCasing === "screamingSnakeCase") return casing.screamingSnake(key);
+	if (keyCasing === "snakeCase") return casing.snake(key);
+	if (keyCasing === "pascalCase") return casing.pascal(key);
+	if (keyCasing === "camelCase") return casing.camel(key);
 	return key;
 }
 /**
@@ -596,7 +522,7 @@ function createEnumDeclaration({ type = "enum", name, typeName, enums, enumKeyCa
 		exprName: identifier(identifierName),
 		typeArguments: null
 	};
-	return [`export const ${identifierName} = {\n${properties.map(indent).join(",\n")},\n} as const;`, typeAlias({
+	return [`export const ${identifierName} = {\n${properties.map((property) => text.indent({ text: property })).join(",\n")},\n} as const;`, typeAlias({
 		type: "TSIndexedAccessType",
 		objectType: {
 			type: "TSParenthesizedType",
@@ -720,7 +646,7 @@ function wrapNullableOptional(type, nullable, addsUndefined) {
 */
 function buildPropertyType(schema, baseType, optionalType, optional) {
 	const addsUndefined = optionalType === "undefined" || optionalType === "questionTokenAndUndefined";
-	const meta = syncSchemaRef(schema);
+	const meta = ast.ref.mergeSchema(schema);
 	return wrapNullableOptional(baseType, !!meta.nullable, addsUndefined && !!(optional || meta.nullish || meta.optional));
 }
 /**
@@ -774,7 +700,7 @@ function buildIndexSignatures(node, propertyCount, printNode) {
 function getEnumNames$1({ node, enum: enumOptions, resolver }) {
 	const resolved = resolver.name(node.name);
 	return {
-		enumName: enumOptions.constCasing === "pascalCase" ? resolved : ensureValidVarName(camelCase(node.name)),
+		enumName: enumOptions.constCasing === "pascalCase" ? resolved : ensureValidVarName(casing.camel(node.name)),
 		typeName: enumOptions.type === "asConst" ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolved
 	};
 }
@@ -800,10 +726,10 @@ function Enum({ node, enum: enumOptions, resolver }) {
 		name: enumName,
 		typeName,
 		enums: node.namedEnumValues?.map((v) => [
-			trimQuotes(v.name.toString()),
+			text.unquote(v.name.toString()),
 			v.value,
 			v.description
-		]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes(v.toString()), v]) ?? [],
+		]) ?? node.enumValues?.filter((v) => v !== null && v !== void 0).map((v) => [text.unquote(v.toString()), v]) ?? [],
 		type: enumOptions.type,
 		enumKeyCasing: enumOptions.keyCasing
 	});
@@ -828,169 +754,567 @@ function Enum({ node, enum: enumOptions, resolver }) {
 		children: typeNode
 	})] });
 }
-// ../../internals/shared/src/operation.ts
+// src/utils.ts
 /**
-* Builds the `ResolverFileParams` every operation generator passes to
-* `resolver.file`: a file named `name`, tagged by the operation's first
-* tag (or `'default'`), at the operation's path. Centralizes the entry object
-* that was repeated at dozens of call sites across the client and query plugins.
-*
-* @example
-* ```ts
-* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
-* ```
+* Renames inline enum declarations and their uses together.
 */
-function operationFileEntry(node, name, extname = ".ts") {
-	return {
-		name,
-		extname,
-		tag: node.tags[0] ?? "default",
-		path: node.path
-	};
+function resolveInlineEnumNames({ node, owner, resolver, enumOptions }) {
+	return ast.node.transform(node, { schema(child) {
+		if (child === node || child.type !== "enum" || !child.name) return;
+		const name = resolver.resolveName({
+			key: [
+				"enum",
+				owner,
+				child.pointer ?? child.name
+			],
+			name: child.name,
+			normalize: (value) => {
+				const { enumName, typeName } = getEnumNames$1({
+					node: {
+						...child,
+						name: value
+					},
+					enum: enumOptions,
+					resolver
+				});
+				return enumOptions.type === "literal" ? [typeName] : [enumName, typeName];
+			}
+		});
+		return name === child.name ? void 0 : {
+			...child,
+			name
+		};
+	} });
+}
+function enumTypeName({ resolver, name, enumOptions, isEnum }) {
+	return isEnum && enumOptions?.type === "asConst" && enumOptions.typeSuffix ? resolver.enum.keyName({ name }, enumOptions.typeSuffix) : resolver.name(name);
 }
 /**
-* Resolves the file a schema-emitting plugin (`plugin-ts`, `plugin-zod`, `plugin-faker`) writes
-* `node` to, cached in `ctx.memo` under the resolver's plugin name and the
-* operation. The plugin itself and every plugin that imports from it call this, so they all get
-* the same path.
-*
-* When that path matches the file of a component schema in `ctx.driver.inputNode`, ignoring case, the file name
-* gets an `Operation` suffix: operation `point` goes to `PointOperation.ts` next to schema `Point.ts`.
-* Otherwise the two merge into one file, or overwrite each other on a case-insensitive file system.
-* Only the file name changes. The declarations keep their names.
+* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
+* rather than a named enum reference or a runtime enum declaration.
 *
-* @example Resolve `plugin-ts`'s file for the current operation
-* ```ts
-* const fileTs = resolveOperationFile({ ctx, node, resolver: tsResolver, root, output })
-* ```
+* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
+* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
+* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
+* a named enum, which keeps the declaration and its references in sync across adapter versions.
 */
-function resolveOperationFile(options) {
-	const { ctx, node, resolver, root, output } = options;
-	const { memo } = ctx;
-	const location = {
-		root,
-		output,
-		group: options.group ?? void 0
-	};
-	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => {
-		const schemaPaths = memo(`${resolver.pluginName}:schemaFilePaths`, () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.name ? [resolver.file({
-			name: schema.name,
-			extname: ".ts",
-			...location
-		}).path.toLowerCase()] : [])));
-		let file = resolver.file({
-			...operationFileEntry(node, node.operationId),
-			...location
-		});
-		for (let name = `${node.operationId}Operation`; schemaPaths.has(file.path.toLowerCase()); name += "Operation") {
-			const next = resolver.file({
-				...operationFileEntry(node, name),
-				...location
-			});
-			if (next.path === file.path) break;
-			file = next;
-		}
-		return file;
-	});
+function isInlineConstEnum(node, enumSchemaNames) {
+	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
+}
+function isSchemaOptional(schema) {
+	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
 }
-function baseContentType(contentType) {
-	return contentType.split(";")[0].trim().toLowerCase();
+function formatExample(value) {
+	if (value === null || typeof value !== "object") return String(value);
+	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
 }
 /**
-* Whether a content entry is a sequence of JSON values the adapter marks as a stream, such as `application/jsonl`,
-* `application/x-ndjson`, `application/json-seq`, or any media type with an OpenAPI 3.2 `itemSchema`.
+* Whether a schema is binary, or an array of binary items, so its TypeScript type is `Blob` or `Blob[]`.
 */
-function isJsonLines(entry) {
-	const baseType = baseContentType(entry.contentType);
-	return Boolean(entry.stream) && baseType !== "text/event-stream" && !baseType.startsWith("multipart/");
-}
-function isJsonContentType(baseType) {
-	return baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json";
+function isBinarySchema(schema) {
+	const meta = ast.ref.mergeSchema(schema);
+	const isBlob = (node) => ast.ref.mergeSchema(node)?.type === "blob";
+	return !!meta && (isBlob(meta) || meta.type === "array" && "items" in meta && (meta.items ?? []).some(isBlob));
 }
 /**
-* Parser for one response content entry.
+* Collects JSDoc annotation strings for a schema node.
 *
-* JSON stays unset so the runtime detects it. `text/event-stream` and JSON Lines are streams. A binary schema
-* (`format: binary` / `contentMediaType`) is a blob even when the media type is not a well-known
-* binary type. Other `text/*` is text, and `application/octet-stream`, `application/pdf`,
-* `image/*`, `audio/*`, and `video/*` are blobs.
+* Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@minimum`, `@maximum`, `@minLength`,
+* `@maxLength`, `@pattern`, `@default`, `@example`, `@see` and `@type`.
 */
-function responseTypeForContent(entry) {
-	const baseType = baseContentType(entry.contentType);
-	if (!baseType) return void 0;
-	if (baseType === "text/event-stream" || isJsonLines(entry)) return "stream";
-	if (isJsonContentType(baseType)) return void 0;
-	if (entry.schema?.type === "blob") return "blob";
-	if (baseType.startsWith("text/")) return "text";
-	if (isBinaryContentType(baseType)) return "blob";
-}
-function isBinaryContentType(baseType) {
-	return baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType);
+function buildPropertyJSDocComments(schema, optional) {
+	const meta = ast.ref.mergeSchema(schema);
+	const isArray = meta?.primitive === "array";
+	const isObject = meta?.type === "object";
+	const isNumeric = meta?.primitive === "number" || meta?.primitive === "integer" || meta?.primitive === "bigint";
+	const hasDescription = meta && "description" in meta && meta.description;
+	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
+	const exampleValues = meta?.examples ?? [];
+	const comments = [
+		hasDescription ? `@description ${jsDocEscape(meta.description)}` : null,
+		...formatComment,
+		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
+		!isArray && !isObject && meta && "min" in meta && meta.min !== void 0 ? `@${isNumeric ? "minimum" : "minLength"} ${meta.min}` : null,
+		!isArray && !isObject && meta && "max" in meta && meta.max !== void 0 ? `@${isNumeric ? "maximum" : "maxLength"} ${meta.max}` : null,
+		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
+		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? text.quote(meta.default) : formatExample(meta.default)}` : null,
+		...exampleValues.map((example) => `@example ${formatExample(example)}`),
+		meta?.externalDocs ? `@see ${jsDocEscape([meta.externalDocs.url, meta.externalDocs.description].filter(Boolean).join(" "))}` : null
+	].filter(Boolean);
+	const typeTag = comments.length && !isBinarySchema(schema) && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
+	return [...comments, typeTag].filter(Boolean);
 }
 /**
-* Maps a content type to the PascalCase suffix used to name per-content-type variants
-* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
+* The example values. With `serialized`, each `serializedValue` is added as a `<caption>Serialized</caption>` example.
 */
-function getContentTypeSuffix(contentType) {
-	const baseType = contentType.split(";")[0].trim();
-	if (baseType === "application/json") return "Json";
-	if (baseType === "multipart/form-data") return "FormData";
-	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
-	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
-	if (parts.length === 0) return "Unknown";
-	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+function getExampleValues(examples, serialized = false) {
+	const values = (examples ?? []).flatMap((example) => [...example.value !== void 0 ? [example.value] : [], ...serialized && example.serializedValue !== void 0 ? [`<caption>Serialized</caption> ${jsDocEscape(example.serializedValue)}`] : []]);
+	return values.length > 0 ? values : void 0;
 }
 /**
-* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
-* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+* The JSDoc lines of a response type: `@summary`, and one `@see` per link, such as `@see getPet: getPet({ petId: $response.body#/id })`.
 */
-function getPerContentTypeName(baseName, suffix) {
-	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
-	return baseName + suffix;
+function buildResponseComments(response) {
+	const links = Object.entries(response.links ?? {}).map(([name, link]) => {
+		const values = {
+			...link.parameters,
+			...link.requestBody !== void 0 ? { body: link.requestBody } : {}
+		};
+		const args = Object.entries(values).map(([key, value]) => `${key}: ${formatExample(value)}`);
+		return `@see ${jsDocEscape(`${name}: ${link.operationId ?? link.operationRef ?? ""}(${args.length ? `{ ${args.join(", ")} }` : ""})`)}`;
+	});
+	return [...response.summary ? [`@summary ${jsDocEscape(response.summary)}`] : [], ...links];
 }
 /**
-* Returns the entry with the schema of the value the client returns: `string` for a body read as text, such as `Pet` on
-* `application/xml`, and `blob` for `image/*`, `audio/*`, `video/*`, PDF, and octet-stream. A binary schema elsewhere is a `Blob`
-* only through `parseAs: 'blob'`, which needs every entry in `entries` binary. JSON, vendor (`application/vnd.*`), stream,
-* schemaless, and wildcard entries keep their schema. `entries` is the response's full list of content types.
+* Builds the object schema for one parameter group or a response's headers. Each entry embeds its own schema and JSDoc,
+* so the group is the only type these entries are exported as.
 */
-function toResponseContent(entry, entries = [entry]) {
-	const { contentType, schema } = entry;
-	if (!schema || entry.stream) return entry;
-	const baseType = baseContentType(contentType);
-	const resolved = ast.resolveRef(schema);
-	if (isBinaryContentType(baseType)) return resolved.type === "blob" ? entry : {
-		...entry,
-		schema: ast.factory.createSchema({ type: "blob" }),
-		keysToOmit: null
-	};
-	const isPlainMediaType = Boolean(baseType) && !isJsonContentType(baseType) && !baseType.includes("*");
-	if (resolved.type === "blob") return isPlainMediaType && !entries.every((item) => item.schema?.type === "blob") ? {
-		...entry,
-		schema: ast.factory.createSchema({ type: "string" }),
-		keysToOmit: null
-	} : entry;
-	if (resolved.primitive === "string") return entry;
-	const responseType = responseTypeForContent(entry);
-	if (responseType !== "text" && (resolved.type === "unknown" || resolved.type === "any" || resolved.type === "void")) return entry;
-	const isVendorJson = /^[^/]+\/vnd\./.test(baseType) && !/(xml|yaml|yml|csv)$/.test(baseType);
-	return responseType === "text" || !responseType && isPlainMediaType && !isVendorJson ? {
-		...entry,
-		schema: ast.factory.createSchema({ type: "string" }),
-		keysToOmit: null
-	} : entry;
+function buildParams({ params, serializedExamples }) {
+	const pointer = params[0]?.pointer;
+	return ast.factory.createSchema({
+		type: "object",
+		pointer: pointer?.slice(0, pointer.lastIndexOf("/")),
+		properties: params.map((param) => ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: ast.factory.createSchema({
+				...param.schema,
+				optional: !param.required,
+				deprecated: param.deprecated || param.schema.deprecated,
+				examples: getExampleValues(param.examples, serializedExamples) ?? param.schema.examples
+			})
+		}))
+	});
 }
-/**
-* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
-* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
-* the final (possibly counter-augmented) value, so callers can derive parallel names in another
-* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
-*/
-function resolveContentTypeVariants(entries, baseName) {
-	const usedNames = /* @__PURE__ */ new Set();
-	return entries.filter((entry) => entry.schema).map((entry) => {
-		const baseSuffix = getContentTypeSuffix(entry.contentType);
-		let suffix = baseSuffix;
+function buildResponseUnion(node, { resolver }) {
+	const allWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
+	const successWithSchema = allWithSchema.filter((res) => ast.http.status.isSuccess(res));
+	const responsesWithSchema = successWithSchema.length > 0 ? successWithSchema : allWithSchema;
+	if (responsesWithSchema.length === 0) return null;
+	return ast.factory.createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => ast.factory.createSchema({
+			type: "ref",
+			name: resolver.response.status(node, res.statusCode)
+		}))
+	});
+}
+// src/printers/printerTs.ts
+const { isNonNullable } = factory_exports;
+const requireModule = createRequire(import.meta.url);
+/**
+* Loads `@kubb/parser-ts` on first use. It is an optional peer dependency: only a deprecated `printer.nodes`
+* handler that returns a TypeScript compiler node needs it. Loads synchronously because node handlers are synchronous.
+*/
+function loadParserTs(load = () => requireModule("@kubb/parser-ts")) {
+	try {
+		return load();
+	} catch (error) {
+		if (error.code !== "MODULE_NOT_FOUND" || !error.message.split("\n")[0].includes("@kubb/parser-ts")) throw error;
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.missingDependency,
+			severity: "error",
+			message: "Missing dependency: @kubb/parser-ts. A `printer.nodes` handler returned a TypeScript compiler node, and printing it needs @kubb/parser-ts.",
+			help: "Run `npm i -D @kubb/parser-ts` in the project, or return a string from the handler.",
+			plugin: "plugin-ts"
+		});
+	}
+}
+function printNullable(node, print) {
+	const type = print(node);
+	return type && node.nullable ? createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] }) : type;
+}
+/**
+* Adapts user overrides, which work in strings, to the node-based printer: `this.transform` hands them printed
+* strings and their result is wrapped back into a node. A deprecated compiler node prints through `@kubb/parser-ts`.
+*/
+function toNodeHandlers(nodes) {
+	return Object.fromEntries(Object.entries(nodes ?? {}).map(([type, handler]) => [type, function(node) {
+		const transform = (child) => {
+			const output = this.transform(child);
+			return output ? print(output) : null;
+		};
+		const result = handler.call({
+			...this,
+			transform
+		}, node);
+		if (result === null || result === void 0) return result;
+		return createRaw(typeof result === "string" ? result : loadParserTs().parserTs().print(result).trimEnd());
+	}]));
+}
+/**
+* TypeScript type printer built with `definePrinter`.
+*
+* Converts a `SchemaNode` AST node into TypeScript source:
+* - **`printer.print(node)`** — when `options.name` is set, returns a full
+*   `type Name = …` or `interface Name { … }` declaration.
+*   Without `name`, returns the type for the schema, such as `string | null`.
+*
+* Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
+* over per printer instance, so each call to `printerTs(options)` produces an independent printer.
+*
+* @example Raw type node (no `typeName`)
+* ```ts
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })
+* const type = printer.print(schemaNode) // 'string | null'
+* ```
+*
+* @example Full declaration (with `typeName`)
+* ```ts
+* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })
+* const declaration = printer.print(schemaNode) // 'export type MyType = …'
+* ```
+*/
+const printerTs = createPrinter((options) => {
+	const addsUndefined = options.optionalType === "undefined" || options.optionalType === "questionTokenAndUndefined";
+	return {
+		name: "typescript",
+		options,
+		nodes: {
+			any: () => keywordTypeNodes.any,
+			unknown: () => keywordTypeNodes.unknown,
+			void: () => keywordTypeNodes.void,
+			never: () => keywordTypeNodes.never,
+			boolean: () => keywordTypeNodes.boolean,
+			null: () => keywordTypeNodes.null,
+			blob: () => createTypeReferenceNode("Blob"),
+			string: () => keywordTypeNodes.string,
+			uuid: () => keywordTypeNodes.string,
+			email: () => keywordTypeNodes.string,
+			url: (node) => {
+				if (node.path) return createUrlTemplateType(node.path);
+				return keywordTypeNodes.string;
+			},
+			ipv4: () => keywordTypeNodes.string,
+			ipv6: () => keywordTypeNodes.string,
+			datetime: () => keywordTypeNodes.string,
+			number: () => keywordTypeNodes.number,
+			integer: () => keywordTypeNodes.number,
+			bigint: () => keywordTypeNodes.bigint,
+			date: dateOrStringNode,
+			time: dateOrStringNode,
+			ref(node) {
+				if (!node.name) return null;
+				const refName = ast.ref.getName(node);
+				if (!refName) return null;
+				return createTypeReferenceNode(node.ref ? enumTypeName({
+					resolver: this.options.resolver,
+					name: refName,
+					enumOptions: this.options.enum,
+					isEnum: !!this.options.enumSchemaNames?.has(refName)
+				}) : refName);
+			},
+			enum(node) {
+				const values = ast.schema.getLiterals(node);
+				if (values.some((value) => value !== null && typeof value === "object")) return createUnionDeclaration({ nodes: values.map((value) => constToTypeNode(value)) });
+				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({ nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable) });
+				return createTypeReferenceNode(enumTypeName({
+					resolver: this.options.resolver,
+					name: node.name,
+					enumOptions: this.options.enum,
+					isEnum: true
+				}));
+			},
+			union(node) {
+				const members = node.members ?? [];
+				const hasStringLiteral = members.some((m) => {
+					return ast.schema.narrow(m, ast.schema.types.enum)?.primitive === "string";
+				});
+				const hasPlainString = members.some((m) => ast.schema.isString(m));
+				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({ nodes: members.map((m) => {
+					const print = (node) => ast.schema.isString(node) ? createIntersectionDeclaration({ nodes: [keywordTypeNodes.string, createTypeLiteralNode([])] }) : this.transform(node);
+					return printNullable(m, print);
+				}).filter(isNonNullable) });
+				return createUnionDeclaration({ nodes: buildMemberNodes(members, (member) => printNullable(member, this.transform)) });
+			},
+			intersection(node) {
+				return createIntersectionDeclaration({ nodes: buildMemberNodes(node.members, this.transform) });
+			},
+			array(node) {
+				return createArrayDeclaration({
+					nodes: (node.items ?? []).map((item) => printNullable(item, this.transform)).filter(isNonNullable),
+					arrayType: this.options.arrayType
+				});
+			},
+			tuple(node) {
+				return buildTupleNode(node, (item) => printNullable(item, this.transform));
+			},
+			object(node) {
+				const { transform, options } = this;
+				const keySchema = node.propertyNames && ast.ref.mergeSchema(node.propertyNames);
+				if (!node.properties.length && !Object.keys(node.patternProperties ?? {}).length && node.propertyNames && keySchema?.type === "enum" && node.additionalProperties !== false) {
+					const keyType = transform(node.propertyNames) ?? keywordTypeNodes.string;
+					const valueSchema = typeof node.additionalProperties === "object" ? node.additionalProperties : ast.factory.createSchema({ type: "unknown" });
+					return createTypeReferenceNode("Partial", [createTypeReferenceNode("Record", [keyType, buildPropertyType(valueSchema, transform(valueSchema) ?? keywordTypeNodes.unknown, options.optionalType, false)])]);
+				}
+				const addsQuestionToken = options.optionalType === "questionToken" || options.optionalType === "questionTokenAndUndefined";
+				const propertyNodes = node.properties.map((property) => {
+					const { name } = property;
+					const baseType = transform(property.schema) ?? keywordTypeNodes.unknown;
+					const optional = !property.required || !!property.schema.optional || !!property.schema.nullish;
+					const type = buildPropertyType(property.schema, baseType, options.optionalType, optional);
+					const propMeta = ast.ref.mergeSchema(property.schema);
+					const propertyNode = createPropertySignature({
+						questionToken: optional ? addsQuestionToken : false,
+						name,
+						type,
+						readOnly: propMeta?.readOnly
+					});
+					const binaryRemark = isBinarySchema(property.schema) ? "@remarks Pass a `File` to send its filename. A plain `Blob` is sent with the filename `blob`." : void 0;
+					return appendJSDocToNode({
+						node: propertyNode,
+						comments: [...buildPropertyJSDocComments(property.schema, optional), binaryRemark]
+					});
+				});
+				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)];
+				if (!allElements.length) return keywordTypeNodes.object;
+				return createTypeLiteralNode(allElements);
+			},
+			...toNodeHandlers(options.nodes)
+		},
+		print(node) {
+			const { name, syntaxType = "type", description, examples, comments = [], keysToOmit } = this.options;
+			const transformed = this.transform(node);
+			if (!transformed) return null;
+			const meta = ast.ref.mergeSchema(node);
+			if (!name) return print(wrapNullableOptional(keysToOmit?.length ? createOmitDeclaration({
+				keys: keysToOmit,
+				type: transformed,
+				nonNullable: true
+			}) : transformed, !!meta.nullable, !!(meta.nullish || meta.optional) && addsUndefined));
+			return createTypeDeclaration({
+				name,
+				isExportable: true,
+				type: (() => {
+					return wrapNullableOptional(keysToOmit?.length ? createOmitDeclaration({
+						keys: keysToOmit,
+						type: transformed,
+						nonNullable: true
+					}) : transformed, !!meta.nullable, !!(meta.nullish || meta.optional));
+				})(),
+				syntax: syntaxType === "type" || !!keysToOmit?.length ? "type" : "interface",
+				comments: [...comments, ...buildPropertyJSDocComments({
+					...meta,
+					description,
+					examples: examples?.length ? examples : meta.examples
+				})]
+			});
+		}
+	};
+});
+// src/components/Type.tsx
+function Type({ name, node, printer, enum: enumOptions, resolver, inline }) {
+	if (inline) {
+		const withoutEnums = ast.node.transform(node, { schema: (n) => n.type === ast.schema.types.enum && n.name ? {
+			...n,
+			name: void 0
+		} : void 0 });
+		const expression = printerTs({
+			...printer.options,
+			name: void 0
+		}).print(withoutEnums)?.replace(/\/\*\*[\s\S]*?\*\/\s*/g, "");
+		if (!expression) return;
+		return /* @__PURE__ */ jsx(File.Source, {
+			name,
+			isTypeOnly: true,
+			isExportable: true,
+			isIndexable: true,
+			inline: { expression },
+			children: expression
+		});
+	}
+	const enumSchemaNodes = ast.node.collect(node, { schema(n) {
+		const enumNode = ast.schema.narrow(n, ast.schema.types.enum);
+		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
+	} });
+	const output = printer.print(node);
+	const printerImports = printer.drainImports();
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames$1({
+				node,
+				enum: enumOptions,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
+		node,
+		enum: enumOptions,
+		resolver
+	}, node.name)), shouldExportType && /* @__PURE__ */ jsxs(Fragment, { children: [printerImports.map((imp) => /* @__PURE__ */ jsx(File.Import, { ...imp }, [
+		name,
+		imp.path,
+		imp.name
+	].join("-"))), /* @__PURE__ */ jsx(File.Source, {
+		name,
+		pointer: node.pointer,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] })] });
+}
+// ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+/**
+* Resolves the file a schema-emitting plugin (`plugin-ts`, `plugin-zod`, `plugin-faker`) writes
+* `node` to, cached in `ctx.memo` under the resolver's plugin name and the
+* operation. The plugin itself and every plugin that imports from it call this, so they all get
+* the same path.
+*
+* When that path matches the file of a component schema in `ctx.driver.inputNode`, ignoring case, the file name
+* gets an `Operation` suffix: operation `point` goes to `PointOperation.ts` next to schema `Point.ts`.
+* Otherwise the two merge into one file, or overwrite each other on a case-insensitive file system.
+* Only the file name changes. The declarations keep their names.
+*
+* @example Resolve `plugin-ts`'s file for the current operation
+* ```ts
+* const fileTs = resolveOperationFile({ ctx, node, resolver: tsResolver, root, output })
+* ```
+*/
+function resolveOperationFile(options) {
+	const { ctx, node, resolver, root, output } = options;
+	const { memo } = ctx;
+	const location = {
+		root,
+		output,
+		group: options.group ?? void 0
+	};
+	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => {
+		const schemaPaths = memo(`${resolver.pluginName}:schemaFilePaths`, () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.name ? [resolver.file({
+			name: schema.name,
+			extname: ".ts",
+			...location
+		}).path.toLowerCase()] : [])));
+		let file = resolver.file({
+			...operationFileEntry(node, node.operationId),
+			...location
+		});
+		for (let name = `${node.operationId}Operation`; schemaPaths.has(file.path.toLowerCase()); name += "Operation") {
+			const next = resolver.file({
+				...operationFileEntry(node, name),
+				...location
+			});
+			if (next.path === file.path) break;
+			file = next;
+		}
+		return file;
+	});
+}
+/**
+* How a content entry is framed as a stream: `'events'` for Server-Sent Events, `'lines'` for JSON Lines.
+*/
+function getStreamFraming(entry) {
+	if (ast.mediaType.getBase(entry) === "text/event-stream") return "events";
+	return entry.stream && ast.mediaType.isStream(entry) ? "lines" : void 0;
+}
+/**
+* Parser for one response content entry.
+*
+* JSON stays unset so the runtime detects it. `text/event-stream` and JSON Lines are streams. A binary schema
+* (`format: binary` / `contentMediaType`) is a blob even when the media type is not a well-known
+* binary type. Other `text/*` is text, and `application/octet-stream`, `application/pdf`,
+* `image/*`, `audio/*`, and `video/*` are blobs.
+*/
+function responseTypeForContent(entry) {
+	const baseType = ast.mediaType.getBase(entry);
+	if (!baseType) return void 0;
+	if (getStreamFraming(entry)) return "stream";
+	if (ast.mediaType.isJson(baseType)) return void 0;
+	if (entry.schema?.type === "blob") return "blob";
+	if (baseType.startsWith("text/")) return "text";
+	if (isBinaryContentType(baseType)) return "blob";
+}
+function isBinaryContentType(baseType) {
+	return baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType);
+}
+/**
+* Maps a content type to the PascalCase suffix used to name per-content-type variants
+* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
+*/
+function getContentTypeSuffix(contentType) {
+	const baseType = contentType.split(";")[0].trim();
+	if (baseType === "application/json") return "Json";
+	if (baseType === "multipart/form-data") return "FormData";
+	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
+	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return "Unknown";
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+*/
+function getPerContentTypeName(baseName, suffix) {
+	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
+	return baseName + suffix;
+}
+/**
+* Returns the entry with the schema of the value the client returns: `string` for a body read as text, such as `Pet` on
+* `application/xml`, and `blob` for `image/*`, `audio/*`, `video/*`, PDF, and octet-stream. A binary schema elsewhere is a `Blob`
+* only through `parseAs: 'blob'`, which needs every entry in `entries` binary. JSON, vendor (`application/vnd.*`), stream,
+* schemaless, and wildcard entries keep their schema. `entries` is the response's full list of content types.
+*/
+function toResponseContent(entry, entries = [entry]) {
+	const { contentType, schema } = entry;
+	if (!schema || entry.stream) return entry;
+	const baseType = ast.mediaType.getBase(contentType);
+	const resolved = ast.ref.getSchema(schema);
+	if (isBinaryContentType(baseType)) return resolved.type === "blob" ? entry : {
+		...entry,
+		schema: ast.factory.createSchema({ type: "blob" }),
+		keysToOmit: null
+	};
+	const isPlainMediaType = Boolean(baseType) && !ast.mediaType.isJson(baseType) && !baseType.includes("*");
+	if (resolved.type === "blob") return isPlainMediaType && !entries.every((item) => item.schema?.type === "blob") ? {
+		...entry,
+		schema: ast.factory.createSchema({ type: "string" }),
+		keysToOmit: null
+	} : entry;
+	if (resolved.primitive === "string") return entry;
+	const responseType = responseTypeForContent(entry);
+	if (responseType !== "text" && (resolved.type === "unknown" || resolved.type === "any" || resolved.type === "void")) return entry;
+	const isVendorJson = /^[^/]+\/vnd\./.test(baseType) && !/(xml|yaml|yml|csv)$/.test(baseType);
+	return responseType === "text" || !responseType && isPlainMediaType && !isVendorJson ? {
+		...entry,
+		schema: ast.factory.createSchema({ type: "string" }),
+		keysToOmit: null
+	} : entry;
+}
+/**
+* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
+* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
+* the final (possibly counter-augmented) value, so callers can derive parallel names in another
+* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
+*/
+function resolveContentTypeVariants(entries, baseName) {
+	const usedNames = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => entry.schema).map((entry) => {
+		const baseSuffix = getContentTypeSuffix(entry.contentType);
+		let suffix = baseSuffix;
 		let name = getPerContentTypeName(baseName, suffix);
 		let counter = 2;
 		while (usedNames.has(name)) {
@@ -1007,50 +1331,6 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
-const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
-/**
-* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
-* per property, typed and serialized like any other.
-* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
-*/
-function spreadQuerystring(param) {
-	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
-	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
-	if (schema?.type !== "object" || !formEncoded) return [param];
-	return schema.properties.map((property) => ast.factory.createParameter({
-		name: property.name,
-		in: "query",
-		schema: property.schema,
-		required: param.required && property.required
-	}));
-}
-/**
-* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
-* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
-* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
-* same parameters once per plugin.
-*/
-function getOperationParameters(node) {
-	const cached = operationParameterGroupsByNode.get(node);
-	if (cached) return cached;
-	const dedupe = (params) => {
-		const seen = /* @__PURE__ */ new Set();
-		return params.filter((param) => {
-			if (seen.has(param.name)) return false;
-			seen.add(param.name);
-			return true;
-		});
-	};
-	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
-	const groups = {
-		path: group("path"),
-		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
-		header: group("header"),
-		cookie: group("cookie")
-	};
-	operationParameterGroupsByNode.set(node, groups);
-	return groups;
-}
 /**
 * Whether the operation declares more than one request media type with a schema, so a caller must pick one on `contentType`.
 */
@@ -1066,8 +1346,8 @@ function hasRequestContentTypeChoice(node) {
 * than a record.
 */
 function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
-	const { path, query, header, cookie } = getOperationParameters(node);
-	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const { path, query, header, cookie } = ast.http.groupParameters(node);
+	const hasBody = Boolean(ast.http.requestBody.getSchema(node));
 	const createNever = () => ast.factory.createSchema({
 		type: "never",
 		primitive: void 0,
@@ -1158,9 +1438,10 @@ function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
 * The schema a status occupies in the `<Name>Responses` record. A status that documents several
 * content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type
 * on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the
-* query hooks and `result.data` use.
+* query hooks and `result.data` use. With `streamData`, the stream variant of a 2xx status holds that schema, since the
+* client returns its body unread.
 */
-function buildResponseRecordEntry(node, res, resolver) {
+function buildResponseRecordEntry(node, res, resolver, streamData) {
 	const statusName = resolver.response.status(node, res.statusCode);
 	const variants = (res.content ?? []).filter((entry) => entry.schema);
 	if (variants.length <= 1) return ast.factory.createSchema({
@@ -1177,12 +1458,12 @@ function buildResponseRecordEntry(node, res, resolver) {
 				required: true,
 				schema: ast.factory.createSchema({
 					type: "enum",
-					enumValues: [baseContentType(variant.contentType)]
+					enumValues: [ast.mediaType.getBase(variant)]
 				})
 			}), ast.factory.createProperty({
 				name: "data",
 				required: true,
-				schema: ast.factory.createSchema({
+				schema: streamData && ast.http.status.isSuccess(res) && ast.mediaType.isStream(variant) ? streamData : ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				})
@@ -1198,26 +1479,20 @@ function buildResponseRecordEntry(node, res, resolver) {
 * Always emits the keyed record, even when an operation declares no responses. An operation with no
 * responses renders as an empty object, which keeps every consumer's import (for example the axios
 * SDK's `RequestResult<XResponses>`) resolvable instead of pointing at a missing export.
+*
+* `streamData` is the type of a stream variant's `data`, such as a `ReadableStream<Uint8Array>` reference.
 */
-function buildResponses(node, resolver) {
+function buildResponses(node, resolver, { streamData } = {}) {
 	return ast.factory.createSchema({
 		type: "object",
 		primitive: "object",
 		properties: node.responses.map((res) => ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
-			schema: buildResponseRecordEntry(node, res, resolver)
+			schema: buildResponseRecordEntry(node, res, resolver, streamData)
 		}))
 	});
 }
-function getStatusCodeNumber(statusCode) {
-	const code = Number(statusCode);
-	return Number.isNaN(code) ? null : code;
-}
-function isSuccessStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 200 && code < 300;
-}
 // ../../internals/shared/src/resolver.ts
 /**
 * Builds the allocation key for a declaration an operation owns. `scope` names which declaration
@@ -1271,516 +1546,90 @@ function createOperationParamResolver() {
 				name
 			});
 		},
-		headers(node) {
-			const name = this.name(`${node.operationId} Headers`);
-			return this.resolveName({
-				key: operationKey(node, "param", "headers"),
-				name
-			});
-		},
-		cookies(node) {
-			const name = this.name(`${node.operationId} Cookies`);
-			return this.resolveName({
-				key: operationKey(node, "param", "cookies"),
-				name
-			});
-		}
-	};
-}
-/**
-* Builds the shared `response` namespace. Spread the result into
-* `createResolver` and add plugin-specific methods (`options`, `error`) next
-* to it.
-*
-* @example
-* ```ts
-* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
-* ```
-*/
-function createOperationResponseResolver() {
-	return {
-		status(node, statusCode) {
-			const name = this.name(`${node.operationId} Status ${statusCode}`);
-			return this.resolveName({
-				key: operationKey(node, "response", "status", statusCode),
-				name
-			});
-		},
-		body(node) {
-			const name = this.name(`${node.operationId} Body`);
-			return this.resolveName({
-				key: operationKey(node, "response", "body"),
-				name
-			});
-		},
-		responses(node) {
-			const name = this.name(`${node.operationId} Responses`);
-			return this.resolveName({
-				key: operationKey(node, "response", "responses"),
-				name
-			});
-		},
-		response(node) {
-			const name = this.name(`${node.operationId} Response`);
-			return this.resolveName({
-				key: operationKey(node, "response", "response"),
-				name
-			});
-		}
-	};
-}
-/**
-* Builds a resolver `file` override whose base name runs every path segment
-* through `toFilePath`, casing the final segment with `caseLast`.
-*
-* @example
-* ```ts
-* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
-* ```
-*/
-function createCasedFile(caseLast) {
-	return { baseName({ name, extname }) {
-		return this.memo(`file:${name}\0${extname}`, () => `${toFilePath(name, caseLast)}${extname}`);
-	} };
-}
-/**
-* Names of the schemas whose type is `enum`, computed once per build.
-*/
-function getEnumNames(ctx) {
-	return ctx.memo("enumNames:set", () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.type === "enum" && schema.name ? [schema.name] : [])));
-}
-// ../../internals/shared/src/group.ts
-/**
-* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
-* shared default naming so every plugin groups output consistently:
-*
-* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use the camelCased group (`pet store` → `petStore`).
-*
-* A user-provided `group.name` always wins over the default namer, so callers stay in
-* control of their output folders. Returns `null` when grouping is disabled, matching the
-* per-plugin convention.
-*
-* @param group - The user-supplied group option, or `undefined` to disable grouping.
-*
-* @example
-* ```ts
-* createGroupConfig(group) // shared across every plugin
-* ```
-*/
-function createGroupConfig(group) {
-	if (!group) return null;
-	const defaultName = (ctx) => {
-		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return camelCase(ctx.group);
-	};
-	return {
-		...group,
-		name: group.name ? group.name : defaultName
-	};
-}
-// ../../internals/shared/src/schemaTraversal.ts
-/**
-* Maps each property of an object schema to its transformed output. Pairs every result with the
-* original property so the printer keeps full control over modifiers, getters, and key syntax.
-*
-* @example
-* ```ts
-* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
-* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
-* ```
-*/
-function mapSchemaProperties(node, transform) {
-	return node.properties.map((property) => ({
-		name: property.name,
-		property,
-		output: transform(property.schema)
-	}));
-}
-/**
-* Maps each item of an array or tuple schema to its transformed output, pairing every result with
-* the original item.
-*/
-function mapSchemaItems(node, transform) {
-	return (node.items ?? []).map((schema) => ({
-		schema,
-		output: transform(schema)
-	}));
-}
-// src/utils.ts
-/**
-* Renames inline enum declarations and their uses together.
-*/
-function resolveInlineEnumNames({ node, owner, resolver, enumOptions }) {
-	return ast.transform(node, { schema(child) {
-		if (child === node || child.type !== "enum" || !child.name) return;
-		const name = resolver.resolveName({
-			key: [
-				"enum",
-				owner,
-				child.pointer ?? child.name
-			],
-			name: child.name,
-			normalize: (value) => {
-				const { enumName, typeName } = getEnumNames$1({
-					node: {
-						...child,
-						name: value
-					},
-					enum: enumOptions,
-					resolver
-				});
-				return enumOptions.type === "literal" ? [typeName] : [enumName, typeName];
-			}
-		});
-		return name === child.name ? void 0 : {
-			...child,
-			name
-		};
-	} });
-}
-function enumTypeName({ resolver, name, enumOptions, isEnum }) {
-	return isEnum && enumOptions?.type === "asConst" && enumOptions.typeSuffix ? resolver.enum.keyName({ name }, enumOptions.typeSuffix) : resolver.name(name);
-}
-/**
-* Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
-* rather than a named enum reference or a runtime enum declaration.
-*
-* The parser folds `const` into a single-value enum node. The adapter decides which schemas are
-* named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for
-* example `StatusKey`). A const renders as a literal only when the adapter has not registered it as
-* a named enum, which keeps the declaration and its references in sync across adapter versions.
-*/
-function isInlineConstEnum(node, enumSchemaNames) {
-	return (node.namedEnumValues ?? node.enumValues ?? []).length === 1 && !(node.name && enumSchemaNames?.has(node.name));
-}
-/**
-* Collects JSDoc annotation strings for a schema node.
-*
-* Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.
-* Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.
-
-*/
-function isSchemaOptional(schema) {
-	return Boolean("optional" in schema && schema.optional || "nullish" in schema && schema.nullish);
-}
-function formatExample(value) {
-	if (value === null || typeof value !== "object") return String(value);
-	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
-}
-/**
-* Whether a schema is binary, or an array of binary items, so its TypeScript type is `Blob` or `Blob[]`.
-*/
-function isBinarySchema(schema) {
-	const meta = syncSchemaRef(schema);
-	const isBlob = (node) => syncSchemaRef(node)?.type === "blob";
-	return !!meta && (isBlob(meta) || meta.type === "array" && "items" in meta && (meta.items ?? []).some(isBlob));
-}
-function buildPropertyJSDocComments(schema, optional) {
-	const meta = syncSchemaRef(schema);
-	const isArray = meta?.primitive === "array";
-	const isNumeric = meta?.primitive === "number" || meta?.primitive === "integer" || meta?.primitive === "bigint";
-	const hasDescription = meta && "description" in meta && meta.description;
-	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
-	const exampleValues = meta?.examples ?? [];
-	const comments = [
-		hasDescription ? `@description ${jsDocEscape(meta.description)}` : null,
-		...formatComment,
-		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
-		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@${isNumeric ? "minimum" : "minLength"} ${meta.min}` : null,
-		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@${isNumeric ? "maximum" : "maxLength"} ${meta.max}` : null,
-		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
-		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : formatExample(meta.default)}` : null,
-		...exampleValues.map((example) => `@example ${formatExample(example)}`)
-	].filter(Boolean);
-	const typeTag = comments.length && !isBinarySchema(schema) && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
-	return [...comments, typeTag].filter(Boolean);
-}
-/**
-* Builds the object schema for a group of parameters sharing one `in` location (path, query, or
-* header), embedding each param's own schema (and JSDoc) directly rather than referencing a
-* separate per-param type — the group itself is the only type these params get exported as.
-*/
-function buildParams({ params }) {
-	return ast.factory.createSchema({
-		type: "object",
-		pointer: params[0]?.pointer?.replace(/\/\d+$/, ""),
-		properties: params.map((param) => ast.factory.createProperty({
-			name: param.name,
-			required: param.required,
-			schema: ast.factory.createSchema({
-				...param.schema,
-				optional: !param.required
-			})
-		}))
-	});
-}
-function buildResponseUnion(node, { resolver }) {
-	const allWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
-	const successWithSchema = allWithSchema.filter((res) => isSuccessStatusCode(res.statusCode));
-	const responsesWithSchema = successWithSchema.length > 0 ? successWithSchema : allWithSchema;
-	if (responsesWithSchema.length === 0) return null;
-	return ast.factory.createSchema({
-		type: "union",
-		members: responsesWithSchema.map((res) => ast.factory.createSchema({
-			type: "ref",
-			name: resolver.response.status(node, res.statusCode)
-		}))
-	});
-}
-// src/printers/printerTs.ts
-const { isNonNullable } = factory_exports;
-const requireModule = createRequire(import.meta.url);
-/**
-* Loads `@kubb/parser-ts` on first use. It is an optional peer dependency: only a deprecated `printer.nodes`
-* handler that returns a TypeScript compiler node needs it. Loads synchronously because node handlers are synchronous.
-*/
-function loadParserTs(load = () => requireModule("@kubb/parser-ts")) {
-	try {
-		return load();
-	} catch (error) {
-		if (error.code !== "MODULE_NOT_FOUND" || !error.message.split("\n")[0].includes("@kubb/parser-ts")) throw error;
-		throw new Diagnostics.Error({
-			code: Diagnostics.code.missingDependency,
-			severity: "error",
-			message: "Missing dependency: @kubb/parser-ts. A `printer.nodes` handler returned a TypeScript compiler node, and printing it needs @kubb/parser-ts.",
-			help: "Run `npm i -D @kubb/parser-ts` in the project, or return a string from the handler.",
-			plugin: "plugin-ts"
-		});
-	}
-}
-/**
-* Adapts user overrides, which work in strings, to the node-based printer: `this.transform` hands them printed
-* strings and their result is wrapped back into a node. A deprecated compiler node prints through `@kubb/parser-ts`.
-*/
-function toNodeHandlers(nodes) {
-	return Object.fromEntries(Object.entries(nodes ?? {}).map(([type, handler]) => [type, function(node) {
-		const transform = (child) => {
-			const output = this.transform(child);
-			return output ? print(output) : null;
-		};
-		const result = handler.call({
-			...this,
-			transform
-		}, node);
-		if (result === null || result === void 0) return result;
-		return createRaw(typeof result === "string" ? result : loadParserTs().parserTs().print(result).trimEnd());
-	}]));
+		headers(node) {
+			const name = this.name(`${node.operationId} Headers`);
+			return this.resolveName({
+				key: operationKey(node, "param", "headers"),
+				name
+			});
+		},
+		cookies(node) {
+			const name = this.name(`${node.operationId} Cookies`);
+			return this.resolveName({
+				key: operationKey(node, "param", "cookies"),
+				name
+			});
+		}
+	};
 }
 /**
-* TypeScript type printer built with `definePrinter`.
-*
-* Converts a `SchemaNode` AST node into TypeScript source:
-* - **`printer.print(node)`** — when `options.name` is set, returns a full
-*   `type Name = …` or `interface Name { … }` declaration.
-*   Without `name`, returns the type for the schema, such as `string | null`.
-*
-* Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed
-* over per printer instance, so each call to `printerTs(options)` produces an independent printer.
-*
-* @example Raw type node (no `typeName`)
-* ```ts
-* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })
-* const type = printer.print(schemaNode) // 'string | null'
-* ```
+* Builds the shared `response` namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`options`, `error`) next
+* to it.
 *
-* @example Full declaration (with `typeName`)
+* @example
 * ```ts
-* const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })
-* const declaration = printer.print(schemaNode) // 'export type MyType = …'
+* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
 * ```
 */
-const printerTs = ast.createPrinter((options) => {
-	const addsUndefined = options.optionalType === "undefined" || options.optionalType === "questionTokenAndUndefined";
+function createOperationResponseResolver() {
 	return {
-		name: "typescript",
-		options,
-		nodes: {
-			any: () => keywordTypeNodes.any,
-			unknown: () => keywordTypeNodes.unknown,
-			void: () => keywordTypeNodes.void,
-			never: () => keywordTypeNodes.never,
-			boolean: () => keywordTypeNodes.boolean,
-			null: () => keywordTypeNodes.null,
-			blob: () => createTypeReferenceNode("Blob"),
-			string: () => keywordTypeNodes.string,
-			uuid: () => keywordTypeNodes.string,
-			email: () => keywordTypeNodes.string,
-			url: (node) => {
-				if (node.path) return createUrlTemplateType(node.path);
-				return keywordTypeNodes.string;
-			},
-			ipv4: () => keywordTypeNodes.string,
-			ipv6: () => keywordTypeNodes.string,
-			datetime: () => keywordTypeNodes.string,
-			number: () => keywordTypeNodes.number,
-			integer: () => keywordTypeNodes.number,
-			bigint: () => keywordTypeNodes.bigint,
-			date: dateOrStringNode,
-			time: dateOrStringNode,
-			ref(node) {
-				if (!node.name) return null;
-				const refName = ast.resolveRefName(node);
-				if (!refName) return null;
-				return createTypeReferenceNode(node.ref ? enumTypeName({
-					resolver: this.options.resolver,
-					name: refName,
-					enumOptions: this.options.enum,
-					isEnum: !!this.options.enumSchemaNames?.has(refName)
-				}) : refName);
-			},
-			enum(node) {
-				const values = ast.getSchemaLiteralValues(node);
-				if (values.some((value) => value !== null && typeof value === "object")) return createUnionDeclaration({ nodes: values.map((value) => constToTypeNode(value)) });
-				if (this.options.enum.type === "inlineLiteral" || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) return createUnionDeclaration({ nodes: values.filter((v) => v !== null && v !== void 0).map((value) => constToTypeNode(value, typeof value)).filter(isNonNullable) });
-				return createTypeReferenceNode(enumTypeName({
-					resolver: this.options.resolver,
-					name: node.name,
-					enumOptions: this.options.enum,
-					isEnum: true
-				}));
-			},
-			union(node) {
-				const members = node.members ?? [];
-				const hasStringLiteral = members.some((m) => {
-					return ast.narrowSchema(m, ast.schemaTypes.enum)?.primitive === "string";
-				});
-				const hasPlainString = members.some((m) => isStringType(m));
-				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({ nodes: members.map((m) => {
-					if (isStringType(m)) return createIntersectionDeclaration({ nodes: [keywordTypeNodes.string, createTypeLiteralNode([])] });
-					return this.transform(m);
-				}).filter(isNonNullable) });
-				return createUnionDeclaration({ nodes: buildMemberNodes(members, this.transform) });
-			},
-			intersection(node) {
-				return createIntersectionDeclaration({ nodes: buildMemberNodes(node.members, this.transform) });
-			},
-			array(node) {
-				return createArrayDeclaration({
-					nodes: mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
-					arrayType: this.options.arrayType
-				});
-			},
-			tuple(node) {
-				return buildTupleNode(node, this.transform);
-			},
-			object(node) {
-				const { transform, options } = this;
-				const keySchema = node.propertyNames && syncSchemaRef(node.propertyNames);
-				if (!node.properties.length && !Object.keys(node.patternProperties ?? {}).length && node.propertyNames && keySchema?.type === "enum" && node.additionalProperties !== false) {
-					const keyType = transform(node.propertyNames) ?? keywordTypeNodes.string;
-					const valueSchema = typeof node.additionalProperties === "object" ? node.additionalProperties : ast.factory.createSchema({ type: "unknown" });
-					return createTypeReferenceNode("Partial", [createTypeReferenceNode("Record", [keyType, buildPropertyType(valueSchema, transform(valueSchema) ?? keywordTypeNodes.unknown, options.optionalType, false)])]);
-				}
-				const addsQuestionToken = options.optionalType === "questionToken" || options.optionalType === "questionTokenAndUndefined";
-				const propertyNodes = mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
-					const baseType = output ?? keywordTypeNodes.unknown;
-					const optional = !property.required || !!property.schema.optional || !!property.schema.nullish;
-					const type = buildPropertyType(property.schema, baseType, options.optionalType, optional);
-					const propMeta = syncSchemaRef(property.schema);
-					const propertyNode = createPropertySignature({
-						questionToken: optional ? addsQuestionToken : false,
-						name,
-						type,
-						readOnly: propMeta?.readOnly
-					});
-					const binaryRemark = isBinarySchema(property.schema) ? "@remarks Pass a `File` to send its filename. A plain `Blob` is sent with the filename `blob`." : void 0;
-					return appendJSDocToNode({
-						node: propertyNode,
-						comments: [...buildPropertyJSDocComments(property.schema, optional), binaryRemark]
-					});
-				});
-				const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)];
-				if (!allElements.length) return keywordTypeNodes.object;
-				return createTypeLiteralNode(allElements);
-			},
-			...toNodeHandlers(options.nodes)
+		status(node, statusCode) {
+			const name = this.name(`${node.operationId} Status ${statusCode}`);
+			return this.resolveName({
+				key: operationKey(node, "response", "status", statusCode),
+				name
+			});
 		},
-		print(node) {
-			const { name, syntaxType = "type", description, keysToOmit } = this.options;
-			const transformed = this.transform(node);
-			if (!transformed) return null;
-			const meta = syncSchemaRef(node);
-			if (!name) return print(wrapNullableOptional(keysToOmit?.length ? createOmitDeclaration({
-				keys: keysToOmit,
-				type: transformed,
-				nonNullable: true
-			}) : transformed, !!meta.nullable, !!(meta.nullish || meta.optional) && addsUndefined));
-			return createTypeDeclaration({
-				name,
-				isExportable: true,
-				type: (() => {
-					return wrapNullableOptional(keysToOmit?.length ? createOmitDeclaration({
-						keys: keysToOmit,
-						type: transformed,
-						nonNullable: true
-					}) : transformed, !!meta.nullable, !!(meta.nullish || meta.optional));
-				})(),
-				syntax: syntaxType === "type" || !!keysToOmit?.length ? "type" : "interface",
-				comments: buildPropertyJSDocComments({
-					...meta,
-					description
-				})
+		headers(node, statusCode) {
+			const name = this.name(`${node.operationId} Status ${statusCode} Headers`);
+			return this.resolveName({
+				key: operationKey(node, "response", "headers", statusCode),
+				name
+			});
+		},
+		body(node) {
+			const name = this.name(`${node.operationId} Body`);
+			return this.resolveName({
+				key: operationKey(node, "response", "body"),
+				name
+			});
+		},
+		responses(node) {
+			const name = this.name(`${node.operationId} Responses`);
+			return this.resolveName({
+				key: operationKey(node, "response", "responses"),
+				name
+			});
+		},
+		response(node) {
+			const name = this.name(`${node.operationId} Response`);
+			return this.resolveName({
+				key: operationKey(node, "response", "response"),
+				name
 			});
 		}
 	};
-});
-// src/components/Type.tsx
-function Type({ name, node, printer, enum: enumOptions, resolver, inline }) {
-	if (inline) {
-		const withoutEnums = ast.transform(node, { schema: (n) => n.type === ast.schemaTypes.enum && n.name ? {
-			...n,
-			name: void 0
-		} : void 0 });
-		const expression = printerTs({
-			...printer.options,
-			name: void 0
-		}).print(withoutEnums)?.replace(/\/\*\*[\s\S]*?\*\/\s*/g, "");
-		if (!expression) return;
-		return /* @__PURE__ */ jsx(File.Source, {
-			name,
-			isTypeOnly: true,
-			isExportable: true,
-			isIndexable: true,
-			inline: { expression },
-			children: expression
-		});
-	}
-	const enumSchemaNodes = ast.collectSync(node, { schema(n) {
-		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
-		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
-	} });
-	const output = printer.print(node);
-	const printerImports = printer.drainImports();
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			node,
-			...getEnumNames$1({
-				node,
-				enum: enumOptions,
-				resolver
-			})
-		};
-	});
-	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
-	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ jsx(Enum, {
-		node,
-		enum: enumOptions,
-		resolver
-	}, node.name)), shouldExportType && /* @__PURE__ */ jsxs(Fragment, { children: [printerImports.map((imp) => /* @__PURE__ */ jsx(File.Import, { ...imp }, [
-		name,
-		imp.path,
-		imp.name
-	].join("-"))), /* @__PURE__ */ jsx(File.Source, {
-		name,
-		pointer: node.pointer,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] })] });
+}
+/**
+* Builds a resolver `file` override whose base name runs every path segment
+* through `toFilePath`, casing the final segment with `caseLast`.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
+* ```
+*/
+function createCasedFile(caseLast) {
+	return { baseName({ name, extname }) {
+		return this.memo(`file:${name}\0${extname}`, () => `${toFilePath(name, caseLast)}${extname}`);
+	} };
+}
+/**
+* Names of the schemas whose type is `enum`, computed once per build.
+*/
+function getEnumNames(ctx) {
+	return ctx.memo("enumNames:set", () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.type === "enum" && schema.name ? [schema.name] : [])));
 }
 // src/generators/typeGenerator.tsx
 /**
@@ -1816,7 +1665,7 @@ const typeGenerator = defineGenerator({
 			group: group ?? void 0,
 			name: importName
 		});
-		const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum);
+		const enumNode = ast.schema.narrow(node, ast.schema.types.enum);
 		const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames);
 		const meta = {
 			name: enumOptions.type === "asConst" && isEnumSchema ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolver.name(node.name),
@@ -1905,7 +1754,7 @@ const typeGenerator = defineGenerator({
 			enumSchemaNames,
 			nodes: printer?.nodes
 		}) : null;
-		function renderSchemaType({ schema, name, keysToOmit }) {
+		function renderSchemaType({ schema, name, keysToOmit, examples, comments }) {
 			if (!schema) return null;
 			if (!inline && enumOptions.type !== "inlineLiteral") schema = resolveInlineEnumNames({
 				node: schema,
@@ -1927,6 +1776,8 @@ const typeGenerator = defineGenerator({
 				name,
 				syntaxType,
 				description: schema.description,
+				examples: getExampleValues(examples, true),
+				comments,
 				keysToOmit,
 				resolver,
 				enumSchemaNames,
@@ -1956,7 +1807,7 @@ const typeGenerator = defineGenerator({
 		* variants by content type in {@link buildResponses}; the standalone alias stays a plain union so
 		* query hooks and `result.data` keep the bare body.
 		*/
-		function buildContentTypeVariants(entries, baseName, pointer, decorate) {
+		function buildContentTypeVariants(entries, baseName, pointer, { decorate, comments }) {
 			const variants = resolveContentTypeVariants(entries, baseName);
 			const keys = variants.map((variant) => inlinePrinter ? `${inlinePrinter.print(variant.schema)}:${variant.keysToOmit ?? ""}` : variant.name);
 			const members = variants.filter((_, index) => keys.indexOf(keys[index]) === index);
@@ -1971,20 +1822,25 @@ const typeGenerator = defineGenerator({
 			return /* @__PURE__ */ jsxs(Fragment, { children: [variants.map((variant) => renderSchemaType({
 				schema: decorate ? decorate(variant.schema) : variant.schema,
 				name: variant.name,
-				keysToOmit: variant.keysToOmit
+				keysToOmit: variant.keysToOmit,
+				examples: entries.find((entry) => entry.contentType === variant.contentType)?.examples
 			})), renderSchemaType({
 				schema: unionSchema,
-				name: baseName
+				name: baseName,
+				comments
 			})] });
 		}
-		const { path, query, header, cookie } = getOperationParameters(node);
+		const { path, query, header, cookie } = ast.http.groupParameters(node);
 		const paramGroupTypes = [
 			[path, resolver.param.path],
 			[query, resolver.param.query],
 			[header, resolver.param.headers],
 			[cookie, resolver.param.cookies]
 		].map(([params, resolveName]) => params.length > 0 && renderSchemaType({
-			schema: buildParams({ params }),
+			schema: buildParams({
+				params,
+				serializedExamples: true
+			}),
 			name: resolveName.call(resolver.param, node, params[0])
 		}));
 		const requestBodyContent = node.requestBody?.content ?? [];
@@ -2000,19 +1856,20 @@ const typeGenerator = defineGenerator({
 						description: node.requestBody.description ?? entry.schema.description
 					},
 					name: resolver.response.body(node),
-					keysToOmit: entry.keysToOmit
+					keysToOmit: entry.keysToOmit,
+					examples: entry.examples
 				});
 			}
-			return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), node.requestBody.pointer, (schema) => ({
+			return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), node.requestBody.pointer, { decorate: (schema) => ({
 				...schema,
 				description: node.requestBody.description ?? schema.description
-			}));
+			}) });
 		}
 		const requestType = buildRequestType();
 		const responseTypes = node.responses.map((res) => {
 			const content = (res.content ?? []).map((entry, _, content) => toResponseContent(entry, content));
 			const variants = content.filter((entry) => entry.schema);
-			if (variants.length > 1) return buildContentTypeVariants(variants, resolver.response.status(node, res.statusCode), res.pointer);
+			if (variants.length > 1) return buildContentTypeVariants(variants, resolver.response.status(node, res.statusCode), res.pointer, { comments: buildResponseComments(res) });
 			const primary = variants[0] ?? content[0];
 			return renderSchemaType({
 				schema: primary?.schema ? {
@@ -2020,22 +1877,34 @@ const typeGenerator = defineGenerator({
 					pointer: res.pointer ?? primary.schema.pointer
 				} : ast.factory.createSchema({ type: "unknown" }),
 				name: resolver.response.status(node, res.statusCode),
-				keysToOmit: primary?.keysToOmit
+				keysToOmit: primary?.keysToOmit,
+				examples: primary?.examples,
+				comments: buildResponseComments(res)
 			});
 		});
+		const responseHeaderTypes = node.responses.map((res) => res.headers?.length ? renderSchemaType({
+			schema: buildParams({
+				params: res.headers,
+				serializedExamples: true
+			}),
+			name: resolver.response.headers(node, res.statusCode)
+		}) : null);
 		const optionsType = renderSchemaType({
 			schema: buildOptionsSchema(node, resolver, { pairContentTypes: true }),
 			name: resolver.response.options(node)
 		});
 		const responsesType = renderSchemaType({
-			schema: buildResponses(node, resolver),
+			schema: buildResponses(node, resolver, { streamData: ast.factory.createSchema({
+				type: "ref",
+				name: "ReadableStream<Uint8Array>"
+			}) }),
 			name: resolver.response.responses(node)
 		});
 		function buildResponseType() {
 			const hasSchema = (res) => (res.content ?? []).some((entry) => entry.schema);
 			const responseName = resolver.response.response(node);
 			const responsesWithSchema = node.responses.filter(hasSchema);
-			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? ast.collectImportedRefNames(entry.schema).map(importName) : []))).has(responseName)) return null;
+			if (new Set(ast.http.responses.getImportedNames(responsesWithSchema).map(importName)).has(responseName)) return null;
 			return renderSchemaType({
 				schema: {
 					...buildResponseUnion(node, { resolver }) ?? ast.factory.createSchema({ type: "unknown" }),
@@ -2068,6 +1937,7 @@ const typeGenerator = defineGenerator({
 			children: [
 				paramGroupTypes,
 				responseTypes,
+				responseHeaderTypes,
 				requestType,
 				optionsType,
 				responsesType,
@@ -2078,11 +1948,11 @@ const typeGenerator = defineGenerator({
 });
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.16.0",
+	"kubb": ">=5.18.4",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.5.0-canary.20261111T122006";
+var version = "5.5.1";
 // src/resolvers/resolverTs.ts
 /**
 * Default resolver used by `@kubb/plugin-ts`. Decides the names and file paths
@@ -2105,9 +1975,9 @@ var version = "5.5.0-canary.20261111T122006";
 const resolverTs = createResolver({
 	pluginName: "plugin-ts",
 	name(name) {
-		return this.memo(`name:${name}`, () => ensureValidVarName(pascalCase(name)));
+		return this.memo(`name:${name}`, () => ensureValidVarName(casing.pascal(name)));
 	},
-	file: createCasedFile(pascalCase),
+	file: createCasedFile(casing.pascal),
 	param: createOperationParamResolver(),
 	response: {
 		...createOperationResponseResolver(),
@@ -2180,7 +2050,7 @@ const pluginTs = defineExtension({
 			include,
 			override,
 			optionalType,
-			group: createGroupConfig(group),
+			group: group ?? null,
 			arrayType,
 			enum: resolvedEnum,
 			syntaxType,