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

package/dist/{components-IArDg-DO.js → components-Ds-e_nnK.js}

@@ -1,5 +1,6 @@
 import "./chunk-C0LytTxp.js";
 import { ast } from "@kubb/core";
+import { buildGroupParam, caseParams, createOperationParams, getNestedAccessor, resolveGroupType, resolveParamType } from "@kubb/ast/utils";
 import { functionPrinter } from "@kubb/plugin-ts";
 import { File, Function, Type } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
@@ -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$10 = 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$10.print(paramsNode) ?? "";
 	const keys = (transformer ?? mutationKeyTransformer)({
 		node,
@@ -460,6 +381,35 @@ function MutationKey({ name, paramsCasing, node, transformer }) {
 }
 //#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
+/**
+* Returns the `TypeLiteral` members of a destructured group parameter, or `null`
+* for a plain named parameter.
+*/
+function groupMembers(param) {
+	if (typeof param.name === "string") return null;
+	return param.type && typeof param.type !== "string" && param.type.kind === "TypeLiteral" ? param.type.members : [];
+}
+/**
+* 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 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: "{}"
+		})]
+	});
+}
 function matchesPattern(node, ov) {
 	const { type, pattern } = ov;
 	const matches = (value) => typeof pattern === "string" ? value === pattern : pattern.test(value);
@@ -483,116 +433,97 @@ function resolveOperationOverrides(node, override) {
 	return override.find((ov) => matchesPattern(node, ov))?.options ?? {};
 }
 /**
-* 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 `'zod'` when response-direction parsing is enabled.
+* The string shorthand `'zod'` also enables response parsing.
 */
-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 resolveResponseParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.response ?? null;
 }
 /**
-* 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).
+* Returns `'zod'` when request body parsing is enabled.
+* The string shorthand `'zod'` also enables request body parsing (existing behavior).
 */
-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 resolveRequestParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.request ?? null;
 }
 /**
-* 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 query-params parsing is enabled.
+* Only the object form `{ request: 'zod' }` enables this. `parser: 'zod'` does not.
 */
