@kubb/plugin-vue-query 5.0.0-beta.4 → 5.0.0-beta.56

package/dist/{components-D1UhYFgY.js → components-B79Gljyl.js}

@@ -1,8 +1,9 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
+import { t as __name } from "./chunk-C0LytTxp.js";
 import { ast } from "@kubb/core";
 import { functionPrinter } from "@kubb/plugin-ts";
 import { File, Function, Type } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { getNestedAccessor } from "@kubb/ast/utils";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -14,50 +15,20 @@ import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
 * Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
 *
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-//#endregion
-//#region ../../internals/utils/src/object.ts
-/**
-* Converts a dot-notation path or string array into an optional-chaining accessor expression.
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
 *
-* @example
-* getNestedAccessor('pagination.next.id', 'lastPage')
-* // → "lastPage?.['pagination']?.['next']?.['id']"
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function getNestedAccessor(param, accessor) {
-	const parts = Array.isArray(param) ? param : param.split(".");
-	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
-	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 //#endregion
 //#region ../../internals/utils/src/reserved.ts
@@ -163,99 +134,80 @@ function isValidVarName(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
-//#region ../../internals/utils/src/urlPath.ts
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
 */
-var URLPath = class {
+var Url = class Url {
 	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
 	*/
-	get URL() {
-		return this.toURLPath();
+	static canParse(url, base) {
+		return URL.canParse(url, base);
 	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
 	*
 	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
 	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
 	}
 	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
 	*
 	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	get object() {
-		return this.toObject();
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	/**
+	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+	* expression when `stringify` is set.
 	*
 	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.getParams();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
 	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
+	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
 		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -264,64 +216,153 @@ var URLPath = class {
 		}
 		return object;
 	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	getParams(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
 };
 //#endregion
-//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
-function getParams$4() {
-	return ast.createFunctionParameters({ params: [] });
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.resolveFile`: 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.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+function getOperationLink(node, link) {
+	if (!link) return null;
+	if (typeof link === "function") return link(node) ?? null;
+	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
+	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
 }
-__name(getParams$4, "getParams");
-const getTransformer$1 = /* @__PURE__ */ __name(({ node, casing }) => {
-	return [`{ url: '${new URLPath(node.path, { casing }).toURLPath()}' }`];
-}, "getTransformer");
-function MutationKey({ name, paramsCasing, node, transformer = getTransformer$1 }) {
-	const paramsNode = getParams$4();
-	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
-	const keys = transformer({
+function getContentTypeInfo(node) {
+	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function buildRequestConfigType(node, resolver) {
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
+	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
+	return `${requestName ? `Partial<RequestConfig<${requestName}>>` : "Partial<RequestConfig>"} & { ${["client?: Client", isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null].filter(Boolean).join("; ")} }`;
+}
+function buildOperationComments(node, options = {}) {
+	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
+	const linkComment = getOperationLink(node, link);
+	const filteredComments = (linkPosition === "beforeDeprecated" ? [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		linkComment,
+		node.deprecated && "@deprecated"
+	] : [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		node.deprecated && "@deprecated",
+		linkComment
+	]).filter((comment) => Boolean(comment));
+	if (!splitLines) return filteredComments;
+	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
+}
+function getOperationParameters(node, options = {}) {
+	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	return {
+		path: params.filter((param) => param.in === "path"),
+		query: params.filter((param) => param.in === "query"),
+		header: params.filter((param) => param.in === "header"),
+		cookie: params.filter((param) => param.in === "cookie")
+	};
+}
+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 isErrorStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 400;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+function resolveSuccessNames(node, resolver) {
+	return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+/**
+* Builds the discriminated union type string for `dataReturnType: 'full'` return shapes.
+* Each member is `{ status: N; data: StatusNType; statusText: string }`.
+*/
+function buildStatusUnionType(node, resolver) {
+	const members = node.responses.map((r) => {
+		const typeName = resolver.resolveResponseStatusName(node, r.statusCode);
+		const statusCode = Number.parseInt(r.statusCode, 10);
+		return `{ status: ${Number.isNaN(statusCode) ? "number" : String(statusCode)}; data: ${typeName}; statusText: string }`;
+	});
+	if (members.length === 1) return members[0];
+	return `(${members.join(" | ")})`;
+}
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
+	let byResolver = typeNamesByResolver.get(resolver);
+	if (byResolver) {
+		const cached = byResolver.get(cacheKey);
+		if (cached) return cached;
+	} else {
+		byResolver = /* @__PURE__ */ new Map();
+		typeNamesByResolver.set(resolver, byResolver);
+	}
+	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
+	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
+	const exclude = new Set(options.exclude ?? []);
+	const paramNames = [
+		...path.map((param) => resolver.resolvePathParamsName(node, param)),
+		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
+		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
+	];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
+	const result = (options.order === "body-response-first" ? [
+		...bodyAndResponseNames,
+		...paramNames,
+		...responseStatusNames
+	] : [
+		...paramNames,
+		...bodyAndResponseNames,
+		...responseStatusNames
+	]).filter((name) => Boolean(name) && !exclude.has(name));
+	byResolver.set(cacheKey, result);
+	return result;
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
+const mutationKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	return [`{ url: '${Url.toPath(node.path)}' }`];
+};
+function MutationKey({ name, paramsCasing, node, transformer }) {
+	const paramsNode = ast.createFunctionParameters({ params: [] });
+	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
 		node,
 		casing: paramsCasing
 	});
@@ -338,28 +379,76 @@ function MutationKey({ name, paramsCasing, node, transformer = getTransformer$1
 		})
 	});
 }
-MutationKey.getParams = getParams$4;
-MutationKey.getTransformer = getTransformer$1;
 //#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
 /**
-* Build JSDoc comment lines from an OperationNode.
+* Builds the shared `(…params, config = {})` parameter list for a TanStack
+* query-options function. The trailing `config` parameter is typed as a partial
+* `RequestConfig` with an optional `client`. Framework plugins wrap the result
+* when needed, for example vue-query applies `MaybeRefOrGetter`.
 */
-function getComments(node) {
-	return [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		node.deprecated && "@deprecated",
-		`{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`
-	].filter((x) => Boolean(x));
+function buildQueryOptionsParams(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	return ast.createOperationParams(node, {
+		paramsType,
+		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
+		paramsCasing,
+		resolver,
+		extraParams: [ast.createFunctionParameter({
+			name: "config",
+			type: ast.createParamsType({
+				variant: "reference",
+				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+			}),
+			default: "{}"
+		})]
+	});
+}
+/**
+* Returns `'zod'` when response-direction parsing is enabled.
+* The string shorthand `'zod'` also enables response parsing.
+*/
+function resolveResponseParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.response ?? null;
+}
+/**
+* Returns `'zod'` when request body parsing is enabled.
+* The string shorthand `'zod'` also enables request body parsing (existing behavior).
+*/
+function resolveRequestParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.request ?? null;
 }
 /**
-* Resolve error type names from operation responses.
+* Returns `'zod'` when query-params parsing is enabled.
+* Only the object form `{ request: 'zod' }` enables this. `parser: 'zod'` does not.
 */
-function resolveErrorNames(node, tsResolver) {
-	return node.responses.filter((r) => {
-		return Number.parseInt(r.statusCode, 10) >= 400;
-	}).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
+function resolveQueryParamsParser(parser) {
+	if (!parser || parser === "zod") return null;
+	return parser.request ?? null;
+}
+/**
+* Collects the Zod schema import names for an operation based on the active parser directions.
+*
+* - `parser: 'zod'`: response and request body names (backward-compatible behavior).
+* - `parser: { request: 'zod' }`: request body and query params names.
+* - `parser: { response: 'zod' }`: response name only.
+* - `parser: { request: 'zod', response: 'zod' }`: all three.
+*
+* Returns an empty array when no resolver is provided or `parser` is falsy.
+*/
+function resolveZodSchemaNames(node, zodResolver, parser) {
+	if (!zodResolver || !parser) return [];
+	const { query: queryParams } = getOperationParameters(node);
+	return [
+		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
+	].filter((n) => Boolean(n));
 }
 /**
 * Resolve the type for a single path parameter.
@@ -383,30 +472,14 @@ function resolvePathParamType(node, param, resolver) {
 }
 /**
 * Derive a query-params group type from the resolver.
-* Returns `undefined` when no query params exist or when the group name
+* Returns `null` when no query params exist or when the group name
 * equals the individual param name (no real group).
 */
 function resolveQueryGroupType(node, params, resolver) {
-	if (!params.length) return void 0;
+	if (!params.length) return null;
 	const firstParam = params[0];
 	const groupName = resolver.resolveQueryParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return void 0;
-	return {
-		type: ast.createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Derive a header-params group type from the resolver.
-*/
-function resolveHeaderGroupType(node, params, resolver) {
-	if (!params.length) return void 0;
-	const firstParam = params[0];
-	const groupName = resolver.resolveHeaderParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return void 0;
+	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
 	return {
 		type: ast.createParamsType({
 			variant: "reference",
@@ -456,7 +529,7 @@ function buildQueryKeyParams(node, options) {
 	const bodyType = node.requestBody?.content?.[0]?.schema ? ast.createParamsType({
 		variant: "reference",
 		name: resolver.resolveDataName(node)
-	}) : void 0;
+	}) : null;
 	const bodyRequired = node.requestBody?.required ?? false;
 	const params = [];
 	if (pathParams.length) {
@@ -481,47 +554,84 @@ function buildQueryKeyParams(node, options) {
 	return ast.createFunctionParameters({ params });
 }
 /**
-* Build mutation arg params for paramsToTrigger mode.
-* Contains pathParams + data + queryParams + headers (all flattened, for type alias).
+* Collect the names of the required params (no default) that drive the `enabled`
+* guard. These are exactly the params that should be made optional in the
+* generated signatures so callers can pass `undefined` to reach the disabled state.
 */
-function buildMutationArgParams(node, options) {
-	const { paramsCasing, resolver } = options;
-	const casedParams = ast.caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const queryGroupType = resolveQueryGroupType(node, queryParams, resolver);
-	const headerGroupType = resolveHeaderGroupType(node, headerParams, resolver);
-	const bodyType = node.requestBody?.content?.[0]?.schema ? ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : void 0;
-	const bodyRequired = node.requestBody?.required ?? false;
-	const params = [];
-	for (const p of pathParams) params.push(ast.createFunctionParameter({
-		name: p.name,
-		type: resolvePathParamType(node, p, resolver),
-		optional: !p.required
-	}));
-	if (bodyType) params.push(ast.createFunctionParameter({
-		name: "data",
-		type: bodyType,
-		optional: !bodyRequired
-	}));
-	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
-	params.push(...buildGroupParam("headers", node, headerParams, headerGroupType, resolver));
+function getEnabledParamNames(paramsNode) {
+	const required = [];
+	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
+		const group = param;
+		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
+	} else {
+		const fp = param;
+		if (!fp.optional && fp.default === void 0) required.push(fp.name);
+	}
+	return required;
+}
+/**
+* Return a copy of `paramsNode` with the named params marked optional.
+*
+* Used to align signatures with the `enabled` guard: the guard already disables
+* the query while a param is falsy, so the param should accept `undefined`. The
+* change is type-only — the `queryFn` keeps calling the client with a non-null
+* assertion (see `injectNonNullAssertions`), so the emitted runtime is unchanged.
+*/
+function markParamsOptional(paramsNode, names) {
+	if (names.length === 0) return paramsNode;
+	const nameSet = new Set(names);
+	const params = paramsNode.params.map((param) => {
+		if ("kind" in param && param.kind === "ParameterGroup") {
+			const group = param;
+			return {
+				...group,
+				properties: group.properties.map((child) => nameSet.has(child.name) ? ast.createFunctionParameter({
+					name: child.name,
+					type: child.type,
+					rest: child.rest,
+					optional: true
+				}) : child)
+			};
+		}
+		const fp = param;
+		return nameSet.has(fp.name) ? ast.createFunctionParameter({
+			name: fp.name,
+			type: fp.type,
+			rest: fp.rest,
+			optional: true
+		}) : fp;
+	});
 	return ast.createFunctionParameters({ params });
 }
+functionPrinter({ mode: "declaration" });
+const queryKeyTransformer = ({ node, casing }) => {
+	if (!node.path) return [];
+	const hasQueryParams = getOperationParameters(node).query.length > 0;
+	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
+	return [
+		Url.toObject(node.path, {
+			type: "path",
+			stringify: true,
+			casing
+		}),
+		hasQueryParams ? "...(params ? [params] : [])" : null,
+		hasRequestBody ? "...(data ? [data] : [])" : null
+	].filter(Boolean);
+};
 //#endregion
 //#region src/utils.ts
-function transformName(name, type, transformers) {
-	return transformers?.name?.(name, type) || name;
+function printType(typeNode) {
+	if (!typeNode) return "unknown";
+	if (typeNode.variant === "reference") return typeNode.name;
+	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
+	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
+		const typeStr = printType(p.type);
+		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
+	}).join("; ")} }`;
+	return "unknown";
 }
-//#endregion
-//#region src/components/QueryKey.tsx
-const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
-const callPrinter$5 = functionPrinter({ mode: "call" });
-function wrapWithMaybeRefOrGetter(paramsNode) {
+function wrapWithMaybeRefOrGetter(paramsNode, skip) {
 	const wrappedParams = paramsNode.params.map((param) => {
 		if ("kind" in param && param.kind === "ParameterGroup") {
 			const group = param;
@@ -531,59 +641,38 @@ function wrapWithMaybeRefOrGetter(paramsNode) {
 					...p,
 					type: p.type ? ast.createParamsType({
 						variant: "reference",
-						name: `MaybeRefOrGetter<${printType$4(p.type)}>`
+						name: `MaybeRefOrGetter<${printType(p.type)}>`
 					}) : p.type
 				}))
 			};
 		}
 		const fp = param;
+		if (skip?.(fp.name)) return fp;
 		return {
 			...fp,
 			type: fp.type ? ast.createParamsType({
 				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$4(fp.type)}>`
+				name: `MaybeRefOrGetter<${printType(fp.type)}>`
 			}) : fp.type
 		};
 	});
 	return ast.createFunctionParameters({ params: wrappedParams });
 }
-function printType$4(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$4(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-__name(printType$4, "printType");
-function getParams$3(node, options) {
+//#endregion
+//#region src/components/QueryKey.tsx
+const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
+function buildQueryKeyParamsNode(node, options) {
 	return wrapWithMaybeRefOrGetter(buildQueryKeyParams(node, options));
 }
-__name(getParams$3, "getParams");
-const getTransformer = ({ node, casing }) => {
-	const path = new URLPath(node.path, { casing });
-	const hasQueryParams = node.parameters.some((p) => p.in === "query");
-	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
-	return [
-		path.toObject({
-			type: "path",
-			stringify: true
-		}),
-		hasQueryParams ? "...(params ? [params] : [])" : void 0,
-		hasRequestBody ? "...(data ? [data] : [])" : void 0
-	].filter(Boolean);
-};
-function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer = getTransformer }) {
-	const paramsNode = getParams$3(node, {
+function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer }) {
+	const baseParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
 	});
+	const paramsNode = markParamsOptional(baseParamsNode, getEnabledParamNames(baseParamsNode));
 	const paramsSignature = declarationPrinter$5.print(paramsNode) ?? "";
-	const keys = transformer({
+	const keys = (transformer ?? queryKeyTransformer)({
 		node,
 		casing: paramsCasing
 	});
@@ -610,103 +699,35 @@ function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeNa
 		})
 	})] });
 }
