@kubb/plugin-react-query 5.0.0-beta.56 → 5.0.0-beta.73

package/dist/components-DL0Cai7l.js

@@ -1,1507 +0,0 @@
-import "./chunk-C0LytTxp.js";
-import { ast } from "@kubb/core";
-import { functionPrinter } from "@kubb/plugin-ts";
-import { File, Function, Type } from "@kubb/renderer-jsx";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-import { getNestedAccessor } from "@kubb/ast/utils";
-//#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
-/**
-* Builds the `ResolverFileParams` every operation generator passes to
-* `resolver.resolveFile`: a file named `name`, tagged by the operation's first
-* tag (or `'default'`), at the operation's path. Centralizes the entry object
-* that was repeated at dozens of call sites across the client and query plugins.
-*
-* @example
-* ```ts
-* resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
-* ```
-*/
-function operationFileEntry(node, name, extname = ".ts") {
-	return {
-		name,
-		extname,
-		tag: node.tags[0] ?? "default",
-		path: node.path
-	};
-}
-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 = 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));
-}
-/**
-* 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$10 = functionPrinter({ mode: "declaration" });
-const mutationKeyTransformer = ({ node }) => {
-	if (!node.path) return [];
-	return [`{ url: '${Url.toPath(node.path)}' }`];
-};
-function MutationKey({ name, paramsCasing, node, transformer }) {
-	const paramsNode = ast.createFunctionParameters({ params: [] });
-	const paramsSignature = declarationPrinter$10.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`
-		})
-	});
-}
-//#endregion
-//#region ../../internals/tanstack-query/src/utils.ts
-/**
-* 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 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 matchesPattern(node, ov) {
-	const { type, pattern } = ov;
-	const matches = (value) => typeof pattern === "string" ? value === pattern : pattern.test(value);
-	if (type === "operationId") return matches(node.operationId);
-	if (type === "tag") return node.tags.some((t) => matches(t));
-	if (type === "path") return node.path !== void 0 && matches(node.path);
-	if (type === "method") return node.method !== void 0 && matches(node.method);
-	return false;
-}
-/**
-* Resolves per-operation overrides (first matching override wins).
-*
-* @example
-* ```ts
-* const opts = resolveOperationOverrides(node, override)
-* const queryOpts = 'query' in opts ? opts.query : defaultQuery
-* ```
-*/
-function resolveOperationOverrides(node, override) {
-	if (!override) return {};
-	return override.find((ov) => matchesPattern(node, ov))?.options ?? {};
-}
-/**
-* 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));
-}
-/**
-* 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 `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 null;
-	const firstParam = params[0];
-	const groupName = resolver.resolveQueryParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: ast.createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* 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?.content?.[0]?.schema ? ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : null;
-	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 });
-}
-/**
-* 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) 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;
-}
-/**
-* 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) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((child) => nameSet.has(child.name) ? ast.createFunctionParameter({
-					name: child.name,
-					type: child.type,
-					rest: child.rest,
-					optional: true
-				}) : child)
-			};
-		}
-		const fp = param;
-		return nameSet.has(fp.name) ? ast.createFunctionParameter({
-			name: fp.name,
-			type: fp.type,
-			rest: fp.rest,
-			optional: true
-		}) : fp;
-	});
-	return ast.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$9 = 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$9.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/QueryOptions.tsx
-const declarationPrinter$8 = functionPrinter({ mode: "declaration" });
-const callPrinter$8 = functionPrinter({ mode: "call" });
-function getQueryOptionsParams(node, options) {
-	return buildQueryOptionsParams(node, options);
-}
-function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName, suspense }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$8.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const optionalNames = suspense ? [] : enabledNames;
-	const enabledText = suspense ? "" : enabledNames.length ? `enabled: !!(${enabledNames.join(" && ")}),` : "";
-	const paramsNode = markParamsOptional(getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	}), optionalNames);
-	const paramsSignature = declarationPrinter$8.print(paramsNode) ?? "";
-	const clientCallStr = injectNonNullAssertions((callPrinter$8.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }"), optionalNames);
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return queryOptions<${TData}, ${TError}, ${TData}, typeof queryKey>({${enabledText ? `\n       ${enabledText}` : ""}
-       queryKey,
-       queryFn: async ({ signal }) => {
-          return ${clientName}(${clientCallStr})
-       },
-      })
-`
-		})
-	});
-}
-//#endregion
-//#region src/components/InfiniteQuery.tsx
-const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
-const callPrinter$7 = functionPrinter({ mode: "call" });
-function buildInfiniteQueryParamsNode(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = ast.createFunctionParameter({
-		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
-  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
-		default: "{}"
-	});
-	return ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [optionsParam]
-	});
-}
-function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver, initialPageParam, queryParam, customOptions }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const responseType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
-	const fallbackPageParamType = typeof initialPageParam === "number" ? "number" : typeof initialPageParam === "string" ? initialPageParam.includes(" as ") ? (() => {
-		const parts = initialPageParam.split(" as ");
-		return parts[parts.length - 1] ?? "unknown";
-	})() : "string" : typeof initialPageParam === "boolean" ? "boolean" : "unknown";
-	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 : null;
-	})() : null;
-	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
-	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
-	const returnType = "UseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }";
-	const generics = [
-		`TQueryFnData = ${responseType}`,
-		`TError = ${errorType}`,
-		"TData = InfiniteData<TQueryFnData>",
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
-		`TPageParam = ${pageParamType}`
-	];
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$7.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const queryOptionsParamsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const queryOptionsParamsCall = callPrinter$7.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = markParamsOptional(buildInfiniteQueryParamsNode(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		resolver: tsResolver,
-		pageParamGeneric: "TPageParam"
-	}), enabledNames);
-	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			returnType: void 0,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
-
-       const query = useInfiniteQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
-        ...resolvedOptions,
-        queryKey,
-       } as unknown as InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `
-		})
-	});
-}
-//#endregion
-//#region src/components/InfiniteQueryOptions.tsx
-const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
-const callPrinter$6 = functionPrinter({ mode: "call" });
-function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, paramsCasing, paramsType, dataReturnType, pathParamsType, queryParam, queryKeyName }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const queryFnDataType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
-	const fallbackPageParamType = typeof initialPageParam === "number" ? "number" : typeof initialPageParam === "string" ? initialPageParam.includes(" as ") ? (() => {
-		const parts = initialPageParam.split(" as ");
-		return parts[parts.length - 1] ?? "unknown";
-	})() : "string" : typeof initialPageParam === "boolean" ? "boolean" : "unknown";
-	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 : null;
-	})() : null;
-	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
-	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$6.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const enabledText = enabledNames.length ? `enabled: !!(${enabledNames.join(" && ")}),` : "";
-	const paramsNode = markParamsOptional(getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
-	const clientCallStr = injectNonNullAssertions((callPrinter$6.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }"), enabledNames);
-	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];
-		}
-		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,
-		getPreviousPageParamExpr
-	].filter(Boolean);
-	const infiniteOverrideParams = queryParam && queryParamsTypeName ? `params = {
-      ...(params ?? {}),
-      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
-    } as ${queryParamsTypeName}` : "";
-	if (infiniteOverrideParams) return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
-  queryKey,
-  queryFn: async ({ signal, pageParam }) => {
-    ${infiniteOverrideParams}
-    return ${clientName}(${clientCallStr})
-  },
-  ${queryOptionsArr.join(",\n  ")}
-})
-`
-		})
-	});
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
-  queryKey,
-  queryFn: async ({ signal }) => {
-    return ${clientName}(${clientCallStr})
-  },
-  ${queryOptionsArr.join(",\n  ")}
-})
-`
-		})
-	});
-}
-//#endregion
-//#region src/components/MutationOptions.tsx
-const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
-const callPrinter$5 = functionPrinter({ mode: "call" });
-const keysPrinter = functionPrinter({ mode: "keys" });
-function buildMutationConfigParamsNode(node, resolver) {
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
-		name: "config",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: buildRequestConfigType(node, resolver)
-		}),
-		default: "{}"
-	})] });
-}
-function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, mutationKeyName }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const configParamsNode = buildMutationConfigParamsNode(node, tsResolver);
-	const paramsSignature = declarationPrinter$5.print(configParamsNode) ?? "";
-	const mutationArgParamsNode = ast.createOperationParams(node, {
-		paramsType: "inline",
-		pathParamsType: "inline",
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const hasMutationParams = mutationArgParamsNode.params.length > 0;
-	const TRequest = hasMutationParams ? declarationPrinter$5.print(mutationArgParamsNode) ?? "" : "";
-	const argKeysStr = hasMutationParams ? keysPrinter.print(mutationArgParamsNode) ?? "" : "";
-	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: buildRequestConfigType(node, tsResolver)
-			}),
-			default: "{}"
-		})]
-	});
-	const clientCallStr = callPrinter$5.print(clientCallParamsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			generics: ["TContext = unknown"],
-			children: `
-      const mutationKey = ${mutationKeyName}()
-      return mutationOptions<${TData}, ${TError}, ${TRequest ? `{${TRequest}}` : "undefined"}, TContext>({
-        mutationKey,
-        mutationFn: async(${hasMutationParams ? `{ ${argKeysStr} }` : "_"}) => {
-          return ${clientName}(${clientCallStr})
-        },
-      })
-`
-		})
-	});
-}
-//#endregion
-//#region src/components/Mutation.tsx
-const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
-const callPrinter$4 = functionPrinter({ mode: "call" });
-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 successNames = resolveSuccessNames(node, resolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : 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"}>`;
-	const mutationArgParamsNode = createMutationArgParams(node, {
-		paramsCasing,
-		resolver
-	});
-	const TRequest = mutationArgParamsNode.params.length > 0 ? declarationPrinter$4.print(mutationArgParamsNode) ?? "" : "";
-	const generics = [
-		TData,
-		TError,
-		TRequest ? `{${TRequest}}` : "undefined",
-		"TContext"
-	].join(", ");
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
-		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
-  mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
-  client?: ${buildRequestConfigType(node, resolver)},
-}`
-		}),
-		default: "{}"
-	})] });
-}
-function Mutation({ name, mutationOptionsName, paramsCasing, dataReturnType, node, tsResolver, mutationKeyName, customOptions }) {
-	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 : buildStatusUnionType(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const mutationArgParamsNode = createMutationArgParams(node, {
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const TRequest = mutationArgParamsNode.params.length > 0 ? declarationPrinter$4.print(mutationArgParamsNode) ?? "" : "";
-	const generics = [
-		TData,
-		TError,
-		TRequest ? `{${TRequest}}` : "undefined",
-		"TContext"
-	].join(", ");
-	const returnType = `UseMutationResult<${generics}>`;
-	const mutationOptionsConfigNode = buildMutationConfigParamsNode(node, tsResolver);
-	const mutationOptionsParamsCall = callPrinter$4.print(mutationOptionsConfigNode) ?? "";
-	const paramsNode = buildMutationParamsNode(node, {
-		paramsCasing,
-		dataReturnType,
-		resolver: tsResolver
-	});
-	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			generics: ["TContext"],
-			children: `
-        const { mutation = {}, client: config = {} } = options ?? {}
-        const { client: queryClient, ...mutationOptions } = mutation;
-        const mutationKey = mutationOptions.mutationKey ?? ${mutationKeyName}()
-
-        const baseOptions = ${mutationOptionsName}(${mutationOptionsParamsCall}) as UseMutationOptions<${generics}>${customOptions ? `\n        const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' }) as UseMutationOptions<${generics}>` : ""}
-
-        return useMutation<${generics}>({
-          ...baseOptions,${customOptions ? "\n          ...customOptions," : ""}
-          mutationKey,
-          ...mutationOptions,
-        }, queryClient) as ${returnType}
-    `
-		})
-	});
-}
-//#endregion
-//#region src/components/Query.tsx
-const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
-const callPrinter$3 = functionPrinter({ mode: "call" });
-function buildQueryParamsNode(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	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 : buildStatusUnionType(node, resolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = ast.createFunctionParameter({
-		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
-  query?: Partial<QueryObserverOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
-		default: "{}"
-	});
-	return ast.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, customOptions }) {
-	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 : buildStatusUnionType(node, tsResolver);
-	const returnType = `UseQueryResult<TData, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}> & { queryKey: TQueryKey }`;
-	const generics = [
-		`TData = ${TData}`,
-		`TQueryData = ${TData}`,
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
-	];
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const queryOptionsParamsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const queryOptionsParamsCall = callPrinter$3.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = markParamsOptional(buildQueryParamsNode(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			returnType: void 0,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
-
-       const query = useQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
-        ...resolvedOptions,
-        queryKey,
-       } as unknown as QueryObserverOptions, queryClient) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `
-		})
-	});
-}
-//#endregion
-//#region src/components/SuspenseInfiniteQuery.tsx
-const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
-const callPrinter$2 = functionPrinter({ mode: "call" });
-function buildSuspenseInfiniteQueryParamsNode(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = ast.createFunctionParameter({
-		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
-  query?: Partial<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
-		default: "{}"
-	});
-	return ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [optionsParam]
-	});
-}
-function SuspenseInfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver, customOptions, initialPageParam, queryParam }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const responseType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
-	const fallbackPageParamType = typeof initialPageParam === "number" ? "number" : typeof initialPageParam === "string" ? initialPageParam.includes(" as ") ? (() => {
-		const parts = initialPageParam.split(" as ");
-		return parts[parts.length - 1] ?? "unknown";
-	})() : "string" : typeof initialPageParam === "boolean" ? "boolean" : "unknown";
-	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 : null;
-	})() : null;
-	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
-	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
-	const returnType = "UseSuspenseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }";
-	const generics = [
-		`TQueryFnData = ${responseType}`,
-		`TError = ${errorType}`,
-		"TData = InfiniteData<TQueryFnData>",
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
-		`TPageParam = ${pageParamType}`
-	];
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
-	const queryOptionsParamsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const queryOptionsParamsCall = callPrinter$2.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = buildSuspenseInfiniteQueryParamsNode(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		resolver: tsResolver,
-		pageParamGeneric: "TPageParam"
-	});
-	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			returnType: void 0,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
-
-       const query = useSuspenseInfiniteQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
-        ...resolvedOptions,
-        queryKey,
-       } as unknown as UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `
-		})
-	});
-}
-//#endregion
-//#region src/components/SuspenseInfiniteQueryOptions.tsx
-const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
-const callPrinter$1 = functionPrinter({ mode: "call" });
-function SuspenseInfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, paramsCasing, paramsType, dataReturnType, pathParamsType, queryParam, queryKeyName }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const queryFnDataType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
-	const fallbackPageParamType = typeof initialPageParam === "number" ? "number" : typeof initialPageParam === "string" ? initialPageParam.includes(" as ") ? (() => {
-		const parts = initialPageParam.split(" as ");
-		return parts[parts.length - 1] ?? "unknown";
-	})() : "string" : typeof initialPageParam === "boolean" ? "boolean" : "unknown";
-	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 : null;
-	})() : null;
-	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
-	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
-	const paramsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
-	const clientCallStr = (callPrinter$1.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$1.print(queryKeyParamsNode) ?? "";
-	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];
-		}
-		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,
-		getPreviousPageParamExpr
-	].filter(Boolean);
-	const infiniteOverrideParams = queryParam && queryParamsTypeName ? `params = {
-      ...(params ?? {}),
-      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
-    } as ${queryParamsTypeName}` : "";
-	if (infiniteOverrideParams) return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
-  queryKey,
-  queryFn: async ({ signal, pageParam }) => {
-    ${infiniteOverrideParams}
-    return ${clientName}(${clientCallStr})
-  },
-  ${queryOptionsArr.join(",\n  ")}
-})
-`
-		})
-	});
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
-  queryKey,
-  queryFn: async ({ signal }) => {
-    return ${clientName}(${clientCallStr})
-  },
-  ${queryOptionsArr.join(",\n  ")}
-})
-`
-		})
-	});
-}
-//#endregion
-//#region src/components/SuspenseQuery.tsx
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-const callPrinter = functionPrinter({ mode: "call" });
-function buildSuspenseQueryParamsNode(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	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 : buildStatusUnionType(node, resolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = ast.createFunctionParameter({
-		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
-  query?: Partial<UseSuspenseQueryOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
-		default: "{}"
-	});
-	return ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [optionsParam]
-	});
-}
-function SuspenseQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver, customOptions }) {
-	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 : buildStatusUnionType(node, tsResolver);
-	const returnType = `UseSuspenseQueryResult<TData, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}> & { queryKey: TQueryKey }`;
-	const generics = [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`];
-	const queryKeyParamsNode = buildQueryKeyParams(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
-	const queryOptionsParamsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = buildSuspenseQueryParamsNode(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		resolver: tsResolver
-	});
-	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			returnType: void 0,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
-
-       const query = useSuspenseQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
-        ...resolvedOptions,
-        queryKey,
-       } as unknown as UseSuspenseQueryOptions, queryClient) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `
-		})
-	});
-}
-//#endregion
-export { operationFileEntry as _, Mutation as a, InfiniteQuery as c, queryKeyTransformer as d, resolveOperationOverrides as f, getOperationParameters as g, mutationKeyTransformer as h, Query as i, QueryOptions as l, MutationKey as m, SuspenseInfiniteQueryOptions as n, MutationOptions as o, resolveZodSchemaNames as p, SuspenseInfiniteQuery as r, InfiniteQueryOptions as s, SuspenseQuery as t, QueryKey as u, resolveOperationTypeNames as v, camelCase as y };
-
-//# sourceMappingURL=components-DL0Cai7l.js.map