@kubb/plugin-vue-query 5.0.0-beta.42 → 5.0.0-beta.64

package/dist/{components-Bxe1EuWf.js → components-CAlEf7Oh.js}

@@ -1,6 +1,7 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
 import { ast } from "@kubb/core";
-import { functionPrinter } from "@kubb/plugin-ts";
+import { buildGroupParam, caseParams, createOperationParams, getNestedAccessor, resolveGroupType, resolveParamType } from "@kubb/ast/utils";
+import { functionPrinter, renderType } from "@kubb/plugin-ts";
 import { File, Function, Type } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
@@ -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 `null` 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         // null
-	* ```
-	*/
-	get params() {
-		return this.toParamsObject();
-	}
-	#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.toParamsObject()
+			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,50 +216,6 @@ 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 } = {}) {
-		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* 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}').toParamsObject()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	toParamsObject(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : null;
-	}
-	/** 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/shared/src/operation.ts
@@ -333,7 +241,7 @@ function operationFileEntry(node, name, extname = ".ts") {
 function getOperationLink(node, link) {
 	if (!link) return null;
 	if (typeof link === "function") return link(node) ?? null;
-	if (link === "urlPath") return node.path ? `{@link ${new URLPath(node.path).URL}}` : null;
+	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
 	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
 }
 function getContentTypeInfo(node) {
@@ -370,7 +278,7 @@ function buildOperationComments(node, options = {}) {
 	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);
+	const params = caseParams(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -399,6 +307,19 @@ function resolveSuccessNames(node, resolver) {
 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(",")}`;
@@ -434,12 +355,12 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 //#endregion
 //#region ../../internals/tanstack-query/src/components/MutationKey.tsx
 const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
