@kubb/plugin-vue-query 5.0.0-beta.3 → 5.0.0-beta.30

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

@@ -228,16 +228,16 @@ var URLPath = class {
 	get object() {
 		return this.toObject();
 	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	/** Returns a map of path parameter names, or `null` when the path has no parameters.
 	*
 	* @example
 	* ```ts
 	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
+	* new URLPath('/pet').params         // null
 	* ```
 	*/
 	get params() {
-		return this.getParams();
+		return this.toParamsObject();
 	}
 	#transformParam(raw) {
 		const param = isValidVarName(raw) ? raw : camelCase(raw);
@@ -255,7 +255,7 @@ var URLPath = class {
 	toObject({ type = "path", replacer, stringify } = {}) {
 		const object = {
 			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
+			params: this.toParamsObject()
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -271,12 +271,13 @@ var URLPath = class {
 	* @example
 	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
 	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+	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("")}\``;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
 	/**
 	* Extracts all `{param}` segments from the path and returns them as a key-value map.
@@ -285,17 +286,17 @@ var URLPath = class {
 	*
 	* @example
 	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+	* new URLPath('/pet/{petId}/tag/{tagId}').toParamsObject()
 	* // { petId: 'petId', tagId: 'tagId' }
 	* ```
 	*/
-	getParams(replacer) {
+	toParamsObject(replacer) {
 		const params = {};
 		this.#eachParam((_raw, param) => {
 			const key = replacer ? replacer(param) : param;
 			params[key] = key;
 		});
-		return Object.keys(params).length > 0 ? params : void 0;
+		return Object.keys(params).length > 0 ? params : null;
 	}
 	/** Converts the OpenAPI path to Express-style colon syntax.
 	*
@@ -310,18 +311,14 @@ var URLPath = class {
 };
 //#endregion
 //#region ../../internals/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
-function getParams$4() {
-	return ast.createFunctionParameters({ params: [] });
-}
-__name(getParams$4, "getParams");
-const getTransformer$1 = /* @__PURE__ */ __name(({ node, casing }) => {
+const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
+const mutationKeyTransformer = ({ node, casing }) => {
 	return [`{ url: '${new URLPath(node.path, { casing }).toURLPath()}' }`];
-}, "getTransformer");
-function MutationKey({ name, paramsCasing, node, transformer = getTransformer$1 }) {
-	const paramsNode = getParams$4();
-	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
-	const keys = transformer({
+};
+function MutationKey({ name, paramsCasing, node, transformer }) {
+	const paramsNode = ast.createFunctionParameters({ params: [] });
+	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
 		node,
 		casing: paramsCasing
 	});
@@ -338,28 +335,119 @@ function MutationKey({ name, paramsCasing, node, transformer = getTransformer$1
 		})
 	});
 }
-MutationKey.getParams = getParams$4;
-MutationKey.getTransformer = getTransformer$1;
 //#endregion
-//#region ../../internals/tanstack-query/src/utils.ts
-/**
-* Build JSDoc comment lines from an OperationNode.
-*/
-function getComments(node) {
-	return [
+//#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;
+	return `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`;
+}
+function getContentTypeInfo(node) {
+	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function buildRequestConfigType(node, resolver) {
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
+	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
+	return `${requestName ? `Partial<RequestConfig<${requestName}>>` : "Partial<RequestConfig>"} & { ${["client?: Client", isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null].filter(Boolean).join("; ")} }`;
+}
+function buildOperationComments(node, options = {}) {
+	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
+	const linkComment = getOperationLink(node, link);
+	const filteredComments = (linkPosition === "beforeDeprecated" ? [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		linkComment,
+		node.deprecated && "@deprecated"
+	] : [
 		node.description && `@description ${node.description}`,
 		node.summary && `@summary ${node.summary}`,
 		node.deprecated && "@deprecated",
-		`{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`
-	].filter((x) => Boolean(x));
+		linkComment
+	]).filter((comment) => Boolean(comment));
+	if (!splitLines) return filteredComments;
+	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
+}
+function getOperationParameters(node, options = {}) {
+	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	return {
+		path: params.filter((param) => param.in === "path"),
+		query: params.filter((param) => param.in === "query"),
+		header: params.filter((param) => param.in === "header"),
+		cookie: params.filter((param) => param.in === "cookie")
+	};
 }
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function isErrorStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 400;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+function resolveSuccessNames(node, resolver) {
+	return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
+	let byResolver = typeNamesByResolver.get(resolver);
+	if (byResolver) {
+		const cached = byResolver.get(cacheKey);
+		if (cached) return cached;
+	} else {
+		byResolver = /* @__PURE__ */ new Map();
+		typeNamesByResolver.set(resolver, byResolver);
+	}
+	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
+	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
+	const exclude = new Set(options.exclude ?? []);
+	const paramNames = [
+		...path.map((param) => resolver.resolvePathParamsName(node, param)),
+		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
+		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
+	];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
+	const result = (options.order === "body-response-first" ? [
+		...bodyAndResponseNames,
+		...paramNames,
+		...responseStatusNames
+	] : [
+		...paramNames,
+		...bodyAndResponseNames,
+		...responseStatusNames
+	]).filter((name) => Boolean(name) && !exclude.has(name));
+	byResolver.set(cacheKey, result);
+	return result;
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/utils.ts
 /**
-* Resolve error type names from operation responses.
+* 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.
 */
-function resolveErrorNames(node, tsResolver) {
-	return node.responses.filter((r) => {
-		return Number.parseInt(r.statusCode, 10) >= 400;
-	}).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
+function resolveZodSchemaNames(node, zodResolver) {
+	if (!zodResolver) return [];
+	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter((n) => Boolean(n));
 }
 /**
 * Resolve the type for a single path parameter.
@@ -383,30 +471,14 @@ function resolvePathParamType(node, param, resolver) {
 }
 /**
 * Derive a query-params group type from the resolver.
-* Returns `undefined` when no query params exist or when the group name
+* Returns `null` when no query params exist or when the group name
 * equals the individual param name (no real group).
 */
 function resolveQueryGroupType(node, params, resolver) {
-	if (!params.length) return void 0;
+	if (!params.length) return null;
 	const firstParam = params[0];
 	const groupName = resolver.resolveQueryParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return void 0;
-	return {
-		type: ast.createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Derive a header-params group type from the resolver.
-*/
-function resolveHeaderGroupType(node, params, resolver) {
-	if (!params.length) return void 0;
-	const firstParam = params[0];
-	const groupName = resolver.resolveHeaderParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return void 0;
+	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
 	return {
 		type: ast.createParamsType({
 			variant: "reference",
@@ -456,7 +528,7 @@ function buildQueryKeyParams(node, options) {
 	const bodyType = node.requestBody?.content?.[0]?.schema ? ast.createParamsType({
 		variant: "reference",
 		name: resolver.resolveDataName(node)
-	}) : void 0;
+	}) : null;
 	const bodyRequired = node.requestBody?.required ?? false;
 	const params = [];
 	if (pathParams.length) {
@@ -480,48 +552,45 @@ function buildQueryKeyParams(node, options) {
 	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
 	return ast.createFunctionParameters({ params });
 }
-/**
-* Build mutation arg params for paramsToTrigger mode.
-* Contains pathParams + data + queryParams + headers (all flattened, for type alias).
-*/
-function buildMutationArgParams(node, options) {
-	const { paramsCasing, resolver } = options;
-	const casedParams = ast.caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const queryGroupType = resolveQueryGroupType(node, queryParams, resolver);
-	const headerGroupType = resolveHeaderGroupType(node, headerParams, resolver);
-	const bodyType = node.requestBody?.content?.[0]?.schema ? ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : void 0;
-	const bodyRequired = node.requestBody?.required ?? false;
-	const params = [];
-	for (const p of pathParams) params.push(ast.createFunctionParameter({
-		name: p.name,
-		type: resolvePathParamType(node, p, resolver),
-		optional: !p.required
-	}));
-	if (bodyType) params.push(ast.createFunctionParameter({
-		name: "data",
-		type: bodyType,
-		optional: !bodyRequired
-	}));
-	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
-	params.push(...buildGroupParam("headers", node, headerParams, headerGroupType, resolver));
-	return ast.createFunctionParameters({ params });
+function buildEnabledCheck(paramsNode) {
+	const required = [];
+	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
+		const group = param;
+		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
+	} else {
+		const fp = param;
+		if (!fp.optional && fp.default === void 0) required.push(fp.name);
+	}
+	return required.join(" && ");
 }
+functionPrinter({ mode: "declaration" });
+const queryKeyTransformer = ({ node, casing }) => {
+	const path = new URLPath(node.path, { casing });
+	const hasQueryParams = getOperationParameters(node).query.length > 0;
+	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
+	return [
+		path.toObject({
+			type: "path",
+			stringify: true
+		}),
+		hasQueryParams ? "...(params ? [params] : [])" : null,
+		hasRequestBody ? "...(data ? [data] : [])" : null
+	].filter(Boolean);
+};
 //#endregion
 //#region src/utils.ts
-function transformName(name, type, transformers) {
-	return transformers?.name?.(name, type) || name;
+function printType(typeNode) {
+	if (!typeNode) return "unknown";
+	if (typeNode.variant === "reference") return typeNode.name;
+	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
+	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
+		const typeStr = printType(p.type);
+		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
+	}).join("; ")} }`;
+	return "unknown";
 }
-//#endregion
-//#region src/components/QueryKey.tsx
-const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
-const callPrinter$5 = functionPrinter({ mode: "call" });
-function wrapWithMaybeRefOrGetter(paramsNode) {
+function wrapWithMaybeRefOrGetter(paramsNode, skip) {
 	const wrappedParams = paramsNode.params.map((param) => {
 		if ("kind" in param && param.kind === "ParameterGroup") {
 			const group = param;
@@ -531,59 +600,37 @@ function wrapWithMaybeRefOrGetter(paramsNode) {
 					...p,
 					type: p.type ? ast.createParamsType({
 						variant: "reference",
-						name: `MaybeRefOrGetter<${printType$4(p.type)}>`
+						name: `MaybeRefOrGetter<${printType(p.type)}>`
 					}) : p.type
 				}))
 			};
 		}
 		const fp = param;
+		if (skip?.(fp.name)) return fp;
 		return {
 			...fp,
 			type: fp.type ? ast.createParamsType({
 				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$4(fp.type)}>`
+				name: `MaybeRefOrGetter<${printType(fp.type)}>`
 			}) : fp.type
 		};
 	});
 	return ast.createFunctionParameters({ params: wrappedParams });
 }
-function printType$4(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$4(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-__name(printType$4, "printType");
-function getParams$3(node, options) {
+//#endregion
+//#region src/components/QueryKey.tsx
+const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
+function buildQueryKeyParamsNode(node, options) {
 	return wrapWithMaybeRefOrGetter(buildQueryKeyParams(node, options));
 }
-__name(getParams$3, "getParams");
-const getTransformer = ({ node, casing }) => {
-	const path = new URLPath(node.path, { casing });
-	const hasQueryParams = node.parameters.some((p) => p.in === "query");
-	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
-	return [
-		path.toObject({
-			type: "path",
-			stringify: true
-		}),
-		hasQueryParams ? "...(params ? [params] : [])" : void 0,
-		hasRequestBody ? "...(data ? [data] : [])" : void 0
-	].filter(Boolean);
-};
-function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer = getTransformer }) {
-	const paramsNode = getParams$3(node, {
+function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer }) {
+	const paramsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
 	});
 	const paramsSignature = declarationPrinter$5.print(paramsNode) ?? "";
-	const keys = transformer({
+	const keys = (transformer ?? queryKeyTransformer)({
 		node,
 		casing: paramsCasing
 	});
@@ -610,17 +657,14 @@ function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeNa
 		})
 	})] });
 }