-QueryKey.getParams = getParams$3;
-QueryKey.getTransformer = getTransformer;
-QueryKey.callPrinter = callPrinter$5;
 //#endregion
 //#region src/components/QueryOptions.tsx
 const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
 const callPrinter$4 = functionPrinter({ mode: "call" });
 function getQueryOptionsParams(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
-	return wrapOperationParamsWithMaybeRef$2(ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [ast.createFunctionParameter({
-			name: "config",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
-			}),
-			default: "{}"
-		})]
-	}));
-}
-function wrapOperationParamsWithMaybeRef$2(paramsNode) {
-	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType$3(p.type)}>`
-					}) : p.type
-				}))
-			};
-		}
-		const fp = param;
-		if (fp.name === "config") return fp;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$3(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	return ast.createFunctionParameters({ params: wrappedParams });
-}
-__name(wrapOperationParamsWithMaybeRef$2, "wrapOperationParamsWithMaybeRef");
-function printType$3(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$3(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-__name(printType$3, "printType");
-function buildEnabledCheck(paramsNode) {
-	const required = [];
-	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
-		const group = param;
-		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
-	} else {
-		const fp = param;
-		if (!fp.optional && fp.default === void 0) required.push(fp.name);
-	}
-	return required.join(" && ");
+	return wrapWithMaybeRefOrGetter(buildQueryOptionsParams(node, options), (name) => name === "config");
 }
 function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const paramsNode = getQueryOptionsParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$4.print(queryKeyParamsNode) ?? "";
+	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
+	const enabledText = enabledNames.length ? `enabled: () => ${enabledNames.map((n) => `!!toValue(${n})`).join(" && ")},` : "";
+	const paramsNode = markParamsOptional(getQueryOptionsParams(node, {
 		paramsType,
 		paramsCasing,
 		pathParamsType,
 		resolver: tsResolver
-	});
+	}), enabledNames);
 	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
 	const clientCallStr = (callPrinter$4.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
-	const queryKeyParamsNode = QueryKey.getParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$4.print(queryKeyParamsNode) ?? "";
-	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
-	const enabledText = enabledSource ? `enabled: () => !!(${enabledSource}),` : "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -717,11 +738,10 @@ function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, para
 			params: paramsSignature,
 			children: `
       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return queryOptions<${TData}, ${TError}, ${TData}>({
-       ${enabledText}
+      return queryOptions<${TData}, ${TError}, ${TData}>({${enabledText ? `\n       ${enabledText}` : ""}
        queryKey,
        queryFn: async ({ signal }) => {
-          return ${clientName}(${addToValueCalls$1(clientCallStr)})
+          return ${clientName}(${addToValueCalls$1(clientCallStr, enabledNames)})
        },
       })
 `
@@ -735,30 +755,31 @@ function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, para
 * Handles both inline params (`petId, config`) and object shorthand
 * params (`{ petId }, config`) by expanding to `{ petId: toValue(petId) }`.
 */
-function addToValueCalls$1(callStr) {
+function addToValueCalls$1(callStr, enabledNames = []) {
+	const optional = new Set(enabledNames);
 	let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner) => {
 		if (inner.includes(":") || inner.includes("...")) return match;
-		return `{ ${inner.split(",").map((k) => k.trim()).filter(Boolean).map((k) => `${k}: toValue(${k})`).join(", ")} }`;
+		return `{ ${inner.split(",").map((k) => k.trim()).filter(Boolean).map((k) => `${k}: toValue(${optional.has(k) ? `${k}!` : k})`).join(", ")} }`;
 	});
 	result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name) => {
 		if (name === "config" || name === "signal" || name === "undefined") return match;
 		if (match.includes("toValue(")) return match;
-		return `toValue(${name})`;
+		return `toValue(${optional.has(name) ? `${name}!` : name})`;
 	});
 	return result;
 }
 __name(addToValueCalls$1, "addToValueCalls");
-QueryOptions.getParams = getQueryOptionsParams;
 //#endregion
 //#region src/components/InfiniteQuery.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 const callPrinter$3 = functionPrinter({ mode: "call" });
-function getParams$2(node, options) {
+function buildInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
 	const errorNames = resolveErrorNames(node, resolver);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const optionsParam = ast.createFunctionParameter({
 		name: "options",
@@ -777,59 +798,19 @@ function getParams$2(node, options) {
 		}),
 		default: "{}"
 	});
-	return wrapOperationParamsWithMaybeRef$1(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver,
 		extraParams: [optionsParam]
-	}));
+	}), (name) => name === "options");
 }
-__name(getParams$2, "getParams");
-function wrapOperationParamsWithMaybeRef$1(paramsNode) {
-	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType$2(p.type)}>`
-					}) : p.type
-				}))
-			};
-		}
-		const fp = param;
-		if (fp.name === "options") return fp;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$2(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	return ast.createFunctionParameters({ params: wrappedParams });
-}
-__name(wrapOperationParamsWithMaybeRef$1, "wrapOperationParamsWithMaybeRef");
-function printType$2(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$2(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-__name(printType$2, "printType");
 function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const returnType = `UseInfiniteQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
 	const generics = [
@@ -837,12 +818,13 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		`TQueryData = ${TData}`,
 		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
 	];
-	const queryKeyParamsNode = QueryKey.getParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
 	});
 	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
+	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
 	const queryOptionsParamsNode = getQueryOptionsParams(node, {
 		paramsType,
 		paramsCasing,
@@ -850,13 +832,13 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		resolver: tsResolver
 	});
 	const queryOptionsParamsCall = callPrinter$3.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = getParams$2(node, {
+	const paramsNode = markParamsOptional(buildInfiniteQueryParamsNode(node, {
 		paramsType,
 		paramsCasing,
 		pathParamsType,
 		dataReturnType,
 		resolver: tsResolver
-	});
+	}), enabledNames);
 	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -867,7 +849,7 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 			export: true,
 			generics: generics.join(", "),
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node) },
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
@@ -886,14 +868,14 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		})
 	});
 }
-InfiniteQuery.getParams = getParams$2;
 //#endregion
 //#region src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$2 = functionPrinter({ mode: "call" });
 function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, paramsCasing, paramsType, dataReturnType, pathParamsType, queryParam, queryKeyName }) {
-	const responseName = tsResolver.resolveResponseName(node);
-	const queryFnDataType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const queryFnDataType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
@@ -901,59 +883,48 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 		const parts = initialPageParam.split(" as ");
 		return parts[parts.length - 1] ?? "unknown";
 	})() : "string" : typeof initialPageParam === "boolean" ? "boolean" : "unknown";
-	const rawQueryParams = node.parameters.filter((p) => p.in === "query");
+	const rawQueryParams = getOperationParameters(node).query;
 	const queryParamsTypeName = rawQueryParams.length > 0 ? (() => {
 		const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]);
-		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : void 0;
-	})() : void 0;
-	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : void 0;
+		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : null;
+	})() : null;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
 	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
-	const paramsNode = getQueryOptionsParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
+	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
+	const enabledText = enabledNames.length ? `enabled: () => ${enabledNames.map((n) => `!!toValue(${n})`).join(" && ")},` : "";
+	const paramsNode = markParamsOptional(getQueryOptionsParams(node, {
 		paramsType,
 		paramsCasing,
 		pathParamsType,
 		resolver: tsResolver
-	});
+	}), enabledNames);
 	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
 	const clientCallStr = (callPrinter$2.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
-	const queryKeyParamsNode = QueryKey.getParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
-	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
-	const enabledText = enabledSource ? `enabled: () => !!(${enabledSource}),` : "";
-	const hasNewParams = nextParam !== void 0 || previousParam !== void 0;
-	let getNextPageParamExpr;
-	let getPreviousPageParamExpr;
-	if (hasNewParams) {
-		if (nextParam) {
-			const accessor = getNestedAccessor(nextParam, "lastPage");
-			if (accessor) getNextPageParamExpr = `getNextPageParam: (lastPage) => ${accessor}`;
+	const hasNewParams = nextParam != null || previousParam != null;
+	const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
+		if (hasNewParams) {
+			const nextAccessor = nextParam ? getNestedAccessor(nextParam, "lastPage") : null;
+			const prevAccessor = previousParam ? getNestedAccessor(previousParam, "firstPage") : null;
+			return [nextAccessor ? `getNextPageParam: (lastPage) => ${nextAccessor}` : null, prevAccessor ? `getPreviousPageParam: (firstPage) => ${prevAccessor}` : null];
 		}
-		if (previousParam) {
-			const accessor = getNestedAccessor(previousParam, "firstPage");
-			if (accessor) getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => ${accessor}`;
-		}
-	} else if (cursorParam) {
-		getNextPageParamExpr = `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`;
-		getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`;
-	} else {
-		if (dataReturnType === "full") getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1";
-		else getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1";
-		getPreviousPageParamExpr = "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1";
-	}
+		if (cursorParam) return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`];
+		return [dataReturnType === "full" ? "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1" : "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1", "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1"];
+	})();
 	const queryOptionsArr = [
 		`initialPageParam: ${typeof initialPageParam === "string" ? JSON.stringify(initialPageParam) : initialPageParam}`,
 		getNextPageParamExpr,
 		getPreviousPageParamExpr
 	].filter(Boolean);
