@kubb/plugin-swr 5.0.0-beta.42 → 5.0.0-beta.64

package/dist/{components-CD7ZoS3B.cjs → components-DxWGjLWg.cjs}

@@ -25,6 +25,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let _kubb_core = require("@kubb/core");
+let _kubb_ast_utils = require("@kubb/ast/utils");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
 let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
@@ -39,35 +40,19 @@ let _kubb_renderer_jsx_jsx_runtime = require("@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'
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 //#endregion
@@ -174,99 +159,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(`"`, "");
@@ -275,85 +241,13 @@ 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/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const mutationKeyTransformer = ({ node, casing }) => {
-	if (!node.path) return [];
-	return [`{ url: '${new URLPath(node.path, { casing }).toURLPath()}' }`];
-};
-function MutationKey$1({ name, paramsCasing, node, transformer }) {
-	const paramsNode = _kubb_core.ast.createFunctionParameters({ params: [] });
-	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
-	const keys = (transformer ?? mutationKeyTransformer)({
-		node,
-		casing: paramsCasing
-	});
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function.Arrow, {
-			name,
-			export: true,
-			params: paramsSignature,
-			singleLine: true,
-			children: `[${keys.join(", ")}] as const`
-		})
-	});
-}
-__name(MutationKey$1, "MutationKey");
-//#endregion
 //#region ../../internals/shared/src/operation.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) {