-const mutationKeyTransformer = ({ node, casing }) => {
+const mutationKeyTransformer = ({ node }) => {
 	if (!node.path) return [];
-	return [`{ url: '${new URLPath(node.path, { casing }).toURLPath()}' }`];
+	return [`{ url: '${Url.toPath(node.path)}' }`];
 };
 function MutationKey({ name, paramsCasing, node, transformer }) {
-	const paramsNode = ast.createFunctionParameters({ params: [] });
+	const paramsNode = ast.factory.createFunctionParameters({ params: [] });
 	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
 	const keys = (transformer ?? mutationKeyTransformer)({
 		node,
@@ -461,116 +382,126 @@ function MutationKey({ name, paramsCasing, node, transformer }) {
 //#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
 /**
-* Collects the Zod schema import names for an operation (response + request body).
-*
-* Returns an empty array when no resolver is provided or the operation has no request body schema.
+* Returns the `TypeLiteral` members of a destructured group parameter, or `null`
+* for a plain named parameter.
 */
-function resolveZodSchemaNames(node, zodResolver) {
-	if (!zodResolver) return [];
-	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter((n) => Boolean(n));
+function groupMembers(param) {
+	if (typeof param.name === "string") return null;
+	return param.type && typeof param.type !== "string" && param.type.kind === "TypeLiteral" ? param.type.members : [];
 }
 /**
-* Resolve the type for a single path parameter.
-*
-* - When the resolver's group name differs from the individual param name
-*   (e.g. kubbV4) → `GroupName['paramName']` (member access).
-* - When they match (v5 default) → `TypeName` (direct reference).
+* 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 resolvePathParamType(node, param, resolver) {
-	const individualName = resolver.resolveParamName(node, param);
-	const groupName = resolver.resolvePathParamsName(node, param);
-	if (groupName !== individualName) return ast.createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return ast.createParamsType({
-		variant: "reference",
-		name: individualName
+function buildQueryOptionsParams(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	return createOperationParams(node, {
+		paramsType,
+		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
+		paramsCasing,
+		resolver,
+		extraParams: [ast.factory.createFunctionParameter({
+			name: "config",
+			type: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
+			default: "{}"
+		})]
 	});
 }
 /**
-* Derive a query-params group type from the resolver.
-* Returns `null` when no query params exist or when the group name
-* equals the individual param name (no real group).
+* Returns `'zod'` when response-direction parsing is enabled.
+* The string shorthand `'zod'` also enables response parsing.
 */
-function resolveQueryGroupType(node, params, resolver) {
-	if (!params.length) return null;
-	const firstParam = params[0];
-	const groupName = resolver.resolveQueryParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: ast.createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: params.every((p) => !p.required)
-	};
+function resolveResponseParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.response ?? null;
 }
 /**
-* Build a single `FunctionParameterNode` for a query or header group.
+* Returns `'zod'` when request body parsing is enabled.
+* The string shorthand `'zod'` also enables request body parsing (existing behavior).
 */
-function buildGroupParam(name, node, params, groupType, resolver) {
-	if (groupType) return [ast.createFunctionParameter({
-		name,
-		type: groupType.type,
-		optional: groupType.optional
-	})];
-	if (params.length) {
-		const structProps = params.map((p) => ({
-			name: p.name,
-			type: ast.createParamsType({
-				variant: "reference",
-				name: resolver.resolveParamName(node, p)
-			}),
-			optional: !p.required
-		}));
-		return [ast.createFunctionParameter({
-			name,
-			type: ast.createParamsType({
-				variant: "struct",
-				properties: structProps
-			}),
-			optional: params.every((p) => !p.required)
-		})];
-	}
-	return [];
+function resolveRequestParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.request ?? null;
+}
+/**
+* Returns `'zod'` when query-params parsing is enabled.
+* Only the object form `{ request: 'zod' }` enables this. `parser: 'zod'` does not.
+*/
+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));
 }
 /**
 * Build QueryKey params: pathParams + data + queryParams (NO headers, NO config).
 */
 function buildQueryKeyParams(node, options) {
 	const { pathParamsType, paramsCasing, resolver } = options;
-	const casedParams = ast.caseParams(node.parameters, paramsCasing);
+	const casedParams = caseParams(node.parameters, paramsCasing);
 	const pathParams = casedParams.filter((p) => p.in === "path");
 	const queryParams = casedParams.filter((p) => p.in === "query");
-	const queryGroupType = resolveQueryGroupType(node, queryParams, resolver);
-	const bodyType = node.requestBody?.content?.[0]?.schema ? ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : null;
+	const queryGroupType = resolveGroupType({
+		node,
+		params: queryParams,
+		group: "query",
+		resolver
+	});
+	const bodyType = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
 	const bodyRequired = node.requestBody?.required ?? false;
 	const params = [];
 	if (pathParams.length) {
-		const pathChildren = pathParams.map((p) => ast.createFunctionParameter({
+		const pathChildren = pathParams.map((p) => ({
 			name: p.name,
-			type: resolvePathParamType(node, p, resolver),
+			type: resolveParamType({
+				node,
+				param: p,
+				resolver
+			}),
 			optional: !p.required
 		}));
-		params.push({
-			kind: "ParameterGroup",
+		if (pathParamsType === "object") params.push(ast.factory.createFunctionParameter({
 			properties: pathChildren,
-			inline: pathParamsType === "inline",
 			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
-		});
+		}));
+		else params.push(...pathChildren.map((child) => ast.factory.createFunctionParameter(child)));
 	}
-	if (bodyType) params.push(ast.createFunctionParameter({
+	if (bodyType) params.push(ast.factory.createFunctionParameter({
 		name: "data",
 		type: bodyType,
 		optional: !bodyRequired
 	}));
-	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
-	return ast.createFunctionParameters({ params });
+	params.push(...buildGroupParam({
+		name: "params",
+		node,
+		params: queryParams,
+		groupType: queryGroupType,
+		resolver,
+		wrapType: (type) => type
+	}));
+	return ast.factory.createFunctionParameters({ params });
 }
 /**
 * Collect the names of the required params (no default) that drive the `enabled`
@@ -579,12 +510,11 @@ function buildQueryKeyParams(node, options) {
 */
 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);
+	for (const param of paramsNode.params) {
+		const members = groupMembers(param);
+		if (members) {
+			for (const member of members) if (!member.optional) required.push(member.name);
+		} else if (typeof param.name === "string" && !param.optional && param.default === void 0) required.push(param.name);
 	}
 	return required;
 }
@@ -600,38 +530,36 @@ 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;
+		const members = groupMembers(param);
+		if (members) {
+			const next = members.map((member) => nameSet.has(member.name) ? {
+				...member,
+				optional: true
+			} : member);
 			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)
+				...param,
+				type: ast.factory.createTypeLiteral({ members: next })
 			};
 		}
-		const fp = param;
-		return nameSet.has(fp.name) ? ast.createFunctionParameter({
-			name: fp.name,
-			type: fp.type,
-			rest: fp.rest,
+		return typeof param.name === "string" && nameSet.has(param.name) ? ast.factory.createFunctionParameter({
+			name: param.name,
+			type: param.type,
+			rest: param.rest,
 			optional: true
-		}) : fp;
+		}) : param;
 	});
-	return ast.createFunctionParameters({ params });
+	return ast.factory.createFunctionParameters({ params });
 }
 functionPrinter({ mode: "declaration" });
 const queryKeyTransformer = ({ node, casing }) => {
 	if (!node.path) return [];
-	const path = new URLPath(node.path, { casing });
 	const hasQueryParams = getOperationParameters(node).query.length > 0;
 	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
 	return [
-		path.toObject({
+		Url.toObject(node.path, {
 			type: "path",
-			stringify: true
+			stringify: true,
+			casing
 		}),
 		hasQueryParams ? "...(params ? [params] : [])" : null,
 		hasRequestBody ? "...(data ? [data] : [])" : null
@@ -639,43 +567,31 @@ const queryKeyTransformer = ({ node, casing }) => {
 };
 //#endregion
 //#region src/utils.ts
-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";
-}
+/**
+* Wraps each parameter type in `MaybeRefOrGetter<…>` so a vue-query signature
+* accepts refs or getters. Group members are wrapped individually; `skip` opts a
+* plain parameter out by name.
+*/
 function wrapWithMaybeRefOrGetter(paramsNode, skip) {
 	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
-				}))
+		if (typeof param.name !== "string") {
+			const type = param.type;
+			if (type && typeof type !== "string" && type.kind === "TypeLiteral") return {
+				...param,
+				type: ast.factory.createTypeLiteral({ members: type.members.map((member) => ({
+					...member,
+					type: `MaybeRefOrGetter<${renderType(member.type)}>`
+				})) })
 			};
+			return param;
 		}
-		const fp = param;
-		if (skip?.(fp.name)) return fp;
+		if (skip?.(param.name)) return param;
 		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType(fp.type)}>`
-			}) : fp.type
+			...param,
+			type: param.type ? `MaybeRefOrGetter<${renderType(param.type)}>` : param.type
 		};
 	});
-	return ast.createFunctionParameters({ params: wrappedParams });
+	return ast.factory.createFunctionParameters({ params: wrappedParams });
 }
 //#endregion
 //#region src/components/QueryKey.tsx
@@ -723,28 +639,13 @@ function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeNa
 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) : null;
-	return wrapWithMaybeRefOrGetter(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: "{}"
-		})]
-	}), (name) => name === "config");
+	return wrapWithMaybeRefOrGetter(buildQueryOptionsParams(node, options), (name) => name === "config");
 }
 function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
 	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 queryKeyParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
@@ -772,8 +673,7 @@ 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, enabledNames)})
@@ -814,26 +714,23 @@ function buildInfiniteQueryParamsNode(node, options) {
 	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({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<UseInfiniteQueryOptions<${[
-				TData,
-				TError,
-				"TQueryData",
-				"TQueryKey",
-				"TQueryData"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TQueryData",
+			"TQueryKey",
+			"TQueryData"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -845,7 +742,7 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 	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 = [
@@ -910,7 +807,7 @@ const callPrinter$2 = functionPrinter({ mode: "call" });
 function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, paramsCasing, paramsType, dataReturnType, pathParamsType, queryParam, queryKeyName }) {
 	const successNames = resolveSuccessNames(node, tsResolver);
 	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const queryFnDataType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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;
@@ -956,11 +853,10 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 		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,
@@ -970,16 +866,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, enabledNames)})
-        },
-       ${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  ")}
+})
 `
 		})
 	});