-	const infiniteOverrideParams = queryParam && queryParamsTypeName ? `
-          params = {
-            ...(params ?? {}),
-            ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
-          } as ${queryParamsTypeName}` : "";
+	const infiniteOverrideParams = queryParam && queryParamsTypeName ? `params = {
+      ...(params ?? {}),
+      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
+    } as ${queryParamsTypeName}` : "";
 	if (infiniteOverrideParams) return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -963,16 +934,15 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 			export: true,
 			params: paramsSignature,
 			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({
-       ${enabledText}
-       queryKey,
-       queryFn: async ({ signal, pageParam }) => {
-          ${infiniteOverrideParams}
-          return ${clientName}(${addToValueCalls(clientCallStr)})
-        },
-       ${queryOptionsArr.join(",\n")}
-      })
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
+  queryKey,
+  queryFn: async ({ signal, pageParam }) => {
+    ${infiniteOverrideParams}
+    return ${clientName}(${addToValueCalls(clientCallStr, enabledNames)})
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
 `
 		})
 	});
@@ -985,58 +955,55 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 			export: true,
 			params: paramsSignature,
 			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({
-       ${enabledText}
-       queryKey,
-       queryFn: async ({ signal }) => {
-          return ${clientName}(${addToValueCalls(clientCallStr)})
-        },
-       ${queryOptionsArr.join(",\n")}
-      })
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
+  queryKey,
+  queryFn: async ({ signal }) => {
+    return ${clientName}(${addToValueCalls(clientCallStr, enabledNames)})
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
 `
 		})
 	});
 }