-QueryKey.getParams = getParams$3;
-QueryKey.getTransformer = getTransformer;
-QueryKey.callPrinter = callPrinter$5;
 //#endregion
 //#region src/components/QueryOptions.tsx
 const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
 const callPrinter$4 = functionPrinter({ mode: "call" });
 function getQueryOptionsParams(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
-	return wrapOperationParamsWithMaybeRef$2(ast.createOperationParams(node, {
+	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,
@@ -633,61 +677,11 @@ function getQueryOptionsParams(node, options) {
 			}),
 			default: "{}"
 		})]
-	}));
-}
-function wrapOperationParamsWithMaybeRef$2(paramsNode) {
-	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType$3(p.type)}>`
-					}) : p.type
-				}))
-			};
-		}
-		const fp = param;
-		if (fp.name === "config") return fp;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$3(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	return ast.createFunctionParameters({ params: wrappedParams });
-}
-__name(wrapOperationParamsWithMaybeRef$2, "wrapOperationParamsWithMaybeRef");
-function printType$3(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$3(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-__name(printType$3, "printType");
-function buildEnabledCheck(paramsNode) {
-	const required = [];
-	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
-		const group = param;
-		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
-	} else {
-		const fp = param;
-		if (!fp.optional && fp.default === void 0) required.push(fp.name);
-	}
-	return required.join(" && ");
+	}), (name) => name === "config");
 }
 function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
@@ -699,14 +693,14 @@ function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, para
 	});
 	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
 	const clientCallStr = (callPrinter$4.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
-	const queryKeyParamsNode = QueryKey.getParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
 	});
 	const queryKeyParamsCall = callPrinter$4.print(queryKeyParamsNode) ?? "";
 	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
-	const enabledText = enabledSource ? `enabled: () => !!(${enabledSource}),` : "";
+	const enabledText = enabledSource ? `enabled: () => ${enabledSource.split(" && ").map((n) => `!!toValue(${n.trim()})`).join(" && ")},` : "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -748,15 +742,15 @@ function addToValueCalls$1(callStr) {
 	return result;
 }
 __name(addToValueCalls$1, "addToValueCalls");
-QueryOptions.getParams = getQueryOptionsParams;
 //#endregion
 //#region src/components/InfiniteQuery.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 const callPrinter$3 = functionPrinter({ mode: "call" });
-function getParams$2(node, options) {
+function buildInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
 	const errorNames = resolveErrorNames(node, resolver);
 	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
@@ -777,57 +771,17 @@ function getParams$2(node, options) {
 		}),
 		default: "{}"
 	});
-	return wrapOperationParamsWithMaybeRef$1(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver,
 		extraParams: [optionsParam]
-	}));
-}
-__name(getParams$2, "getParams");
-function wrapOperationParamsWithMaybeRef$1(paramsNode) {
-	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType$2(p.type)}>`
-					}) : p.type
-				}))
-			};
-		}
-		const fp = param;
-		if (fp.name === "options") return fp;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$2(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	return ast.createFunctionParameters({ params: wrappedParams });
-}
-__name(wrapOperationParamsWithMaybeRef$1, "wrapOperationParamsWithMaybeRef");
-function printType$2(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$2(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
+	}), (name) => name === "options");
 }