@@ -992,15 +887,14 @@ 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, enabledNames)})
-        },
-       ${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  ")}
+})
 `
 		})
 	});
@@ -1022,9 +916,9 @@ function addToValueCalls(callStr, enabledNames = []) {
 //#region src/components/Mutation.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 const callPrinter$1 = functionPrinter({ mode: "call" });
-const keysPrinter = functionPrinter({ mode: "keys" });
+const keysPrinter = functionPrinter({ mode: "call" });
 function createMutationArgParams(node, options) {
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing: options.paramsCasing,
@@ -1036,27 +930,24 @@ function buildMutationParamsNode(node, options) {
 	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 wrappedParamsNode = wrapWithMaybeRefOrGetter(createMutationArgParams(node, {
 		paramsCasing,
 		resolver
 	}));
 	const TRequestWrapped = wrappedParamsNode.params.length > 0 ? declarationPrinter$1.print(wrappedParamsNode) ?? "" : "";
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+	return ast.factory.createFunctionParameters({ params: [ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   mutation?: MutationObserverOptions<${[
-				TData,
-				TError,
-				TRequestWrapped ? `{${TRequestWrapped}}` : "undefined",
-				"TContext"
-			].join(", ")}> & { client?: QueryClient },
+			TData,
+			TError,
+			TRequestWrapped ? `{${TRequestWrapped}}` : "undefined",
+			"TContext"
+		].join(", ")}> & { client?: QueryClient },
   client?: ${buildRequestConfigType(node, resolver)},
-}`
-		}),
+}`,
 		default: "{}"
 	})] });
 }
@@ -1064,7 +955,7 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 	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 = createMutationArgParams(node, {
 		paramsCasing,
@@ -1079,19 +970,16 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 		TRequest ? `{${TRequest}}` : "undefined",
 		"TContext"
 	].join(", ");
-	const mutationKeyParamsNode = ast.createFunctionParameters({ params: [] });
+	const mutationKeyParamsNode = ast.factory.createFunctionParameters({ params: [] });
 	const mutationKeyParamsCall = callPrinter$1.print(mutationKeyParamsNode) ?? "";
-	const clientCallParamsNode = ast.createOperationParams(node, {
+	const clientCallParamsNode = createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver: tsResolver,
-		extraParams: [ast.createFunctionParameter({
+		extraParams: [ast.factory.createFunctionParameter({
 			name: "config",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
+			type: buildRequestConfigType(node, tsResolver),
 			default: "{}"
 		})]
 	});
@@ -1138,26 +1026,23 @@ function buildQueryParamsNode(node, options) {
 	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({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<UseQueryOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TData",
+			"TQueryData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1169,7 +1054,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 	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 = [
@@ -1230,4 +1115,4 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 //#endregion
 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-Bxe1EuWf.js.map
+//# sourceMappingURL=components-CAlEf7Oh.js.map