-function addToValueCalls(callStr) {
+function addToValueCalls(callStr, enabledNames = []) {
+	const optional = new Set(enabledNames);
 	let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner) => {
 		if (inner.includes(":") || inner.includes("...")) return match;
-		return `{ ${inner.split(",").map((k) => k.trim()).filter(Boolean).map((k) => `${k}: toValue(${k})`).join(", ")} }`;
+		return `{ ${inner.split(",").map((k) => k.trim()).filter(Boolean).map((k) => `${k}: toValue(${optional.has(k) ? `${k}!` : k})`).join(", ")} }`;
 	});
 	result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name) => {
 		if (name === "config" || name === "signal" || name === "undefined") return match;
 		if (match.includes("toValue(")) return match;
-		return `toValue(${name})`;
+		return `toValue(${optional.has(name) ? `${name}!` : name})`;
 	});
 	return result;
 }
-InfiniteQueryOptions.getParams = (node, options) => getQueryOptionsParams(node, options);
 //#endregion
 //#region src/components/Mutation.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 const callPrinter$1 = functionPrinter({ mode: "call" });
 const keysPrinter = functionPrinter({ mode: "keys" });
-function getParams$1(node, options) {
+function createMutationArgParams(node, options) {
+	return ast.createOperationParams(node, {
+		paramsType: "inline",
+		pathParamsType: "inline",
+		paramsCasing: options.paramsCasing,
+		resolver: options.resolver
+	});
+}
+function buildMutationParamsNode(node, options) {
 	const { paramsCasing, dataReturnType, resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, resolver);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const mutationArgWrapped = buildMutationArgParams(node, {
+	const wrappedParamsNode = wrapWithMaybeRefOrGetter(createMutationArgParams(node, {
 		paramsCasing,
 		resolver
-	}).params.map((param) => {
-		const fp = param;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$1(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	const wrappedParamsNode = ast.createFunctionParameters({ params: mutationArgWrapped });
+	}));
 	const TRequestWrapped = wrappedParamsNode.params.length > 0 ? declarationPrinter$1.print(wrappedParamsNode) ?? "" : "";
 	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
 		name: "options",
@@ -1046,34 +1013,22 @@ function getParams$1(node, options) {
   mutation?: MutationObserverOptions<${[
 				TData,
 				TError,
-				TRequestWrapped ? `{${TRequestWrapped}}` : "void",
+				TRequestWrapped ? `{${TRequestWrapped}}` : "undefined",
 				"TContext"
 			].join(", ")}> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
+  client?: ${buildRequestConfigType(node, resolver)},
 }`
 		}),
 		default: "{}"
 	})] });
 }
-__name(getParams$1, "getParams");
-function printType$1(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$1(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-__name(printType$1, "printType");
 function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType, dataReturnType, node, tsResolver, mutationKeyName }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const mutationArgParamsNode = buildMutationArgParams(node, {
+	const mutationArgParamsNode = createMutationArgParams(node, {
 		paramsCasing,
 		resolver: tsResolver
 	});
@@ -1083,10 +1038,10 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 	const generics = [
 		TData,
 		TError,
-		TRequest ? `{${TRequest}}` : "void",
+		TRequest ? `{${TRequest}}` : "undefined",
 		"TContext"
 	].join(", ");
-	const mutationKeyParamsNode = MutationKey.getParams();
+	const mutationKeyParamsNode = ast.createFunctionParameters({ params: [] });
 	const mutationKeyParamsCall = callPrinter$1.print(mutationKeyParamsNode) ?? "";
 	const clientCallParamsNode = ast.createOperationParams(node, {
 		paramsType,
@@ -1097,13 +1052,13 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 			name: "config",
 			type: ast.createParamsType({
 				variant: "reference",
-				name: node.requestBody?.content?.[0]?.schema ? `Partial<RequestConfig<${tsResolver.resolveDataName(node)}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+				name: buildRequestConfigType(node, tsResolver)
 			}),
 			default: "{}"
 		})]
 	});
 	const clientCallStr = callPrinter$1.print(clientCallParamsNode) ?? "";