@@ -390,7 +284,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 = _kubb_core.ast.caseParams(node.parameters, options.paramsCasing);
+	const params = (0, _kubb_ast_utils.caseParams)(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -412,6 +306,19 @@ function resolveErrorNames(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(",")}`;
@@ -445,118 +352,156 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 	return result;
 }
 //#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const mutationKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	return [`{ url: '${Url.toPath(node.path)}' }`];
+};
+function MutationKey$1({ name, paramsCasing, node, transformer }) {
+	const paramsNode = _kubb_core.ast.factory.createFunctionParameters({ params: [] });
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
+		node,
+		casing: paramsCasing
+	});
+	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	});
+}
+__name(MutationKey$1, "MutationKey");
+//#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 _kubb_core.ast.createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return _kubb_core.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 (0, _kubb_ast_utils.createOperationParams)(node, {
+		paramsType,
+		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
+		paramsCasing,
+		resolver,
+		extraParams: [_kubb_core.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: _kubb_core.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 [_kubb_core.ast.createFunctionParameter({
-		name,
-		type: groupType.type,
-		optional: groupType.optional
-	})];
-	if (params.length) {
-		const structProps = params.map((p) => ({
-			name: p.name,
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: resolver.resolveParamName(node, p)
-			}),
-			optional: !p.required
-		}));
-		return [_kubb_core.ast.createFunctionParameter({
-			name,
-			type: _kubb_core.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 = _kubb_core.ast.caseParams(node.parameters, paramsCasing);
+	const casedParams = (0, _kubb_ast_utils.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 ? _kubb_core.ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : null;
+	const queryGroupType = (0, _kubb_ast_utils.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) => _kubb_core.ast.createFunctionParameter({
+		const pathChildren = pathParams.map((p) => ({
 			name: p.name,
-			type: resolvePathParamType(node, p, resolver),
+			type: (0, _kubb_ast_utils.resolveParamType)({
+				node,
+				param: p,
+				resolver
+			}),
 			optional: !p.required
 		}));
-		params.push({
-			kind: "ParameterGroup",
+		if (pathParamsType === "object") params.push(_kubb_core.ast.factory.createFunctionParameter({
 			properties: pathChildren,
-			inline: pathParamsType === "inline",
 			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
-		});
+		}));
+		else params.push(...pathChildren.map((child) => _kubb_core.ast.factory.createFunctionParameter(child)));
 	}
-	if (bodyType) params.push(_kubb_core.ast.createFunctionParameter({
+	if (bodyType) params.push(_kubb_core.ast.factory.createFunctionParameter({
 		name: "data",
 		type: bodyType,
 		optional: !bodyRequired
 	}));
-	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
-	return _kubb_core.ast.createFunctionParameters({ params });
+	params.push(...(0, _kubb_ast_utils.buildGroupParam)({
+		name: "params",
+		node,
+		params: queryParams,
+		groupType: queryGroupType,
+		resolver,
+		wrapType: (type) => type
+	}));
+	return _kubb_core.ast.factory.createFunctionParameters({ params });
 }
 /**
 * Collect the names of the required params (no default) that drive the `enabled`
@@ -565,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;
 }
@@ -586,27 +530,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) ? _kubb_core.ast.createFunctionParameter({
-					name: child.name,
-					type: child.type,
-					rest: child.rest,
-					optional: true
-				}) : child)
+				...param,
+				type: _kubb_core.ast.factory.createTypeLiteral({ members: next })
 			};
 		}
-		const fp = param;
-		return nameSet.has(fp.name) ? _kubb_core.ast.createFunctionParameter({
-			name: fp.name,
-			type: fp.type,
-			rest: fp.rest,
+		return typeof param.name === "string" && nameSet.has(param.name) ? _kubb_core.ast.factory.createFunctionParameter({
+			name: param.name,
+			type: param.type,
+			rest: param.rest,
 			optional: true
-		}) : fp;
+		}) : param;
 	});
-	return _kubb_core.ast.createFunctionParameters({ params });
+	return _kubb_core.ast.factory.createFunctionParameters({ params });
 }
 /**
 * Add a non-null assertion (`!`) to the named params inside a printed client-call
@@ -633,13 +575,13 @@ function injectNonNullAssertions(callStr, names) {
 const declarationPrinter$3 = (0, _kubb_plugin_ts.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
@@ -681,9 +623,9 @@ function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeNa
 //#region src/components/Mutation.tsx
 const declarationPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-const keysPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "keys" });
+const keysPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function createMutationArgParams(node, options) {
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing: options.paramsCasing,
@@ -694,25 +636,22 @@ function buildMutationParamsNode(node, options) {
 	const { dataReturnType, mutationKeyTypeName, mutationArgTypeName, resolver } = options;
 	const responseName = 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"}>`;
-	return _kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createFunctionParameter({
+	return _kubb_core.ast.factory.createFunctionParameters({ params: [_kubb_core.ast.factory.createFunctionParameter({
 		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
   client?: ${buildRequestConfigType(node, resolver)},
   shouldFetch?: boolean,
-}`
-		}),
+}`,
 		default: "{}"
 	})] });
 }
 function Mutation({ name, clientName, mutationKeyName, mutationKeyTypeName, mutationArgTypeName, paramsCasing, paramsType, pathParamsType, dataReturnType, node, tsResolver }) {
 	const responseName = 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,
@@ -735,17 +674,14 @@ function Mutation({ name, clientName, mutationKeyName, mutationKeyTypeName, muta
 		resolver: tsResolver
 	});
 	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
-	const clientCallParamsNode = _kubb_core.ast.createOperationParams(node, {
+	const clientCallParamsNode = (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver: tsResolver,
-		extraParams: [_kubb_core.ast.createFunctionParameter({
+		extraParams: [_kubb_core.ast.factory.createFunctionParameter({
 			name: "config",
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
+			type: buildRequestConfigType(node, tsResolver),
 			default: "{}"
 		})]
 	});
@@ -810,22 +746,7 @@ function MutationKey({ name, typeName, node, paramsCasing, pathParamsType, trans
 const declarationPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function getQueryOptionsParams(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
-	return _kubb_core.ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [_kubb_core.ast.createFunctionParameter({
-			name: "config",
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
-			}),
-			default: "{}"
-		})]
-	});
+	return buildQueryOptionsParams(node, options);
 }
 function QueryOptions({ name, clientName, node, tsResolver, paramsCasing, paramsType, pathParamsType }) {
 	const enabledNames = getEnabledParamNames(buildQueryKeyParams(node, {
@@ -868,22 +789,19 @@ function buildQueryParamsNode(node, options) {
 	const responseName = resolver.resolveResponseName(node);
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
 	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 = _kubb_core.ast.createFunctionParameter({
+	const optionsParam = _kubb_core.ast.factory.createFunctionParameter({
 		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: SWRConfiguration<${[TData, TError].join(", ")}>,
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
   shouldFetch?: boolean,
   immutable?: boolean
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return _kubb_core.ast.createOperationParams(node, {
+	return (0, _kubb_ast_utils.createOperationParams)(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -895,7 +813,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 	const responseName = tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const generics = [
-		dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`,
+		dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver),
 		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
 		`${queryKeyTypeName} | null`
 	];
@@ -1026,4 +944,4 @@ Object.defineProperty(exports, "resolveZodSchemaNames", {
 	}
 });
 
-//# sourceMappingURL=components-CD7ZoS3B.cjs.map
+//# sourceMappingURL=components-DxWGjLWg.cjs.map