@kubb/plugin-react-query 5.0.0-alpha.9 → 5.0.0-beta.3

package/dist/components-DTGLu4UV.js

@@ -0,0 +1,1451 @@
+import { t as __name } from "./chunk--u3MIqq1.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";
+//#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/object.ts
+/**
+* Converts a dot-notation path or string array into an optional-chaining accessor expression.
+*
+* @example
+* getNestedAccessor('pagination.next.id', 'lastPage')
+* // → "lastPage?.['pagination']?.['next']?.['id']"
+*/
+function getNestedAccessor(param, accessor) {
+	const parts = Array.isArray(param) ? param : param.split(".");
+	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+}
+//#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/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 ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$10 = functionPrinter({ mode: "declaration" });
+function getParams$6() {
+	return ast.createFunctionParameters({ params: [] });
+}
+__name(getParams$6, "getParams");
+const getTransformer$1 = /* @__PURE__ */ __name(({ node, casing }) => {
+	return [`{ url: '${new URLPath(node.path, { casing }).toURLPath()}' }`];
+}, "getTransformer");
+function MutationKey({ name, paramsCasing, node, transformer = getTransformer$1 }) {
+	const paramsNode = getParams$6();
+	const paramsSignature = declarationPrinter$10.print(paramsNode) ?? "";
+	const keys = transformer({
+		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`
+		})
+	});
+}
+MutationKey.getParams = getParams$6;
+MutationKey.getTransformer = getTransformer$1;
+//#endregion
+//#region ../../internals/tanstack-query/src/utils.ts
+/**
+* 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;
+	}).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?.content?.[0]?.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?.content?.[0]?.schema ? ast.createParamsType({
+		variant: "reference",
+		name: resolver.resolveDataName(node)
+	}) : void 0;
+	const bodyRequired = node.requestBody?.required ?? false;
+	const params = [];
+	for (const p of pathParams) params.push(ast.createFunctionParameter({
+		name: p.name,
+		type: resolvePathParamType(node, p, resolver),
+		optional: !p.required
+	}));
+	if (bodyType) params.push(ast.createFunctionParameter({
+		name: "data",
+		type: bodyType,
+		optional: !bodyRequired
+	}));
+	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
+	params.push(...buildGroupParam("headers", node, headerParams, headerGroupType, resolver));
+	return ast.createFunctionParameters({ params });
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/QueryKey.tsx
+const declarationPrinter$9 = functionPrinter({ mode: "declaration" });
+const callPrinter$9 = functionPrinter({ mode: "call" });
+function getParams$5(node, options) {
+	return buildQueryKeyParams(node, options);
+}
+__name(getParams$5, "getParams");
+const getTransformer = ({ node, casing }) => {
+	const path = new URLPath(node.path, { casing });
+	const hasQueryParams = node.parameters.some((p) => p.in === "query");
+	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
+	return [
+		path.toObject({
+			type: "path",
+			stringify: true
+		}),
+		hasQueryParams ? "...(params ? [params] : [])" : void 0,
+		hasRequestBody ? "...(data ? [data] : [])" : void 0
+	].filter(Boolean);
+};
+function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer = getTransformer }) {
+	const paramsNode = getParams$5(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$9.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.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}>`
+		})
+	})] });
+}
+QueryKey.getParams = getParams$5;
+QueryKey.getTransformer = getTransformer;
+QueryKey.callPrinter = callPrinter$9;
+//#endregion
+//#region src/utils.ts
+function transformName(name, type, transformers) {
+	return transformers?.name?.(name, type) || name;
+}
+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 matches(node.path);
+	if (type === "method") return matches(node.method);
+	return false;
+}
+/**
+* Resolves per-operation overrides (first matching override wins), mirroring v4 OperationGenerator.getOptions().
+*/
+function resolveOperationOverrides(node, override) {
+	if (!override) return {};
+	return override.find((ov) => matchesPattern(node, ov))?.options ?? {};
+}
+//#endregion
+//#region src/components/QueryOptions.tsx
+const declarationPrinter$8 = functionPrinter({ mode: "declaration" });
+const callPrinter$8 = functionPrinter({ mode: "call" });
+function getQueryOptionsParams(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	return 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 buildEnabledCheck(paramsNode) {
+	const required = [];
+	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
+		const group = param;
+		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
+	} else {
+		const fp = param;
+		if (!fp.optional && fp.default === void 0) required.push(fp.name);
+	}
+	return required.join(" && ");
+}
+function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const paramsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$8.print(paramsNode) ?? "";
+	const clientCallStr = (callPrinter$8.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
+	const queryKeyParamsNode = QueryKey.getParams(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$8.print(queryKeyParamsNode) ?? "";
+	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
+	const enabledText = enabledSource ? `enabled: !!(${enabledSource}),` : "";
+	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}
+       queryKey,
+       queryFn: async ({ signal }) => {
+          return ${clientName}(${clientCallStr})
+       },
+      })
+`
+		})
+	});
+}
+QueryOptions.getParams = getQueryOptionsParams;
+//#endregion
+//#region src/components/InfiniteQuery.tsx
+const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
+const callPrinter$7 = functionPrinter({ mode: "call" });
+function getParams$4(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	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]
+	});
+}
+__name(getParams$4, "getParams");
+function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver, initialPageParam, queryParam, customOptions }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const responseType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 = node.parameters.filter((p) => p.in === "query");
+	const queryParamsTypeName = rawQueryParams.length > 0 ? (() => {
+		const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]);
+		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : void 0;
+	})() : void 0;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : void 0;
+	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 = QueryKey.getParams(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$7.print(queryKeyParamsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const queryOptionsParamsCall = callPrinter$7.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = getParams$4(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		resolver: tsResolver,
+		pageParamGeneric: "TPageParam"
+	});
+	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: getComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
+       ${customOptions ? `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
+       `
+		})
+	});
+}
+InfiniteQuery.getParams = getParams$4;
+//#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 responseName = tsResolver.resolveResponseName(node);
+	const queryFnDataType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 = node.parameters.filter((p) => p.in === "query");
+	const queryParamsTypeName = rawQueryParams.length > 0 ? (() => {
+		const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]);
+		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : void 0;
+	})() : void 0;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : void 0;
+	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
+	const paramsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
+	const clientCallStr = (callPrinter$6.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
+	const queryKeyParamsNode = QueryKey.getParams(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$6.print(queryKeyParamsNode) ?? "";
+	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
+	const enabledText = enabledSource ? `enabled: !!(${enabledSource}),` : "";
+	const hasNewParams = nextParam !== void 0 || previousParam !== void 0;
+	let getNextPageParamExpr;
+	let getPreviousPageParamExpr;
+	if (hasNewParams) {
+		if (nextParam) {
+			const accessor = getNestedAccessor(nextParam, "lastPage");
+			if (accessor) getNextPageParamExpr = `getNextPageParam: (lastPage) => ${accessor}`;
+		}
+		if (previousParam) {
+			const accessor = getNestedAccessor(previousParam, "firstPage");
+			if (accessor) getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => ${accessor}`;
+		}
+	} else if (cursorParam) {
+		getNextPageParamExpr = `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`;
+		getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`;
+	} else {
+		if (dataReturnType === "full") getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1";
+		else getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1";
+		getPreviousPageParamExpr = "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1";
+	}
+	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}
+       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}
+       queryKey,
+       queryFn: async ({ signal }) => {
+          return ${clientName}(${clientCallStr})
+        },
+       ${queryOptionsArr.join(",\n")}
+      })
+`
+		})
+	});
+}
+InfiniteQueryOptions.getParams = (node, options) => getQueryOptionsParams(node, options);
+//#endregion
+//#region src/components/MutationOptions.tsx
+const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
+const callPrinter$5 = functionPrinter({ mode: "call" });
+const keysPrinter = functionPrinter({ mode: "keys" });
+function getConfigParam(node, resolver) {
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+		name: "config",
+		type: ast.createParamsType({
+			variant: "reference",
+			name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+		}),
+		default: "{}"
+	})] });
+}
+function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, mutationKeyName }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const configParamsNode = getConfigParam(node, tsResolver);
+	const paramsSignature = declarationPrinter$5.print(configParamsNode) ?? "";
+	const mutationArgParamsNode = buildMutationArgParams(node, {
+		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: node.requestBody?.content?.[0]?.schema ? `Partial<RequestConfig<${tsResolver.resolveDataName(node)}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+			}),
+			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}}` : "void"}, TContext>({
+        mutationKey,
+        mutationFn: async(${hasMutationParams ? `{ ${argKeysStr} }` : "_"}) => {
+          return ${clientName}(${clientCallStr})
+        },
+      })
+`
+		})
+	});
+}
+MutationOptions.getParams = getConfigParam;
+//#endregion
+//#region src/components/Mutation.tsx
+const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
+const callPrinter$4 = functionPrinter({ mode: "call" });
+function getParams$3(node, options) {
+	const { paramsCasing, dataReturnType, resolver } = options;
+	const responseName = resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const mutationArgParamsNode = buildMutationArgParams(node, {
+		paramsCasing,
+		resolver
+	});
+	const TRequest = mutationArgParamsNode.params.length > 0 ? declarationPrinter$4.print(mutationArgParamsNode) ?? "" : "";
+	const generics = [
+		TData,
+		TError,
+		TRequest ? `{${TRequest}}` : "void",
+		"TContext"
+	].join(", ");
+	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+		name: "options",
+		type: ast.createParamsType({
+			variant: "reference",
+			name: `{
+  mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
+}`
+		}),
+		default: "{}"
+	})] });
+}
+__name(getParams$3, "getParams");
+function Mutation({ name, mutationOptionsName, paramsCasing, dataReturnType, node, tsResolver, mutationKeyName, customOptions }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const mutationArgParamsNode = buildMutationArgParams(node, {
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const TRequest = mutationArgParamsNode.params.length > 0 ? declarationPrinter$4.print(mutationArgParamsNode) ?? "" : "";
+	const generics = [
+		TData,
+		TError,
+		TRequest ? `{${TRequest}}` : "void",
+		"TContext"
+	].join(", ");
+	const returnType = `UseMutationResult<${generics}>`;
+	const mutationOptionsConfigNode = MutationOptions.getParams(node, tsResolver);
+	const mutationOptionsParamsCall = callPrinter$4.print(mutationOptionsConfigNode) ?? "";
+	const paramsNode = getParams$3(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: getComments(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 ? `const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' }) as UseMutationOptions<${generics}>` : ""}
+
+        return useMutation<${generics}>({
+          ...baseOptions,${customOptions ? "\n...customOptions," : ""}
+          mutationKey,
+          ...mutationOptions,
+        }, queryClient) as ${returnType}
+    `
+		})
+	});
+}
+Mutation.getParams = getParams$3;
+//#endregion
+//#region src/components/Query.tsx
+const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
+const callPrinter$3 = functionPrinter({ mode: "call" });
+function getParams$2(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
+	const responseName = resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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]
+	});
+}
+__name(getParams$2, "getParams");
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver, customOptions }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 = QueryKey.getParams(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const queryOptionsParamsCall = callPrinter$3.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = getParams$2(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		resolver: tsResolver
+	});
+	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: getComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
+       ${customOptions ? `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
+       `
+		})
+	});
+}
+Query.getParams = getParams$2;
+//#endregion
+//#region src/components/SuspenseInfiniteQuery.tsx
+const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
+const callPrinter$2 = functionPrinter({ mode: "call" });
+function getParams$1(node, options) {
+	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	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]
+	});
+}
+__name(getParams$1, "getParams");
+function SuspenseInfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver, customOptions, initialPageParam, queryParam }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const responseType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 = node.parameters.filter((p) => p.in === "query");
+	const queryParamsTypeName = rawQueryParams.length > 0 ? (() => {
+		const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]);
+		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : void 0;
+	})() : void 0;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : void 0;
+	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 = QueryKey.getParams(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 = getParams$1(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: getComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
+       ${customOptions ? `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
+       `
+		})
+	});
+}
+SuspenseInfiniteQuery.getParams = getParams$1;
+//#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 responseName = tsResolver.resolveResponseName(node);
+	const queryFnDataType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 = node.parameters.filter((p) => p.in === "query");
+	const queryParamsTypeName = rawQueryParams.length > 0 ? (() => {
+		const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]);
+		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : void 0;
+	})() : void 0;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : void 0;
+	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 = QueryKey.getParams(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$1.print(queryKeyParamsNode) ?? "";
+	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
+	const enabledText = enabledSource ? `enabled: !!(${enabledSource}),` : "";
+	const hasNewParams = nextParam !== void 0 || previousParam !== void 0;
+	let getNextPageParamExpr;
+	let getPreviousPageParamExpr;
+	if (hasNewParams) {
+		if (nextParam) {
+			const accessor = getNestedAccessor(nextParam, "lastPage");
+			if (accessor) getNextPageParamExpr = `getNextPageParam: (lastPage) => ${accessor}`;
+		}
+		if (previousParam) {
+			const accessor = getNestedAccessor(previousParam, "firstPage");
+			if (accessor) getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => ${accessor}`;
+		}
+	} else if (cursorParam) {
+		getNextPageParamExpr = `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`;
+		getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`;
+	} else {
+		if (dataReturnType === "full") getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1";
+		else getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1";
+		getPreviousPageParamExpr = "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1";
+	}
+	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}
+       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}
+       queryKey,
+       queryFn: async ({ signal }) => {
+          return ${clientName}(${clientCallStr})
+        },
+       ${queryOptionsArr.join(",\n")}
+     })
+`
+		})
+	});
+}
+SuspenseInfiniteQueryOptions.getParams = (node, options) => getQueryOptionsParams(node, options);
+//#endregion
+//#region src/components/SuspenseQuery.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?.content?.[0]?.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?: 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 responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const returnType = `UseSuspenseQueryResult<TData, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}> & { queryKey: TQueryKey }`;
+	const generics = [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`];
+	const queryKeyParamsNode = QueryKey.getParams(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 = getParams(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: getComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})
+       ${customOptions ? `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
+       `
+		})
+	});
+}
+SuspenseQuery.getParams = getParams;
+//#endregion
+export { Mutation as a, InfiniteQuery as c, transformName as d, QueryKey as f, Query as i, QueryOptions as l, camelCase as m, SuspenseInfiniteQueryOptions as n, MutationOptions as o, MutationKey as p, SuspenseInfiniteQuery as r, InfiniteQueryOptions as s, SuspenseQuery as t, resolveOperationOverrides as u };
+
+//# sourceMappingURL=components-DTGLu4UV.js.map