-__name(printType$2, "printType");
 function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
@@ -837,7 +791,7 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		`TQueryData = ${TData}`,
 		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
 	];
-	const queryKeyParamsNode = QueryKey.getParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
@@ -850,7 +804,7 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		resolver: tsResolver
 	});
 	const queryOptionsParamsCall = callPrinter$3.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = getParams$2(node, {
+	const paramsNode = buildInfiniteQueryParamsNode(node, {
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -867,7 +821,7 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 			export: true,
 			generics: generics.join(", "),
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node) },
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
@@ -886,13 +840,13 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		})
 	});
 }
-InfiniteQuery.getParams = getParams$2;
 //#endregion
 //#region src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$2 = functionPrinter({ mode: "call" });
 function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, paramsCasing, paramsType, dataReturnType, pathParamsType, queryParam, queryKeyName }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const queryFnDataType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
@@ -901,12 +855,12 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 		const parts = initialPageParam.split(" as ");
 		return parts[parts.length - 1] ?? "unknown";
 	})() : "string" : typeof initialPageParam === "boolean" ? "boolean" : "unknown";
-	const rawQueryParams = node.parameters.filter((p) => p.in === "query");
+	const rawQueryParams = getOperationParameters(node).query;
 	const queryParamsTypeName = rawQueryParams.length > 0 ? (() => {
 		const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]);
