@kubb/plugin-swr 5.0.0-alpha.33 → 5.0.0-alpha.35

package/dist/components-JQ2KRFCa.js

@@ -0,0 +1,877 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { ast } from "@kubb/core";
+import { functionPrinter } from "@kubb/plugin-ts";
+import { File, Function as Function$1, 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;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* 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) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
+/**
+* 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}`'
+*/
+var URLPath = class {
+	/**
+	* 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`.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
+	* ```
+	*/
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	*
+	* @example
+	* ```ts
+	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+	* new URLPath('/pet/{petId}').isURL                       // false
+	* ```
+	*/
+	get isURL() {
+		try {
+			return !!new URL(this.path).href;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	*
+	* @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.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').object
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	* ```
+	*/
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
+	* new URLPath('/pet').params         // undefined
+	* ```
+	*/
+	get params() {
+		return this.getParams();
+	}
+	#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.
+	*/
+	#eachParam(fn) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		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;
+	}
+	/**
+	* 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 } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* 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}').getParams()
+	* // { petId: 'petId', tagId: 'tagId' }
+	* ```
+	*/
+	getParams(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;
+	}
+	/** 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 src/utils.ts
+/**
+* Apply the user-provided `transformers.name` function (if any) to a resolved name.
+* Mirrors the old `createPlugin` `resolveName` lifecycle that applied transformers
+* after resolving the full name (base + suffix).
+*/
+function transformName(name, type, transformers) {
+	return transformers?.name?.(name, type) || name;
+}
+/**
+* Build JSDoc comment lines from an OperationNode.
+*/
+function getComments(node) {
+	return [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		node.deprecated && "@deprecated",
+		`{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`
+	].filter((x) => Boolean(x));
+}
+/**
+* Resolve error type names from operation responses.
+*/
+function resolveErrorNames(node, tsResolver) {
+	return node.responses.filter((r) => {
+		return Number.parseInt(r.statusCode, 10) >= 400 || r.statusCode === "default";
+	}).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
+}
+/**
+* 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).
+*/
+function resolvePathParamType(node, param, resolver) {
+	const individualName = resolver.resolveParamName(node, param);
+	const groupName = resolver.resolvePathParamsName(node, param);
+	if (groupName !== individualName) return ast.createParamsType({
+		variant: "member",
+		base: groupName,
+		key: param.name
+	});
+	return ast.createParamsType({
+		variant: "reference",
+		name: individualName
+	});
+}
+/**
+* Derive a query-params group type from the resolver.
+* Returns `undefined` 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;
+	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;
+	return {
+		type: ast.createParamsType({
+			variant: "reference",
+			name: groupName
+		}),
+		optional: params.every((p) => !p.required)
+	};
+}
+/**
+* Build a single `FunctionParameterNode` for a query or header group.
+*/
+function buildGroupParam(name, node, params, groupType, resolver) {
+	if (groupType) return [ast.createFunctionParameter({
+		name,
+		type: groupType.type,
+		optional: groupType.optional
+	})];
+	if (params.length) {
+		const structProps = params.map((p) => ({
+			name: p.name,
+			type: ast.createParamsType({
+				variant: "reference",
+				name: resolver.resolveParamName(node, p)
+			}),
+			optional: !p.required
+		}));
+		return [ast.createFunctionParameter({
+			name,
+			type: ast.createParamsType({
+				variant: "struct",
+				properties: structProps
+			}),
+			optional: params.every((p) => !p.required)
+		})];
+	}
+	return [];
+}
+/**
+* Build QueryKey params: pathParams + data + queryParams (NO headers, NO config).
+*/
+function buildQueryKeyParams(node, options) {
+	const { pathParamsType, paramsCasing, resolver } = options;
+	const casedParams = ast.caseParams(node.parameters, paramsCasing);
+	const 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?.schema ? ast.createParamsType({
+		variant: "reference",
+		name: resolver.resolveDataName(node)
+	}) : void 0;
+	const bodyRequired = node.requestBody?.required ?? false;
+	const params = [];
+	if (pathParams.length) {
+		const pathChildren = pathParams.map((p) => ast.createFunctionParameter({
+			name: p.name,
+			type: resolvePathParamType(node, p, resolver),
+			optional: !p.required
+		}));
+		params.push({
+			kind: "ParameterGroup",
+			properties: pathChildren,
+			inline: pathParamsType === "inline",
+			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
+		});
+	}
+	if (bodyType) params.push(ast.createFunctionParameter({
+		name: "data",
+		type: bodyType,
+		optional: !bodyRequired
+	}));
+	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?.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 });
+}
+//#endregion
+//#region src/components/Mutation.tsx
+const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
+const callPrinter$3 = functionPrinter({ mode: "call" });
+const keysPrinter = functionPrinter({ mode: "keys" });
+/**
+* Default mutation hook params (paramsToTrigger=false):
+* pathParams + queryParams + headers + options (NO data — it comes via useSWRMutation arg)
+*/
+function getParams$3(node, options) {
+	const { paramsCasing, pathParamsType, dataReturnType, resolver, mutationKeyTypeName } = options;
+	const responseName = resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const TExtraArg = requestName || "never";
+	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 params = [];
+	if (pathParams.length) {
+		const pathChildren = pathParams.map((p) => ast.createFunctionParameter({
+			name: p.name,
+			type: resolvePathParamType(node, p, resolver),
+			optional: !p.required
+		}));
+		params.push({
+			kind: "ParameterGroup",
+			properties: pathChildren,
+			inline: pathParamsType === "inline",
+			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
+		});
+	}
+	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
+	params.push(...buildGroupParam("headers", node, headerParams, headerGroupType, resolver));
+	params.push(ast.createFunctionParameter({
+		name: "options",
+		type: ast.createParamsType({
+			variant: "reference",
+			name: `{
+  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${TExtraArg}> & { throwOnError?: boolean },
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
+  shouldFetch?: boolean,
+}`
+		}),
+		default: "{}"
+	}));
+	return ast.createFunctionParameters({ params });
+}
+__name(getParams$3, "getParams");
+/**
+* Trigger-mode params (paramsToTrigger=true): just `options`
+*/
+function getTriggerParams(node, options) {
+	const { dataReturnType, resolver, mutationKeyTypeName, mutationArgTypeName } = options;
+	const responseName = resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+		name: "options",
+		type: ast.createParamsType({
+			variant: "reference",
+			name: `{
+  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
+  shouldFetch?: boolean,
+}`
+		}),
+		default: "{}"
+	})] });
+}
+function Mutation({ name, clientName, mutationKeyName, mutationKeyTypeName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver, paramsToTrigger = false }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const requestName = node.requestBody?.schema ? tsResolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const clientCallParamsNode = ast.createOperationParams(node, {
+		paramsType,
+		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
+		paramsCasing,
+		resolver: tsResolver,
+		extraParams: [ast.createFunctionParameter({
+			name: "config",
+			type: ast.createParamsType({
+				variant: "reference",
+				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+			}),
+			default: "{}"
+		})]
+	});
+	const clientCallStr = callPrinter$3.print(clientCallParamsNode) ?? "";
+	if (paramsToTrigger) {
+		const mutationArgTypeName = `${mutationKeyTypeName.replace("MutationKey", "")}MutationArg`;
+		const mutationArgParamsNode = buildMutationArgParams(node, {
+			paramsCasing,
+			resolver: tsResolver
+		});
+		const hasMutationParams = mutationArgParamsNode.params.length > 0;
+		const mutationArgDeclaration = hasMutationParams ? declarationPrinter$4.print(mutationArgParamsNode) ?? "" : "";
+		const argKeysStr = hasMutationParams ? keysPrinter.print(mutationArgParamsNode) ?? "" : "";
+		const paramsNode = getTriggerParams(node, {
+			dataReturnType,
+			resolver: tsResolver,
+			mutationKeyTypeName,
+			mutationArgTypeName
+		});
+		const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+		const generics = [
+			TData,
+			TError,
+			`${mutationKeyTypeName} | null`,
+			mutationArgTypeName
+		].filter(Boolean);
+		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 ? `{${mutationArgDeclaration}}` : "never"
+			})
+		}), /* @__PURE__ */ jsx(File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsx(Function$1, {
+				name,
+				export: true,
+				params: paramsSignature,
+				JSDoc: { comments: getComments(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
+        )
+    `
+			})
+		})] });
+	}
+	const generics = [
+		TData,
+		TError,
+		`${mutationKeyTypeName} | null`,
+		requestName
+	].filter(Boolean);
+	const paramsNode = getParams$3(node, {
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		resolver: tsResolver,
+		mutationKeyTypeName
+	});
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: paramsSignature,
+			JSDoc: { comments: getComments(node) },
+			children: `
+        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
+        const mutationKey = ${mutationKeyName}()
+
+        return useSWRMutation<${generics.join(", ")}>(
+          shouldFetch ? mutationKey : null,
+          async (_url${requestName ? ", { arg: data }" : ""}) => {
+            return ${clientName}(${clientCallStr})
+          },
+          mutationOptions
+        )
+    `
+		})
+	});
+}
+//#endregion
+//#region src/components/MutationKey.tsx
+const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
+function getParams$2() {
+	return ast.createFunctionParameters({ params: [] });
+}
+__name(getParams$2, "getParams");
+const getTransformer$1 = /* @__PURE__ */ __name(({ node, casing }) => {
+	return [`{ url: '${new URLPath(node.path, { casing }).toURLPath()}' }`];
+}, "getTransformer");
+function MutationKey({ name, paramsCasing, node, typeName, transformer = getTransformer$1 }) {
+	const paramsNode = getParams$2();
+	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
+	const keys = transformer({
+		node,
+		casing: paramsCasing
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			export: true,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+MutationKey.getParams = getParams$2;
+MutationKey.getTransformer = getTransformer$1;
+//#endregion
+//#region src/components/QueryKey.tsx
+const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
+const callPrinter$2 = functionPrinter({ mode: "call" });
+function getParams$1(node, options) {
+	return buildQueryKeyParams(node, options);
+}
+__name(getParams$1, "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?.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$1(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	const keys = transformer({
+		node,
+		casing: paramsCasing
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			export: true,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+QueryKey.getParams = getParams$1;
+QueryKey.getTransformer = getTransformer;
+QueryKey.callPrinter = callPrinter$2;
+//#endregion
+//#region src/components/QueryOptions.tsx
+const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
+const callPrinter$1 = functionPrinter({ mode: "call" });
+function getQueryOptionsParams(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
+	const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : void 0;
+	return ast.createOperationParams(node, {
+		paramsType,
+		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
+		paramsCasing,
+		resolver,
+		extraParams: [ast.createFunctionParameter({
+			name: "config",
+			type: ast.createParamsType({
+				variant: "reference",
+				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+			}),
+			default: "{}"
+		})]
+	});
+}
+function QueryOptions({ name, clientName, node, tsResolver, paramsCasing, paramsType, pathParamsType }) {
+	const paramsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
+	const paramsCall = callPrinter$1.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+      return {
+        fetcher: async () => {
+          return ${clientName}(${paramsCall})
+        },
+      }
+      `
+		})
+	});
+}
+//#endregion
+//#region src/components/Query.tsx
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+const callPrinter = functionPrinter({ mode: "call" });
+function getParams(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
+	const responseName = resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const optionsParam = ast.createFunctionParameter({
+		name: "options",
+		type: ast.createParamsType({
+			variant: "reference",
+			name: `{
+  query?: Parameters<typeof useSWR<${TData}, ${TError}>>[2],
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
+  shouldFetch?: boolean,
+  immutable?: boolean
+}`
+		}),
+		default: "{}"
+	});
+	if (paramsType === "object") {
+		const baseParams = ast.createOperationParams(node, {
+			paramsType: "object",
+			pathParamsType: "object",
+			paramsCasing,
+			resolver,
+			extraParams: []
+		});
+		return ast.createFunctionParameters({ params: [...baseParams.params, optionsParam] });
+	}
+	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 bodyType = node.requestBody?.schema ? ast.createParamsType({
+		variant: "reference",
+		name: resolver.resolveDataName(node)
+	}) : void 0;
+	const bodyRequired = node.requestBody?.required ?? false;
+	const params = [];
+	if (pathParams.length) {
+		const pathChildren = pathParams.map((p) => ast.createFunctionParameter({
+			name: p.name,
+			type: resolvePathParamType(node, p, resolver),
+			optional: !p.required
+		}));
+		params.push({
+			kind: "ParameterGroup",
+			properties: pathChildren,
+			inline: pathParamsType === "inline",
+			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
+		});
+	}
+	if (bodyType) params.push(ast.createFunctionParameter({
+		name: "data",
+		type: bodyType,
+		optional: !bodyRequired
+	}));
+	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
+	const headerGroupType = node.parameters.some((p) => p.in === "header") ? (() => {
+		const hParams = casedParams.filter((p) => p.in === "header");
+		const firstParam = hParams[0];
+		const groupName = resolver.resolveHeaderParamsName(node, firstParam);
+		if (groupName !== resolver.resolveParamName(node, firstParam)) return {
+			type: ast.createParamsType({
+				variant: "reference",
+				name: groupName
+			}),
+			optional: hParams.every((p) => !p.required)
+		};
+	})() : void 0;
+	params.push(...buildGroupParam("headers", node, headerParams, headerGroupType, resolver));
+	params.push(optionsParam);
+	return ast.createFunctionParameters({ params });
+}
+function Query({ name, node, tsResolver, queryKeyName, queryKeyTypeName, queryOptionsName, dataReturnType, paramsType, paramsCasing, pathParamsType }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const generics = [
+		dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`,
+		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+		`${queryKeyTypeName} | null`
+	];
+	const queryKeyParamsNode = QueryKey.getParams(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
+	const paramsNode = getParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: paramsSignature,
+			JSDoc: { comments: getComments(node) },
+			children: `
+       const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
+
+       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+
+       return useSWR<${generics.join(", ")}>(
+        shouldFetch ? queryKey : null,
+        {
+          ...${queryOptionsName}(${queryOptionsParamsCall}),
+          ...(immutable ? {
+              revalidateIfStale: false,
+              revalidateOnFocus: false,
+              revalidateOnReconnect: false
+            } : { }),
+          ...queryOptions
+        }
+       )
+       `
+		})
+	});
+}
+//#endregion
+export { Mutation as a, MutationKey as i, QueryOptions as n, transformName as o, QueryKey as r, camelCase as s, Query as t };
+
+//# sourceMappingURL=components-JQ2KRFCa.js.map