-	const paramsNode = getParams$1(node, {
+	const paramsNode = buildMutationParamsNode(node, {
 		paramsCasing,
 		dataReturnType,
 		resolver: tsResolver
@@ -1117,7 +1072,7 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 			name,
 			export: true,
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node) },
 			generics: ["TContext"],
 			children: `
         const { mutation = {}, client: config = {} } = options ?? {}
@@ -1135,17 +1090,17 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 		})
 	});
 }
-Mutation.getParams = getParams$1;
 //#endregion
 //#region src/components/Query.tsx
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 const callPrinter = functionPrinter({ mode: "call" });
-function getParams(node, options) {
+function buildQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
 	const errorNames = resolveErrorNames(node, resolver);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const optionsParam = ast.createFunctionParameter({
 		name: "options",
@@ -1164,56 +1119,19 @@ function getParams(node, options) {
 		}),
 		default: "{}"
 	});
-	return wrapOperationParamsWithMaybeRef(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver,
 		extraParams: [optionsParam]
-	}));
-}
-function wrapOperationParamsWithMaybeRef(paramsNode) {
-	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType(p.type)}>`
-					}) : p.type
-				}))
-			};
-		}
-		const fp = param;
-		if (fp.name === "options") return fp;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	return ast.createFunctionParameters({ params: wrappedParams });
-}
-function printType(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
+	}), (name) => name === "options");
 }
 function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const returnType = `UseQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
 	const generics = [
@@ -1221,12 +1139,13 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		`TQueryData = ${TData}`,
 		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
 	];
-	const queryKeyParamsNode = QueryKey.getParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
 	});
 	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
+	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
 	const queryOptionsParamsNode = getQueryOptionsParams(node, {
 		paramsType,
 		paramsCasing,
@@ -1234,13 +1153,13 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		resolver: tsResolver
 	});
 	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = getParams(node, {
+	const paramsNode = markParamsOptional(buildQueryParamsNode(node, {
 		paramsType,
 		paramsCasing,
 		pathParamsType,
 		dataReturnType,
 		resolver: tsResolver
-	});
+	}), enabledNames);
 	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -1251,7 +1170,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 			export: true,
 			generics: generics.join(", "),
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node) },
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
@@ -1270,8 +1189,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		})
 	});
 }
-Query.getParams = getParams;
 //#endregion
-export { QueryOptions as a, MutationKey as c, InfiniteQuery as i, camelCase as l, Mutation as n, QueryKey as o, InfiniteQueryOptions as r, transformName as s, Query as t };
+export { QueryOptions as a, resolveZodSchemaNames as c, getOperationParameters as d, operationFileEntry as f, InfiniteQuery as i, MutationKey as l, camelCase as m, Mutation as n, QueryKey as o, resolveOperationTypeNames as p, InfiniteQueryOptions as r, queryKeyTransformer as s, Query as t, mutationKeyTransformer as u };
 
-//# sourceMappingURL=components-D1UhYFgY.js.map
+//# sourceMappingURL=components-B79Gljyl.js.map