@kubb/plugin-ts 5.0.0-beta.99 → 5.0.1

package/dist/index.cjs

@@ -32,7 +32,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -856,7 +856,7 @@ function buildTupleNode(node, print) {
 */
 function buildPropertyType(schema, baseType, optionalType, optional) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	const meta = kubb_kit.ast.syncSchemaRef(schema);
+	const meta = (0, kubb_kit.syncSchemaRef)(schema);
 	let type = baseType;
 	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
 	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
@@ -950,6 +950,115 @@ function Enum({ node, enum: enumOptions, resolver }) {
 	})] });
 }
 //#endregion
+//#region src/utils.ts
+/**
+* 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("*/", "*\\/");
+}
+function buildPropertyJSDocComments(schema, optional) {
+	const meta = (0, kubb_kit.syncSchemaRef)(schema);
+	const isArray = meta?.primitive === "array";
+	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 ${jsStringEscape(meta.description)}` : null,
+		...formatComment,
+		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
+		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
+		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@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) : meta.default}` : null,
+		...exampleValues.map((example) => `@example ${formatExample(example)}`)
+	].filter(Boolean);
+	const typeTag = comments.length && 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 kubb_kit.ast.factory.createSchema({
+		type: "object",
+		properties: params.map((param) => kubb_kit.ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: kubb_kit.ast.factory.createSchema({
+				...param.schema,
+				optional: !param.required
+			})
+		}))
+	});
+}
+function buildResponseUnion(node, { resolver }) {
+	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
+	if (responsesWithSchema.length === 0) return null;
+	return kubb_kit.ast.factory.createSchema({
+		type: "union",
+		members: responsesWithSchema.map((res) => kubb_kit.ast.factory.createSchema({
+			type: "ref",
+			name: resolver.response.status(node, res.statusCode)
+		}))
+	});
+}
+//#endregion
+//#region src/components/Type.tsx
+function Type({ name, node, printer, enum: enumOptions, resolver }) {
+	const enumSchemaNodes = kubb_kit.ast.collectSync(node, { schema(n) {
+		const enumNode = kubb_kit.ast.narrowSchema(n, kubb_kit.ast.schemaTypes.enum);
+		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
+	} });
+	const output = printer.print(node);
+	if (!output) return;
+	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
+		return {
+			node,
+			...getEnumNames({
+				node,
+				enum: enumOptions,
+				resolver
+			})
+		};
+	});
+	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
+	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Enum, {
+		node,
+		enum: enumOptions,
+		resolver
+	}, node.name)), shouldExportType && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isTypeOnly: true,
+		isExportable: true,
+		isIndexable: true,
+		children: output
+	})] });
+}
+//#endregion
 //#region ../../internals/shared/src/params.ts
 /**
 * Drops parameters that share the same name, keeping the first.
@@ -1017,16 +1126,137 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
+const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
+/**
+* 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) {
-	return {
-		path: dedupeParams(node.parameters.filter((param) => param.in === "path").map((param) => isValidVarName(param.name) ? param : {
-			...param,
-			name: camelCase(param.name)
-		})),
+	const cached = operationParameterGroupsByNode.get(node);
+	if (cached) return cached;
+	const groups = {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
 		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
 		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
 		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
 	};
+	operationParameterGroupsByNode.set(node, groups);
+	return groups;
+}
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
+* printer to emit `z.object(…)` rather than a record.
+*/
+function buildOptionsSchema(node, resolver) {
+	const { path, query, header } = getOperationParameters(node);
+	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const createNever = () => kubb_kit.ast.factory.createSchema({
+		type: "never",
+		primitive: void 0,
+		optional: true
+	});
+	const groups = [
+		{
+			name: "path",
+			params: path,
+			resolve: resolver.param.path
+		},
+		{
+			name: "query",
+			params: query,
+			resolve: resolver.param.query
+		},
+		{
+			name: "headers",
+			params: header,
+			resolve: resolver.param.headers
+		}
+	];
+	return kubb_kit.ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		deprecated: node.deprecated,
+		properties: [kubb_kit.ast.factory.createProperty({
+			name: "body",
+			required: hasBody,
+			schema: hasBody ? kubb_kit.ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.body(node)
+			}) : createNever()
+		}), ...groups.map(({ name, params, resolve }) => {
+			const required = params.some((param) => param.required);
+			return kubb_kit.ast.factory.createProperty({
+				name,
+				required,
+				schema: params.length > 0 ? kubb_kit.ast.factory.createSchema({
+					type: "ref",
+					name: resolve.call(resolver.param, node, params[0]),
+					optional: !required
+				}) : createNever()
+			});
+		})]
+	});
+}
+/**
+* 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.
+*/
+function buildResponseRecordEntry(node, res, resolver) {
+	const statusName = resolver.response.status(node, res.statusCode);
+	const variants = (res.content ?? []).filter((entry) => entry.schema);
+	if (variants.length <= 1) return kubb_kit.ast.factory.createSchema({
+		type: "ref",
+		name: statusName
+	});
+	return kubb_kit.ast.factory.createSchema({
+		type: "union",
+		members: resolveContentTypeVariants(variants, statusName).map((variant) => kubb_kit.ast.factory.createSchema({
+			type: "object",
+			primitive: "object",
+			properties: [kubb_kit.ast.factory.createProperty({
+				name: "contentType",
+				required: true,
+				schema: kubb_kit.ast.factory.createSchema({
+					type: "enum",
+					enumValues: [variant.contentType]
+				})
+			}), kubb_kit.ast.factory.createProperty({
+				name: "data",
+				required: true,
+				schema: kubb_kit.ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
+				})
+			})]
+		}))
+	});
+}
+/**
+* Builds the per-status `<Name>Responses` record for an operation, referencing the already-resolved
+* `<Name>StatusNNN` names. Shared by `@kubb/plugin-ts`'s `Responses` type and `@kubb/plugin-zod`'s
+* inferred responses schema, so both emit the same shape from the same inputs.
+*
+* 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.
+*/
+function buildResponses(node, resolver) {
+	return kubb_kit.ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		properties: node.responses.map((res) => kubb_kit.ast.factory.createProperty({
+			name: String(res.statusCode),
+			required: true,
+			schema: buildResponseRecordEntry(node, res, resolver)
+		}))
+	});
 }
 //#endregion
 //#region ../../internals/shared/src/resolver.ts