-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 resolveQueryParamsParser(parser) {
+	if (!parser || parser === "zod") return null;
+	return parser.request ?? null;
 }
 /**
-* Build a single `FunctionParameterNode` for a query or header group.
+* 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 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 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`
@@ -601,12 +532,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;
 }
@@ -622,27 +552,25 @@ 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 });
 }
 /**
 * Add a non-null assertion (`!`) to the named params inside a printed client-call
@@ -669,13 +597,13 @@ function injectNonNullAssertions(callStr, names) {
 const declarationPrinter$9 = 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
@@ -718,28 +646,13 @@ function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeNa
 const declarationPrinter$8 = functionPrinter({ mode: "declaration" });
 const callPrinter$8 = 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 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: "{}"
-		})]
-	});
+	return buildQueryOptionsParams(node, options);
 }
 function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName, suspense }) {
 	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 = buildQueryKeyParams(node, {
 		pathParamsType,
@@ -768,8 +681,7 @@ function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, para
 			params: paramsSignature,
 			children: `
       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return queryOptions<${TData}, ${TError}, ${TData}, typeof queryKey>({
-       ${enabledText}
+      return queryOptions<${TData}, ${TError}, ${TData}, typeof queryKey>({${enabledText ? `\n       ${enabledText}` : ""}
        queryKey,
        queryFn: async ({ signal }) => {
           return ${clientName}(${clientCallStr})
@@ -786,18 +698,15 @@ const callPrinter$7 = functionPrinter({ mode: "call" });
 function buildInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = ast.createFunctionParameter({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -809,7 +718,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 responseType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const responseType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
 	const fallbackPageParamType = typeof initialPageParam === "number" ? "number" : typeof initialPageParam === "string" ? initialPageParam.includes(" as ") ? (() => {
@@ -868,11 +777,10 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
-       ${customOptions ? `const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
 
        const query = useInfiniteQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n...customOptions," : ""}
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
         ...resolvedOptions,
         queryKey,
        } as unknown as InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
@@ -891,7 +799,7 @@ const callPrinter$6 = 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;
@@ -937,11 +845,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,
@@ -951,16 +858,15 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 			export: true,
 			params: paramsSignature,
 			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
-       ${enabledText}
-       queryKey,
-       queryFn: async ({ signal, pageParam }) => {
-          ${infiniteOverrideParams}
-          return ${clientName}(${clientCallStr})
-        },
-       ${queryOptionsArr.join(",\n")}
-      })
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
+  queryKey,
+  queryFn: async ({ signal, pageParam }) => {
+    ${infiniteOverrideParams}
+    return ${clientName}(${clientCallStr})
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
 `
 		})
 	});
@@ -973,15 +879,14 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 			export: true,
 			params: paramsSignature,
 			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
-       ${enabledText}
-       queryKey,
-       queryFn: async ({ signal }) => {
-          return ${clientName}(${clientCallStr})
-        },
-       ${queryOptionsArr.join(",\n")}
-      })
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
+  queryKey,
+  queryFn: async ({ signal }) => {
+    return ${clientName}(${clientCallStr})
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
 `
 		})
 	});
@@ -990,26 +895,23 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 //#region src/components/MutationOptions.tsx
 const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
 const callPrinter$5 = functionPrinter({ mode: "call" });
-const keysPrinter = functionPrinter({ mode: "keys" });
+const keysPrinter = functionPrinter({ mode: "call" });
 function buildMutationConfigParamsNode(node, resolver) {
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+	return ast.factory.createFunctionParameters({ params: [ast.factory.createFunctionParameter({
 		name: "config",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: buildRequestConfigType(node, resolver)
-		}),
+		type: buildRequestConfigType(node, resolver),
 		default: "{}"
 	})] });
 }
 function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, mutationKeyName }) {
 	const successNames = resolveSuccessNames(node, tsResolver);
 	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const configParamsNode = buildMutationConfigParamsNode(node, tsResolver);
 	const paramsSignature = declarationPrinter$5.print(configParamsNode) ?? "";
-	const mutationArgParamsNode = ast.createOperationParams(node, {
+	const mutationArgParamsNode = createOperationParams(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing,
@@ -1018,17 +920,14 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 	const hasMutationParams = mutationArgParamsNode.params.length > 0;
 	const TRequest = hasMutationParams ? declarationPrinter$5.print(mutationArgParamsNode) ?? "" : "";
 	const argKeysStr = hasMutationParams ? keysPrinter.print(mutationArgParamsNode) ?? "" : "";
-	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: "{}"
 		})]
 	});
@@ -1059,7 +958,7 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
 const callPrinter$4 = functionPrinter({ mode: "call" });
 function createMutationArgParams(node, options) {
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing: options.paramsCasing,
@@ -1071,7 +970,7 @@ 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 mutationArgParamsNode = createMutationArgParams(node, {
 		paramsCasing,
@@ -1084,15 +983,12 @@ function buildMutationParamsNode(node, options) {
 		TRequest ? `{${TRequest}}` : "undefined",
 		"TContext"
 	].join(", ");
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+	return ast.factory.createFunctionParameters({ params: [ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
   client?: ${buildRequestConfigType(node, resolver)},
-}`
-		}),
+}`,
 		default: "{}"
 	})] });
 }
@@ -1100,7 +996,7 @@ function Mutation({ name, mutationOptionsName, paramsCasing, dataReturnType, nod
 	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,
@@ -1137,11 +1033,10 @@ function Mutation({ name, mutationOptionsName, paramsCasing, dataReturnType, nod
         const { client: queryClient, ...mutationOptions } = mutation;
         const mutationKey = mutationOptions.mutationKey ?? ${mutationKeyName}()
 
-        const baseOptions = ${mutationOptionsName}(${mutationOptionsParamsCall}) as UseMutationOptions<${generics}>
-        ${customOptions ? `const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' }) as UseMutationOptions<${generics}>` : ""}
+        const baseOptions = ${mutationOptionsName}(${mutationOptionsParamsCall}) as UseMutationOptions<${generics}>${customOptions ? `\n        const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' }) as UseMutationOptions<${generics}>` : ""}
 
         return useMutation<${generics}>({
-          ...baseOptions,${customOptions ? "\n...customOptions," : ""}
+          ...baseOptions,${customOptions ? "\n          ...customOptions," : ""}
           mutationKey,
           ...mutationOptions,
         }, queryClient) as ${returnType}
@@ -1159,26 +1054,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<QueryObserverOptions<${[
-				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 ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1190,7 +1082,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 returnType = `UseQueryResult<TData, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}> & { queryKey: TQueryKey }`;
 	const generics = [
 		`TData = ${TData}`,
@@ -1233,11 +1125,10 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
-       ${customOptions ? `const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
 
        const query = useQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n...customOptions," : ""}
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
         ...resolvedOptions,
         queryKey,
        } as unknown as QueryObserverOptions, queryClient) as ${returnType}
@@ -1256,18 +1147,15 @@ const callPrinter$2 = functionPrinter({ mode: "call" });
 function buildSuspenseInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = ast.createFunctionParameter({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1279,7 +1167,7 @@ function SuspenseInfiniteQuery({ name, queryKeyTypeName, queryOptionsName, query
 	const successNames = resolveSuccessNames(node, tsResolver);
 	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
-	const responseType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const responseType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
 	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
 	const fallbackPageParamType = typeof initialPageParam === "number" ? "number" : typeof initialPageParam === "string" ? initialPageParam.includes(" as ") ? (() => {
@@ -1337,11 +1225,10 @@ function SuspenseInfiniteQuery({ name, queryKeyTypeName, queryOptionsName, query
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
-       ${customOptions ? `const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
 
        const query = useSuspenseInfiniteQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n...customOptions," : ""}
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
         ...resolvedOptions,
         queryKey,
        } as unknown as UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
@@ -1360,7 +1247,7 @@ const callPrinter$1 = functionPrinter({ mode: "call" });
 function SuspenseInfiniteQueryOptions({ 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;
@@ -1404,11 +1291,10 @@ function SuspenseInfiniteQueryOptions({ name, clientName, initialPageParam, curs
 		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,
@@ -1418,15 +1304,15 @@ function SuspenseInfiniteQueryOptions({ name, clientName, initialPageParam, curs
 			export: true,
 			params: paramsSignature,
 			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
-       queryKey,
-       queryFn: async ({ signal, pageParam }) => {
-          ${infiniteOverrideParams}
-          return ${clientName}(${clientCallStr})
-        },
-       ${queryOptionsArr.join(",\n")}
-      })
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
+  queryKey,
+  queryFn: async ({ signal, pageParam }) => {
+    ${infiniteOverrideParams}
+    return ${clientName}(${clientCallStr})
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
 `
 		})
 	});
@@ -1439,14 +1325,14 @@ function SuspenseInfiniteQueryOptions({ name, clientName, initialPageParam, curs
 			export: true,
 			params: paramsSignature,
 			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
-       queryKey,
-       queryFn: async ({ signal }) => {
-          return ${clientName}(${clientCallStr})
-        },
-       ${queryOptionsArr.join(",\n")}
-     })
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
+  queryKey,
+  queryFn: async ({ signal }) => {
+    return ${clientName}(${clientCallStr})
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
 `
 		})
 	});
@@ -1461,25 +1347,22 @@ function buildSuspenseQueryParamsNode(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<UseSuspenseQueryOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1491,7 +1374,7 @@ function SuspenseQuery({ 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 returnType = `UseSuspenseQueryResult<TData, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}> & { queryKey: TQueryKey }`;
 	const generics = [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`];
 	const queryKeyParamsNode = buildQueryKeyParams(node, {
@@ -1529,11 +1412,10 @@ function SuspenseQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
-       ${customOptions ? `const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
 
        const query = useSuspenseQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n...customOptions," : ""}
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
         ...resolvedOptions,
         queryKey,
        } as unknown as UseSuspenseQueryOptions, queryClient) as ${returnType}
@@ -1548,4 +1430,4 @@ function SuspenseQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 //#endregion
 export { operationFileEntry as _, Mutation as a, InfiniteQuery as c, queryKeyTransformer as d, resolveOperationOverrides as f, getOperationParameters as g, mutationKeyTransformer as h, Query as i, QueryOptions as l, MutationKey as m, SuspenseInfiniteQueryOptions as n, MutationOptions as o, resolveZodSchemaNames as p, SuspenseInfiniteQuery as r, InfiniteQueryOptions as s, SuspenseQuery as t, QueryKey as u, resolveOperationTypeNames as v, camelCase as y };
 
-//# sourceMappingURL=components-IArDg-DO.js.map
+//# sourceMappingURL=components-Ds-e_nnK.js.map