-		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : void 0;
-	})() : void 0;
-	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : void 0;
+		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : null;
+	})() : null;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
 	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
 	const paramsNode = getQueryOptionsParams(node, {
 		paramsType,
@@ -916,34 +870,24 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 	});
 	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
 	const clientCallStr = (callPrinter$2.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
-	const queryKeyParamsNode = QueryKey.getParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
 	});
 	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
 	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
-	const enabledText = enabledSource ? `enabled: () => !!(${enabledSource}),` : "";
-	const hasNewParams = nextParam !== void 0 || previousParam !== void 0;
-	let getNextPageParamExpr;
-	let getPreviousPageParamExpr;
-	if (hasNewParams) {
-		if (nextParam) {
-			const accessor = getNestedAccessor(nextParam, "lastPage");
-			if (accessor) getNextPageParamExpr = `getNextPageParam: (lastPage) => ${accessor}`;
-		}
-		if (previousParam) {
-			const accessor = getNestedAccessor(previousParam, "firstPage");
-			if (accessor) getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => ${accessor}`;
+	const enabledText = enabledSource ? `enabled: () => ${enabledSource.split(" && ").map((n) => `!!toValue(${n.trim()})`).join(" && ")},` : "";
+	const hasNewParams = nextParam != null || previousParam != null;
+	const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
+		if (hasNewParams) {
+			const nextAccessor = nextParam ? getNestedAccessor(nextParam, "lastPage") : null;
+			const prevAccessor = previousParam ? getNestedAccessor(previousParam, "firstPage") : null;
+			return [nextAccessor ? `getNextPageParam: (lastPage) => ${nextAccessor}` : null, prevAccessor ? `getPreviousPageParam: (firstPage) => ${prevAccessor}` : null];
 		}
-	} else if (cursorParam) {
-		getNextPageParamExpr = `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`;
-		getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`;
-	} else {
-		if (dataReturnType === "full") getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1";
-		else getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1";
-		getPreviousPageParamExpr = "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1";
-	}
+		if (cursorParam) return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`];
+		return [dataReturnType === "full" ? "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1" : "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1", "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1"];
+	})();
 	const queryOptionsArr = [
 		`initialPageParam: ${typeof initialPageParam === "string" ? JSON.stringify(initialPageParam) : initialPageParam}`,
 		getNextPageParamExpr,
@@ -1010,33 +954,30 @@ function addToValueCalls(callStr) {
 	});
 	return result;
 }
-InfiniteQueryOptions.getParams = (node, options) => getQueryOptionsParams(node, options);
 //#endregion
 //#region src/components/Mutation.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 const callPrinter$1 = functionPrinter({ mode: "call" });
 const keysPrinter = functionPrinter({ mode: "keys" });
-function getParams$1(node, options) {
+function createMutationArgParams(node, options) {
+	return ast.createOperationParams(node, {
+		paramsType: "inline",
+		pathParamsType: "inline",
+		paramsCasing: options.paramsCasing,
+		resolver: options.resolver
+	});
+}
+function buildMutationParamsNode(node, options) {
 	const { paramsCasing, dataReturnType, resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, resolver);
 	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const mutationArgWrapped = buildMutationArgParams(node, {
+	const wrappedParamsNode = wrapWithMaybeRefOrGetter(createMutationArgParams(node, {
 		paramsCasing,
 		resolver
-	}).params.map((param) => {
-		const fp = param;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType$1(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	const wrappedParamsNode = ast.createFunctionParameters({ params: mutationArgWrapped });
+	}));
 	const TRequestWrapped = wrappedParamsNode.params.length > 0 ? declarationPrinter$1.print(wrappedParamsNode) ?? "" : "";
 	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
 		name: "options",
@@ -1046,34 +987,22 @@ function getParams$1(node, options) {
   mutation?: MutationObserverOptions<${[
 				TData,
 				TError,
-				TRequestWrapped ? `{${TRequestWrapped}}` : "void",
+				TRequestWrapped ? `{${TRequestWrapped}}` : "undefined",
 				"TContext"
 			].join(", ")}> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
+  client?: ${buildRequestConfigType(node, resolver)},
 }`
 		}),
 		default: "{}"
 	})] });
 }
