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

package/dist/components-mWBRE6E4.js

@@ -1,851 +0,0 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
-import { ast } from "@kubb/core";
-import { buildGroupParam, caseParams, createOperationParams, 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";
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-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;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
-*/
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-//#endregion
-//#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;
-}
-/**
-* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
-*/
-var Url = class Url {
-	/**
-	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
-	*
-	* @example
-	* Url.canParse('https://petstore.swagger.io/v2') // true
-	* Url.canParse('/pet/{petId}')                   // false
-	*/
-	static canParse(url, base) {
-		return URL.canParse(url, base);
-	}
-	/**
-	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
-	*
-	* @example
-	* Url.toPath('/pet/{petId}') // '/pet/:petId'
-	*/
-	static toPath(path) {
-		return path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-	/**
-	* 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
-	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
-	*/
-	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 the path and its extracted params as a structured `URLObject`, or as a stringified
-	* expression when `stringify` is set.
-	*
-	* @example
-	* Url.toObject('/pet/{petId}')
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	*/
-	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
-		const object = {
-			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(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
-};
-//#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 ${Url.toPath(node.path)}}` : null;
-	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
-}
-function getContentTypeInfo(node) {
-	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
-	const isMultipleContentTypes = contentTypes.length > 1;
-	return {
-		contentTypes,
-		isMultipleContentTypes,
-		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
-		defaultContentType: contentTypes[0] ?? "application/json",
-		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
-	};
-}
-function buildRequestConfigType(node, resolver) {
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
-	return `${requestName ? `Partial<RequestConfig<${requestName}>>` : "Partial<RequestConfig>"} & { ${["client?: Client", isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null].filter(Boolean).join("; ")} }`;
-}
-function buildOperationComments(node, options = {}) {
-	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
-	const linkComment = getOperationLink(node, link);
-	const filteredComments = (linkPosition === "beforeDeprecated" ? [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		linkComment,
-		node.deprecated && "@deprecated"
-	] : [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		node.deprecated && "@deprecated",
-		linkComment
-	]).filter((comment) => Boolean(comment));
-	if (!splitLines) return filteredComments;
-	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
-}
-function getOperationParameters(node, options = {}) {
-	const params = 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 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 resolveStatusCodeNames(node, resolver) {
-	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-/**
-* Builds the discriminated union type string for `dataReturnType: 'full'` return shapes.
-* Each member is `{ status: N; data: StatusNType; statusText: string }`.
-*/
-function buildStatusUnionType(node, resolver) {
-	const members = node.responses.map((r) => {
-		const typeName = resolver.resolveResponseStatusName(node, r.statusCode);
-		const statusCode = Number.parseInt(r.statusCode, 10);
-		return `{ status: ${Number.isNaN(statusCode) ? "number" : String(statusCode)}; data: ${typeName}; statusText: string }`;
-	});
-	if (members.length === 1) return members[0];
-	return `(${members.join(" | ")})`;
-}
-const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
-function resolveOperationTypeNames(node, resolver, options = {}) {
-	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
-	let byResolver = typeNamesByResolver.get(resolver);
-	if (byResolver) {
-		const cached = byResolver.get(cacheKey);
-		if (cached) return cached;
-	} else {
-		byResolver = /* @__PURE__ */ new Map();
-		typeNamesByResolver.set(resolver, byResolver);
-	}
-	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
-	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
-	const exclude = new Set(options.exclude ?? []);
-	const paramNames = [
-		...path.map((param) => resolver.resolvePathParamsName(node, param)),
-		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
-		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
-	];
-	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
-	const result = (options.order === "body-response-first" ? [
-		...bodyAndResponseNames,
-		...paramNames,
-		...responseStatusNames
-	] : [
-		...paramNames,
-		...bodyAndResponseNames,
-		...responseStatusNames
-	]).filter((name) => Boolean(name) && !exclude.has(name));
-	byResolver.set(cacheKey, result);
-	return result;
-}
-//#endregion
-//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$4 = 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 = ast.factory.createFunctionParameters({ params: [] });
-	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
-	const keys = (transformer ?? mutationKeyTransformer)({
-		node,
-		casing: paramsCasing
-	});
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ 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
-/**
-* 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: "{}"
-		})]
-	});
-}
-/**
-* Returns `'zod'` when response-direction parsing is enabled.
-* The string shorthand `'zod'` also enables response parsing.
-*/
-function resolveResponseParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.response ?? null;
-}
-/**
-* Returns `'zod'` when request body parsing is enabled.
-* The string shorthand `'zod'` also enables request body parsing (existing behavior).
-*/
-function resolveRequestParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.request ?? null;
-}
-/**
-* 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 = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	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) => ({
-			name: p.name,
-			type: resolveParamType({
-				node,
-				param: p,
-				resolver
-			}),
-			optional: !p.required
-		}));
-		if (pathParamsType === "object") params.push(ast.factory.createFunctionParameter({
-			properties: pathChildren,
-			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
-		}));
-		else params.push(...pathChildren.map((child) => ast.factory.createFunctionParameter(child)));
-	}
-	if (bodyType) params.push(ast.factory.createFunctionParameter({
-		name: "data",
-		type: bodyType,
-		optional: !bodyRequired
-	}));
-	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`
-* guard. These are exactly the params that should be made optional in the
-* generated signatures so callers can pass `undefined` to reach the disabled state.
-*/
-function getEnabledParamNames(paramsNode) {
-	const required = [];
-	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;
-}
-/**
-* Return a copy of `paramsNode` with the named params marked optional.
-*
-* Used to align signatures with the `enabled` guard: the guard already disables
-* the query while a param is falsy, so the param should accept `undefined`. The
-* change is type-only — the `queryFn` keeps calling the client with a non-null
-* assertion (see `injectNonNullAssertions`), so the emitted runtime is unchanged.
-*/
-function markParamsOptional(paramsNode, names) {
-	if (names.length === 0) return paramsNode;
-	const nameSet = new Set(names);
-	const params = paramsNode.params.map((param) => {
-		const members = groupMembers(param);
-		if (members) {
-			const next = members.map((member) => nameSet.has(member.name) ? {
-				...member,
-				optional: true
-			} : member);
-			return {
-				...param,
-				type: ast.factory.createTypeLiteral({ members: next })
-			};
-		}
-		return typeof param.name === "string" && nameSet.has(param.name) ? ast.factory.createFunctionParameter({
-			name: param.name,
-			type: param.type,
-			rest: param.rest,
-			optional: true
-		}) : param;
-	});
-	return ast.factory.createFunctionParameters({ params });
-}
-/**
-* Add a non-null assertion (`!`) to the named params inside a printed client-call
-* string. Bridges the type gap created by `markParamsOptional` while keeping the
-* runtime identical (the `!` is erased at compile time).
-*
-* Handles destructured shorthand groups (`{ petId }` → `{ petId: petId! }`) and
-* standalone identifiers (`params` → `params!`).
-*/
-function injectNonNullAssertions(callStr, names) {
-	if (names.length === 0) return callStr;
-	const nameSet = new Set(names);
-	let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner) => {
-		if (inner.includes(":") || inner.includes("...")) return match;
-		const keys = inner.split(",").map((k) => k.trim()).filter(Boolean);
-		if (!keys.some((k) => nameSet.has(k))) return match;
-		return `{ ${keys.map((k) => nameSet.has(k) ? `${k}: ${k}!` : k).join(", ")} }`;
-	});
-	result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name) => nameSet.has(name) ? `${name}!` : match);
-	return result;
-}
-//#endregion
-//#region ../../internals/tanstack-query/src/components/QueryKey.tsx
-const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
-const queryKeyTransformer = ({ node, casing }) => {
-	if (!node.path) return [];
-	const hasQueryParams = getOperationParameters(node).query.length > 0;
-	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
-	return [
-		Url.toObject(node.path, {
-			type: "path",
-			stringify: true,
-			casing
-		}),
-		hasQueryParams ? "...(params ? [params] : [])" : null,
-		hasRequestBody ? "...(data ? [data] : [])" : null
-	].filter(Boolean);
-};
-function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer }) {
-	const baseParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const paramsNode = markParamsOptional(baseParamsNode, getEnabledParamNames(baseParamsNode));
-	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
-	const keys = (transformer ?? queryKeyTransformer)({
-		node,
-		casing: paramsCasing
-	});
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function.Arrow, {
-			name,
-			export: true,
-			params: paramsSignature,
-			singleLine: true,
-			children: `[${keys.join(", ")}] as const`
-		})
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isTypeOnly: true,
-		children: /* @__PURE__ */ jsx(Type, {
-			name: typeName,
-			children: `ReturnType<typeof ${name}>`
-		})
-	})] });
-}
-//#endregion
-//#region src/components/Mutation.tsx
-const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
-const callPrinter$2 = functionPrinter({ mode: "call" });
-const keysPrinter = functionPrinter({ mode: "call" });
-function createMutationArgParams(node, options) {
-	return createOperationParams(node, {
-		paramsType: "inline",
-		pathParamsType: "inline",
-		paramsCasing: options.paramsCasing,
-		resolver: options.resolver
-	});
-}
-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 : buildStatusUnionType(node, resolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	return ast.factory.createFunctionParameters({ params: [ast.factory.createFunctionParameter({
-		name: "options",
-		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 : buildStatusUnionType(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const mutationArgParamsNode = createMutationArgParams(node, {
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const hasMutationParams = mutationArgParamsNode.params.length > 0;
-	const argTypeBody = hasMutationParams ? declarationPrinter$2.print(mutationArgParamsNode) ?? "" : "";
-	const argKeysStr = hasMutationParams ? keysPrinter.print(mutationArgParamsNode) ?? "" : "";
-	const generics = [
-		TData,
-		TError,
-		`${mutationKeyTypeName} | null`,
-		mutationArgTypeName
-	];
-	const paramsNode = buildMutationParamsNode(node, {
-		paramsCasing,
-		dataReturnType,
-		mutationKeyTypeName,
-		mutationArgTypeName,
-		resolver: tsResolver
-	});
-	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
-	const clientCallParamsNode = createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver: tsResolver,
-		extraParams: [ast.factory.createFunctionParameter({
-			name: "config",
-			type: buildRequestConfigType(node, tsResolver),
-			default: "{}"
-		})]
-	});
-	const clientCallStr = callPrinter$2.print(clientCallParamsNode) ?? "";
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
-		name: mutationArgTypeName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: true,
-		children: /* @__PURE__ */ jsx(Type, {
-			name: mutationArgTypeName,
-			export: true,
-			children: hasMutationParams ? `{ ${argTypeBody} }` : "never"
-		})
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}()
-
-        return useSWRMutation<${generics.join(", ")}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${hasMutationParams ? `, { arg: { ${argKeysStr} } }` : ""}) => {
-            return ${clientName}(${clientCallStr})
-          },
-          mutationOptions
-        )
-    `
-		})
-	})] });
-}
-//#endregion
-//#region src/components/MutationKey.tsx
-function MutationKey({ name, typeName, node, paramsCasing, pathParamsType, transformer }) {
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MutationKey$1, {
-		name,
-		node,
-		paramsCasing,
-		pathParamsType,
-		transformer
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: true,
-		children: /* @__PURE__ */ jsx(Type, {
-			export: true,
-			name: typeName,
-			children: `ReturnType<typeof ${name}>`
-		})
-	})] });
-}
-//#endregion
-//#region src/components/QueryOptions.tsx
-const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
-const callPrinter$1 = functionPrinter({ mode: "call" });
-function getQueryOptionsParams(node, options) {
-	return buildQueryOptionsParams(node, options);
-}
-function QueryOptions({ name, clientName, node, tsResolver, paramsCasing, paramsType, pathParamsType }) {
-	const enabledNames = getEnabledParamNames(buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	}));
-	const paramsNode = markParamsOptional(getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
-	const clientCallStr = injectNonNullAssertions(callPrinter$1.print(paramsNode) ?? "", enabledNames);
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-      return {
-        fetcher: async () => {
-          return ${clientName}(${clientCallStr})
-        },
-      }
-`
-		})
-	});
-}
-//#endregion
-//#region src/components/Query.tsx
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-const callPrinter = functionPrinter({ mode: "call" });
-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 errorNames = resolveErrorNames(node, resolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = ast.factory.createFunctionParameter({
-		name: "options",
-		type: `{
-  query?: SWRConfiguration<${[TData, TError].join(", ")}>,
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}`,
-		default: "{}"
-	});
-	return createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [optionsParam]
-	});
-}
-function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver }) {
-	const responseName = tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const generics = [
-		dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver),
-		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
-		`${queryKeyTypeName} | null`
-	];
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const queryOptionsParamsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = markParamsOptional(buildQueryParamsNode(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
-	const shouldFetchExpr = enabledNames.length ? `shouldFetch && !!(${enabledNames.join(" && ")})` : "shouldFetch";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
-
-       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-
-       return useSWR<${generics.join(", ")}>(
-        ${shouldFetchExpr} ? queryKey : null,
-        {
-          ...${queryOptionsName}(${queryOptionsParamsCall}),
-          ...(immutable ? {
-              revalidateIfStale: false,
-              revalidateOnFocus: false,
-              revalidateOnReconnect: false
-            } : { }),
-          ...queryOptions,
-        }
-       )
-       `
-		})
-	});
-}
-//#endregion
-export { QueryKey as a, mutationKeyTransformer as c, Mutation as i, resolveOperationTypeNames as l, QueryOptions as n, queryKeyTransformer as o, MutationKey as r, resolveZodSchemaNames as s, Query as t, camelCase as u };
-
-//# sourceMappingURL=components-mWBRE6E4.js.map