@kubb/plugin-zod 5.0.0-beta.99 → 5.0.0

package/dist/index.d.ts

@@ -238,21 +238,21 @@ type ResolverZod = Resolver & {
      * Resolves the name for an operation's grouped path parameters schema.
      *
      * @example Path parameters names
-     * `resolver.param.path(node, param) // → 'deletePetPathPetIdSchema'`
+     * `resolver.param.path(node, param) // → 'deletePetPathSchema'`
      */
     path(node: ast.OperationNode, param: ast.ParameterNode): string;
     /**
      * Resolves the name for an operation's grouped query parameters schema.
      *
      * @example Query parameters names
-     * `resolver.param.query(node, param) // → 'findPetsByStatusQueryStatusSchema'`
+     * `resolver.param.query(node, param) // → 'findPetsByStatusQuerySchema'`
      */
     query(node: ast.OperationNode, param: ast.ParameterNode): string;
     /**
      * Resolves the name for an operation's grouped header parameters schema.
      *
      * @example Header parameters names
-     * `resolver.param.headers(node, param) // → 'deletePetHeaderApiKeySchema'`
+     * `resolver.param.headers(node, param) // → 'deletePetHeadersSchema'`
      */
     headers(node: ast.OperationNode, param: ast.ParameterNode): string;
   };