@@ -1111,7 +1341,7 @@ function createCasedFile(caseLast) {
 * `resolver.imports` would resolve file paths that are then discarded.
 */
 function collectRefNames(schema) {
-	return kubb_kit.ast.collect(schema, { schema: (node) => {
+	return kubb_kit.ast.collectSync(schema, { schema: (node) => {
 		const refNode = kubb_kit.ast.narrowSchema(node, "ref");
 		if (!refNode?.ref) return null;
 		return kubb_kit.ast.resolveRefName(refNode);
@@ -1178,223 +1408,6 @@ function mapSchemaItems(node, transform) {
 	}));
 }
 //#endregion
-//#region src/utils.ts
-/**
-* 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("*/", "*\\/");
-}
-function buildPropertyJSDocComments(schema, optional) {
-	const meta = kubb_kit.ast.syncSchemaRef(schema);
-	const isArray = meta?.primitive === "array";
-	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 ?? [];
-	return [
-		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
-		...formatComment,
-		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
-		!isArray && meta && "min" in meta && meta.min !== void 0 ? `@minLength ${meta.min}` : null,
-		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@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) : meta.default}` : null,
-		...exampleValues.map((example) => `@example ${formatExample(example)}`),
-		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null
-	].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 kubb_kit.ast.factory.createSchema({
-		type: "object",
-		properties: params.map((param) => kubb_kit.ast.factory.createProperty({
-			name: param.name,
-			required: param.required,
-			schema: kubb_kit.ast.factory.createSchema({
-				...param.schema,
-				optional: !param.required
-			})
-		}))
-	});
-}
-function buildOptions(node, { resolver }) {
-	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
-	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const hasRequiredPath = pathParams.some((param) => param.required);
-	const hasRequiredQuery = queryParams.some((param) => param.required);
-	const hasRequiredHeader = headerParams.some((param) => param.required);
-	return kubb_kit.ast.factory.createSchema({
-		type: "object",
-		deprecated: node.deprecated,
-		properties: [
-			kubb_kit.ast.factory.createProperty({
-				name: "body",
-				required: hasBody,
-				schema: hasBody ? kubb_kit.ast.factory.createSchema({
-					type: "ref",
-					name: resolver.response.body(node)
-				}) : kubb_kit.ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			kubb_kit.ast.factory.createProperty({
-				name: "path",
-				required: hasRequiredPath,
-				schema: pathParams.length > 0 ? kubb_kit.ast.factory.createSchema({
-					type: "ref",
-					name: resolver.param.path(node, pathParams[0]),
-					optional: !hasRequiredPath
-				}) : kubb_kit.ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			kubb_kit.ast.factory.createProperty({
-				name: "query",
-				required: hasRequiredQuery,
-				schema: queryParams.length > 0 ? kubb_kit.ast.factory.createSchema({
-					type: "ref",
-					name: resolver.param.query(node, queryParams[0]),
-					optional: !hasRequiredQuery
-				}) : kubb_kit.ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			kubb_kit.ast.factory.createProperty({
-				name: "headers",
-				required: hasRequiredHeader,
-				schema: headerParams.length > 0 ? kubb_kit.ast.factory.createSchema({
-					type: "ref",
-					name: resolver.param.headers(node, headerParams[0]),
-					optional: !hasRequiredHeader
-				}) : kubb_kit.ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			})
-		]
-	});
-}
-/**
-* 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.
-*/
-function buildResponseRecordEntry(node, res, resolver) {
-	const statusName = resolver.response.status(node, res.statusCode);
-	const variants = (res.content ?? []).filter((entry) => entry.schema);
-	if (variants.length <= 1) return kubb_kit.ast.factory.createSchema({
-		type: "ref",
-		name: statusName
-	});
-	return kubb_kit.ast.factory.createSchema({
-		type: "union",
-		members: resolveContentTypeVariants(variants, statusName).map((variant) => kubb_kit.ast.factory.createSchema({
-			type: "object",
-			properties: [kubb_kit.ast.factory.createProperty({
-				name: "contentType",
-				required: true,
-				schema: kubb_kit.ast.factory.createSchema({
-					type: "enum",
-					enumValues: [variant.contentType]
-				})
-			}), kubb_kit.ast.factory.createProperty({
-				name: "data",
-				required: true,
-				schema: kubb_kit.ast.factory.createSchema({
-					type: "ref",
-					name: variant.name
-				})
-			})]
-		}))
-	});
-}
-function buildResponses(node, { resolver }) {
-	return kubb_kit.ast.factory.createSchema({
-		type: "object",
-		properties: node.responses.map((res) => kubb_kit.ast.factory.createProperty({
-			name: String(res.statusCode),
-			required: true,
-			schema: buildResponseRecordEntry(node, res, resolver)
-		}))
-	});
-}
-function buildResponseUnion(node, { resolver }) {
-	const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
-	if (responsesWithSchema.length === 0) return null;
-	return kubb_kit.ast.factory.createSchema({
-		type: "union",
-		members: responsesWithSchema.map((res) => kubb_kit.ast.factory.createSchema({
-			type: "ref",
-			name: resolver.response.status(node, res.statusCode)
-		}))
-	});
-}
-//#endregion
-//#region src/components/Type.tsx
-function Type({ name, node, printer, enum: enumOptions, resolver }) {
-	const enumSchemaNodes = kubb_kit.ast.collect(node, { schema(n) {
-		const enumNode = kubb_kit.ast.narrowSchema(n, kubb_kit.ast.schemaTypes.enum);
-		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
-	} });
-	const output = printer.print(node);
-	if (!output) return;
-	const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {
-		return {
-			node,
-			...getEnumNames({
-				node,
-				enum: enumOptions,
-				resolver
-			})
-		};
-	});
-	const shouldExportEnums = enumOptions.type !== "inlineLiteral";
-	const shouldExportType = enumOptions.type === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [shouldExportEnums && enums.map(({ node }) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Enum, {
-		node,
-		enum: enumOptions,
-		resolver
-	}, node.name)), shouldExportType && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
-		name,
-		isTypeOnly: true,
-		isExportable: true,
-		isIndexable: true,
-		children: output
-	})] });
-}
-//#endregion
 //#region src/printers/printerTs.ts
 const { isNonNullable } = factory_exports;
 /**
@@ -1469,11 +1482,11 @@ const printerTs = kubb_kit.ast.createPrinter((options) => {
 				const hasStringLiteral = members.some((m) => {
 					return kubb_kit.ast.narrowSchema(m, kubb_kit.ast.schemaTypes.enum)?.primitive === "string";
 				});
-				const hasPlainString = members.some((m) => kubb_kit.ast.isStringType(m));
+				const hasPlainString = members.some((m) => (0, kubb_kit.isStringType)(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if (kubb_kit.ast.isStringType(m)) return createIntersectionDeclaration({
+						if ((0, kubb_kit.isStringType)(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -1507,7 +1520,7 @@ const printerTs = kubb_kit.ast.createPrinter((options) => {
 					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 = kubb_kit.ast.syncSchemaRef(property.schema);
+					const propMeta = (0, kubb_kit.syncSchemaRef)(property.schema);
 					return appendJSDocToNode({
 						node: createPropertySignature({
 							questionToken: optional ? addsQuestionToken : false,
@@ -1528,7 +1541,7 @@ const printerTs = kubb_kit.ast.createPrinter((options) => {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = kubb_kit.ast.syncSchemaRef(node);
+			const meta = (0, kubb_kit.syncSchemaRef)(node);
 			if (!name) {
 				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [transformed, keywordTypeNodes.null] }) : transformed;
 				const result = (meta.nullish || meta.optional) && addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
@@ -1784,11 +1797,11 @@ const typeGenerator = (0, kubb_kit.defineGenerator)({
 			});
 		});
 		const optionsType = renderSchemaType({
-			schema: buildOptions(node, { resolver }),
+			schema: buildOptionsSchema(node, resolver),
 			name: resolver.response.options(node)
 		});
 		const responsesType = renderSchemaType({
-			schema: buildResponses(node, { resolver }),
+			schema: buildResponses(node, resolver),
 			name: resolver.response.responses(node)
 		});
 		function buildResponseType() {