-__name(getParams$1, "getParams");
-function printType$1(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType$1(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-__name(printType$1, "printType");
 function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType, dataReturnType, node, tsResolver, mutationKeyName }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const mutationArgParamsNode = buildMutationArgParams(node, {
+	const mutationArgParamsNode = createMutationArgParams(node, {
 		paramsCasing,
 		resolver: tsResolver
 	});
@@ -1083,10 +1012,10 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 	const generics = [
 		TData,
 		TError,
-		TRequest ? `{${TRequest}}` : "void",
+		TRequest ? `{${TRequest}}` : "undefined",
 		"TContext"
 	].join(", ");
-	const mutationKeyParamsNode = MutationKey.getParams();
+	const mutationKeyParamsNode = ast.createFunctionParameters({ params: [] });
 	const mutationKeyParamsCall = callPrinter$1.print(mutationKeyParamsNode) ?? "";
 	const clientCallParamsNode = ast.createOperationParams(node, {
 		paramsType,
@@ -1097,13 +1026,13 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 			name: "config",
 			type: ast.createParamsType({
 				variant: "reference",
-				name: node.requestBody?.content?.[0]?.schema ? `Partial<RequestConfig<${tsResolver.resolveDataName(node)}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+				name: buildRequestConfigType(node, tsResolver)
 			}),
 			default: "{}"
 		})]
 	});
 	const clientCallStr = callPrinter$1.print(clientCallParamsNode) ?? "";
-	const paramsNode = getParams$1(node, {
+	const paramsNode = buildMutationParamsNode(node, {
 		paramsCasing,
 		dataReturnType,
 		resolver: tsResolver
@@ -1117,7 +1046,7 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 			name,
 			export: true,
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node) },
 			generics: ["TContext"],
 			children: `
         const { mutation = {}, client: config = {} } = options ?? {}
@@ -1135,15 +1064,15 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 		})
 	});
 }
-Mutation.getParams = getParams$1;
 //#endregion
 //#region src/components/Query.tsx
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 const callPrinter = functionPrinter({ mode: "call" });
-function getParams(node, options) {
+function buildQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
 	const errorNames = resolveErrorNames(node, resolver);
 	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
@@ -1164,54 +1093,17 @@ function getParams(node, options) {
 		}),
 		default: "{}"
 	});