@@ -297,6 +297,15 @@ type ResolverZod = Resolver & {
      * `resolver.response.error(node) // → 'listPetsErrorSchema'`
      */
     error(node: ast.OperationNode): string;
+    /**
+     * Resolves the inferred type name for an operation's combined `{ body, path, query, headers }`
+     * options object. Only meaningful when `inferred: true`, since the schema and type this name
+     * points to are generated only in that case.
+     *
+     * @example Options type names
+     * `resolver.response.options(node) // → 'ListPetsOptionsSchemaType'`
+     */
+    options(node: ast.OperationNode): string;
   };
 };
 /**

package/dist/index.js

@@ -1,7 +1,180 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
+import { Resolver, ast, containsCircularRef, createResolver, defineGenerator, definePlugin, extractRefName, syncSchemaRef } from "kubb/kit";
 import { Const, File, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* 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;
+}
+/**
+* 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)) {
+			suffix = `${baseSuffix}${counter++}`;
+			name = getPerContentTypeName(baseName, suffix);
+		}
+		usedNames.add(name);
+		return {
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
+		};
+	});
+}
+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) {
+	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 = () => 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 ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		deprecated: node.deprecated,
+		properties: [ast.factory.createProperty({
+			name: "body",
+			required: hasBody,
+			schema: hasBody ? ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.body(node)
+			}) : createNever()
+		}), ...groups.map(({ name, params, resolve }) => {
+			const required = params.some((param) => param.required);
+			return ast.factory.createProperty({
+				name,
+				required,
+				schema: params.length > 0 ? ast.factory.createSchema({
+					type: "ref",
+					name: resolve.call(resolver.param, node, params[0]),
+					optional: !required
+				}) : createNever()
+			});
+		})]
+	});
+}
+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;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+//#endregion
+//#region ../../internals/shared/src/adapter.ts
+/**
+* Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
+* so OAS-only options (`dateType`, `enums`) and the parsed `document` are typed.
+*
+* Throws when a non-OAS adapter is configured, turning a silently wrong cast into a
+* clear, actionable error at the point of use.
+*
+* @example
+* ```ts
+* const { dateType } = getOasAdapter(ctx.adapter).options
+* ```
+*/
+function getOasAdapter(adapter) {
+	if (adapter.name !== "oas") throw new Error(`Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}". Configure \`adapter: adapterOas()\` in your Kubb config.`);
+	return adapter;
+}
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -346,85 +519,6 @@ function toFilePath(name, caseLast = camelCase) {
 	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
-//#region ../../internals/shared/src/operation.ts
-/**
-* 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;
-}
-/**
-* 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)) {
-			suffix = `${baseSuffix}${counter++}`;
-			name = getPerContentTypeName(baseName, suffix);
-		}
-		usedNames.add(name);
-		return {
-			name,
-			suffix,
-			schema: entry.schema,
-			keysToOmit: entry.keysToOmit,
-			contentType: entry.contentType
-		};
-	});
-}
-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;
-}
-function getSuccessResponses(responses) {
-	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
-}
-//#endregion
-//#region ../../internals/shared/src/adapter.ts
-/**
-* Narrows the generic `Adapter` from a generator context to the OpenAPI adapter,
-* so OAS-only options (`dateType`, `enums`) and the parsed `document` are typed.
-*
-* Throws when a non-OAS adapter is configured, turning a silently wrong cast into a
-* clear, actionable error at the point of use.
-*
-* @example
-* ```ts
-* const { dateType } = getOasAdapter(ctx.adapter).options
-* ```
-*/
-function getOasAdapter(adapter) {
-	if (adapter.name !== "oas") throw new Error(`Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}". Configure \`adapter: adapterOas()\` in your Kubb config.`);
-	return adapter;
-}
-//#endregion
 //#region ../../internals/shared/src/resolver.ts
 /**
 * Resolves a single operation parameter name with the
@@ -437,6 +531,29 @@ function operationParamName(node, param) {
 	return this.name(`${node.operationId} ${param.in} ${param.name}`);
 }
 /**
+* Builds the shared `param` namespace. Spread the result into `createResolver`
+* and override individual methods next to it when a plugin deviates.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ param: createOperationParamResolver(), ... })
+* ```
+*/
+function createOperationParamResolver() {
+	return {
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
+		},
+		query(node) {
+			return this.name(`${node.operationId} Query`);
+		},
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	};
+}
+/**
 * Builds the shared `response` namespace. Spread the result into
 * `createResolver` and add plugin-specific methods (`options`, `error`) next
 * to it.
@@ -484,7 +601,7 @@ function createCasedFile(caseLast) {
 * `resolver.imports` would resolve file paths that are then discarded.
 */
 function collectRefNames(schema) {
-	return ast.collect(schema, { schema: (node) => {
+	return ast.collectSync(schema, { schema: (node) => {
 		const refNode = ast.narrowSchema(node, "ref");
 		if (!refNode?.ref) return null;
 		return ast.resolveRefName(refNode);
@@ -644,12 +761,12 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 	if (hasCodec(node)) return true;
 	if (node.type === "ref") {
 		if (!node.ref) return false;
-		const refName = ast.extractRefName(node.ref);
+		const refName = extractRefName(node.ref);
 		if (refName) {
 			if (seen.has(refName)) return false;
 			seen.add(refName);
 		}
-		const resolved = ast.syncSchemaRef(node);
+		const resolved = syncSchemaRef(node);
 		if (resolved.type === "ref") return false;
 		return containsCodec(resolved, seen);
 	}
@@ -665,7 +782,7 @@ function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
 * them to their input (encode) variant.
 */
 function collectCodecRefNames(node) {
-	return ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.resolveRefName(n) ?? void 0 : void 0 });
+	return ast.collectSync(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.resolveRefName(n) ?? void 0 : void 0 });
 }
 /**
 * Whether the node is a plain inline object whose shape can be lifted into an `.extend({ … })`
@@ -688,7 +805,7 @@ function isObjectSchemaNode(node, cyclicSchemas) {
 	if (node.type === "ref") {
 		const refName = ast.resolveRefName(node);
 		if (refName && cyclicSchemas?.has(refName)) return false;
-		const resolved = ast.syncSchemaRef(node);
+		const resolved = syncSchemaRef(node);
 		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
 	}
 	if (node.type === "union") {
@@ -764,6 +881,20 @@ function buildEnum(values) {
 	return `z.union([${literals.join(", ")}])`;
 }
 /**
+* Digit pattern for a `type: 'string'` schema that carries an integer `format`, the way ProtoJSON
+* encodes 64-bit integers. Returns `undefined` for every other format, and a `pattern` from the
+* spec takes precedence over this fallback.
+*
+* @example
+* ```ts
+* integerFormatPattern('uint64') // '^\\d+$'
+* ```
+*/
+function integerFormatPattern(format) {
+	if (format === "int32" || format === "int64") return "^-?\\d+$";
+	if (format === "uint64") return "^\\d+$";
+}
+/**
 * Map a `regexType` to the `func` argument of `toRegExpString`: `'constructor'` emits
 * `new RegExp(...)`, while `'literal'` (the default) emits a regex literal.
 */
@@ -888,6 +1019,22 @@ function applyMiniModifiers({ value, schema, nullable, optional, nullish, defaul
 	const literal = defaultValue !== void 0 ? defaultLiteral(schema, defaultValue) : null;
 	return literal !== null ? `z._default(${withModifier}, ${literal})` : withModifier;
 }
+/**
+* Builds an `object` schema node grouping the given parameter nodes.
+* The `primitive: 'object'` marker ensures the Zod printer emits `z.object(…)` rather than a record.
+*/
+function buildGroupedParamsSchema({ params, optional }) {
+	return ast.factory.createSchema({
+		type: "object",
+		optional,
+		primitive: "object",
+		properties: params.map((param) => ast.factory.createProperty({
+			name: param.name,
+			required: param.required,
+			schema: param.schema
+		}))
+	});
+}
 //#endregion
 //#region src/printers/printerZod.ts
 function strictOneOfMember$1(member, node, cyclicSchemas) {
@@ -896,7 +1043,7 @@ function strictOneOfMember$1(member, node, cyclicSchemas) {
 		if (member.startsWith("z.lazy(")) return member;
 		const refName = ast.resolveRefName(node);
 		if (refName && cyclicSchemas?.has(refName)) return member;
-		const schema = ast.syncSchemaRef(node);
+		const schema = syncSchemaRef(node);
 		if (schema.nullable || schema.optional || node.nullable || node.optional) return member;
 		if (schema.type === "object" && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
 	}
@@ -921,7 +1068,7 @@ function getMemberConstraint({ member, regexType }) {
 function buildZodObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
 	return buildObject(mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
@@ -931,7 +1078,7 @@ function buildZodObjectShape(ctx, node) {
 		return baseOutput;
 	}).map(({ name: propName, property, output: baseOutput }) => {
 		const { schema } = property;
-		const meta = ast.syncSchemaRef(schema);
+		const meta = syncSchemaRef(schema);
 		const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
 		const value = applyModifiers({
 			value: baseOutput,
@@ -974,8 +1121,11 @@ const printerZod = ast.createPrinter((options) => {
 			boolean: () => "z.boolean()",
 			null: () => "z.null()",
 			string(node) {
-				return `${shouldCoerce(this.options.coercion, "strings") ? "z.coerce.string()" : "z.string()"}${lengthConstraints({
+				const base = shouldCoerce(this.options.coercion, "strings") ? "z.coerce.string()" : "z.string()";
+				const pattern = node.pattern ?? integerFormatPattern(node.format);
+				return `${base}${lengthConstraints({
 					...node,
+					pattern,
 					regexType: this.options.regexType
 				})}`;
 			},
@@ -1116,7 +1266,7 @@ const printerZod = ast.createPrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			const meta = syncSchemaRef(node);
 			return applyModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -1161,7 +1311,7 @@ function getMemberConstraintMini({ member, regexType }) {
 function buildZodMiniObjectShape(ctx, node) {
 	const objectNode = ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && ast.containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
 	return buildObject(mapSchemaProperties(objectNode, (schema) => {
 		const hasSelfRef = isCyclic(schema);
 		const savedCyclicSchemas = ctx.options.cyclicSchemas;
@@ -1171,7 +1321,7 @@ function buildZodMiniObjectShape(ctx, node) {
 		return baseOutput;
 	}).map(({ name: propName, property, output: baseOutput }) => {
 		const { schema } = property;
-		const meta = ast.syncSchemaRef(schema);
+		const meta = syncSchemaRef(schema);
 		const value = applyMiniModifiers({
 			value: baseOutput,
 			schema,
@@ -1211,8 +1361,10 @@ const printerZodMini = ast.createPrinter((options) => {
 			boolean: () => "z.boolean()",
 			null: () => "z.null()",
 			string(node) {
+				const pattern = node.pattern ?? integerFormatPattern(node.format);
 				return `z.string()${lengthChecksMini({
 					...node,
+					pattern,
 					regexType: this.options.regexType
 				})}`;
 			},
@@ -1342,7 +1494,7 @@ const printerZodMini = ast.createPrinter((options) => {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			const meta = syncSchemaRef(node);
 			return applyMiniModifiers({
 				value: (() => {
 					if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
@@ -1693,6 +1845,30 @@ const zodGenerator = defineGenerator({
 				description: node.requestBody.description ?? schema.description
 			}), "input");
 		})();
+		const { path, query, header } = getOperationParameters(node);
+		const paramGroupSchemas = inferred ? [
+			{
+				kind: "path",
+				params: path
+			},
+			{
+				kind: "query",
+				params: query
+			},
+			{
+				kind: "headers",
+				params: header
+			}
+		].filter(({ params }) => params.length > 0).map(({ kind, params }) => renderSchemaEntry({
+			schema: buildGroupedParamsSchema({ params }),
+			name: resolver.param[kind](node, params[0]),
+			direction: "input"
+		})) : [];
+		const optionsSchema = inferred ? renderSchemaEntry({
+			schema: buildOptionsSchema(node, resolver),
+			name: resolver.name(`${node.operationId} Options`),
+			direction: "input"
+		}) : null;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
@@ -1723,7 +1899,9 @@ const zodGenerator = defineGenerator({
 				responseSchemas,
 				responseUnionSchema,
 				errorUnionSchema,
-				requestSchema
+				requestSchema,
+				paramGroupSchemas,
+				optionsSchema
 			]
 		});
 	}
@@ -1765,22 +1943,14 @@ const resolverZod = createResolver({
 			return this.schema.typeName(`${name} input`);
 		}
 	},
-	param: {
-		name: operationParamName,
-		path(node, param) {
-			return this.param.name(node, param);
-		},
-		query(node, param) {
-			return this.param.name(node, param);
-		},
-		headers(node, param) {
-			return this.param.name(node, param);
-		}
-	},
+	param: createOperationParamResolver(),
 	response: {
 		...createOperationResponseResolver(),
 		error(node) {
 			return this.name(`${node.operationId} Error`);
+		},
+		options(node) {
+			return this.schema.type(this.name(`${node.operationId} Options`));
 		}
 	}
 });