-	return wrapOperationParamsWithMaybeRef(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver,
 		extraParams: [optionsParam]
-	}));
-}
-function wrapOperationParamsWithMaybeRef(paramsNode) {
-	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType(p.type)}>`
-					}) : p.type
-				}))
-			};
-		}
-		const fp = param;
-		if (fp.name === "options") return fp;
-		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	return ast.createFunctionParameters({ params: wrappedParams });
-}
-function printType(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
+	}), (name) => name === "options");
 }
 function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
@@ -1221,7 +1113,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		`TQueryData = ${TData}`,
 		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
 	];
-	const queryKeyParamsNode = QueryKey.getParams(node, {
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
 		pathParamsType,
 		paramsCasing,
 		resolver: tsResolver
@@ -1234,7 +1126,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		resolver: tsResolver
 	});
 	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = getParams(node, {
+	const paramsNode = buildQueryParamsNode(node, {
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -1251,7 +1143,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 			export: true,
 			generics: generics.join(", "),
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node) },
 			children: `
        const { query: queryConfig = {}, client: config = {} } = options ?? {}
        const { client: queryClient, ...resolvedOptions } = queryConfig
@@ -1270,8 +1162,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		})
 	});
 }
-Query.getParams = getParams;
 //#endregion
-export { QueryOptions as a, MutationKey as c, InfiniteQuery as i, camelCase as l, Mutation as n, QueryKey as o, InfiniteQueryOptions as r, transformName as s, Query as t };
+export { QueryOptions as a, resolveZodSchemaNames as c, MutationKey as d, mutationKeyTransformer as f, InfiniteQuery as i, getOperationParameters as l, Mutation as n, QueryKey as o, camelCase as p, InfiniteQueryOptions as r, queryKeyTransformer as s, Query as t, resolveOperationTypeNames as u };
 
-//# sourceMappingURL=components-D1UhYFgY.js.map
+//# sourceMappingURL=components-B4IlVmNa.js.map