@kubb/plugin-react-query 4.0.2 → 4.1.1

package/dist/{components-BRLaeCYI.js → components-Dz_s6t75.js}

@@ -1,177 +1,12 @@
-import { File, Function, FunctionParams, Type } from "@kubb/react";
 import { isOptional } from "@kubb/oas";
-import { Client } from "@kubb/plugin-client/components";
 import { getComments, getPathParams } from "@kubb/plugin-oas/utils";
+import { File, Function, FunctionParams, Type } from "@kubb/react";
 import { URLPath } from "@kubb/core/utils";
 import { Fragment, jsx, jsxs } from "@kubb/react/jsx-runtime";
+import { Client } from "@kubb/plugin-client/components";
 
-//#region src/components/MutationKey.tsx
-function getParams$7({}) {
-	return FunctionParams.factory({});
-}
-const getTransformer$1 = ({ operation, casing }) => {
-	return [`{ url: '${new URLPath(operation.path, { casing }).toURLPath()}' }`];
-};
-function MutationKey({ name, typeSchemas, pathParamsType, paramsCasing, operation, typeName, transformer = getTransformer$1 }) {
-	const params = getParams$7({
-		pathParamsType,
-		typeSchemas
-	});
-	const keys = transformer({
-		operation,
-		schemas: typeSchemas,
-		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: params.toConstructor(),
-			singleLine: true,
-			children: `[${keys.join(", ")}] as const`
-		})
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: true,
-		children: /* @__PURE__ */ jsx(Type, {
-			name: typeName,
-			export: true,
-			children: `ReturnType<typeof ${name}>`
-		})
-	})] });
-}
-MutationKey.getParams = getParams$7;
-MutationKey.getTransformer = getTransformer$1;
-
-//#endregion
-//#region src/components/Mutation.tsx
-function getParams$6({ paramsCasing, dataReturnType, typeSchemas }) {
-	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
-	const TRequest = FunctionParams.factory({
-		...getPathParams(typeSchemas.pathParams, {
-			typed: true,
-			casing: paramsCasing
-		}),
-		data: typeSchemas.request?.name ? {
-			type: typeSchemas.request?.name,
-			optional: isOptional(typeSchemas.request?.schema)
-		} : void 0,
-		params: typeSchemas.queryParams?.name ? {
-			type: typeSchemas.queryParams?.name,
-			optional: isOptional(typeSchemas.queryParams?.schema)
-		} : void 0,
-		headers: typeSchemas.headerParams?.name ? {
-			type: typeSchemas.headerParams?.name,
-			optional: isOptional(typeSchemas.headerParams?.schema)
-		} : void 0
-	}).toConstructor();
-	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
-	const generics = [
-		TData,
-		TError,
-		TRequest ? `{${TRequest}}` : "void",
-		"TContext"
-	].join(", ");
-	return FunctionParams.factory({ options: {
-		type: `
-{
-  mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: typeof fetch }` : "Partial<RequestConfig> & { client?: typeof fetch }"},
-}
-`,
-		default: "{}"
-	} });
-}
-function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType, dataReturnType, typeSchemas, operation, mutationKeyName }) {
-	const mutationKeyParams = MutationKey.getParams({
-		pathParamsType,
-		typeSchemas
-	});
-	const params = getParams$6({
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		typeSchemas
-	});
-	const clientParams = Client.getParams({
-		paramsCasing,
-		paramsType,
-		typeSchemas,
-		pathParamsType,
-		isConfigurable: true
-	});
-	const mutationParams = FunctionParams.factory({
-		...getPathParams(typeSchemas.pathParams, {
-			typed: true,
-			casing: paramsCasing
-		}),
-		data: typeSchemas.request?.name ? {
-			type: typeSchemas.request?.name,
-			optional: isOptional(typeSchemas.request?.schema)
-		} : void 0,
-		params: typeSchemas.queryParams?.name ? {
-			type: typeSchemas.queryParams?.name,
-			optional: isOptional(typeSchemas.queryParams?.schema)
-		} : void 0,
-		headers: typeSchemas.headerParams?.name ? {
-			type: typeSchemas.headerParams?.name,
-			optional: isOptional(typeSchemas.headerParams?.schema)
-		} : void 0
-	});
-	const dataParams = FunctionParams.factory({ data: {
-		mode: "object",
-		children: Object.entries(mutationParams.params).reduce((acc, [key, value]) => {
-			if (value) acc[key] = {
-				...value,
-				type: void 0
-			};
-			return acc;
-		}, {})
-	} });
-	const TRequest = mutationParams.toConstructor();
-	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
-	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
-	const generics = [
-		TData,
-		TError,
-		TRequest ? `{${TRequest}}` : "void",
-		"TContext"
-	].join(", ");
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: params.toConstructor(),
-			JSDoc: { comments: getComments(operation) },
-			generics: ["TContext"],
-			children: `
-        const { mutation = {}, client: config = {} } = options ?? {}
-        const { client: queryClient, ...mutationOptions } = mutation;
-        const mutationKey = mutationOptions.mutationKey ?? ${mutationKeyName}(${mutationKeyParams.toCall()})
-
-        return useMutation<${generics}>({
-          mutationFn: async(${dataParams.toConstructor()}) => {
-            return ${clientName}(${clientParams.toCall()})
-          },
-          mutationKey,
-          ...mutationOptions
-        }, queryClient)
-    `
-		})
-	});
-}
-
-//#endregion
 //#region src/components/QueryKey.tsx
-function getParams$5({ pathParamsType, paramsCasing, typeSchemas }) {
+function getParams$8({ pathParamsType, paramsCasing, typeSchemas }) {
 	return FunctionParams.factory({
 		pathParams: {
 			mode: pathParamsType === "object" ? "object" : "inlineSpread",
@@ -190,7 +25,7 @@ function getParams$5({ pathParamsType, paramsCasing, typeSchemas }) {
 		} : void 0
 	});
 }
-const getTransformer = ({ operation, schemas, casing }) => {
+const getTransformer$1 = ({ operation, schemas, casing }) => {
 	return [
 		new URLPath(operation.path, { casing }).toObject({
 			type: "path",
@@ -200,8 +35,8 @@ const getTransformer = ({ operation, schemas, casing }) => {
 		schemas.request?.name ? "...(data ? [data] : [])" : void 0
 	].filter(Boolean);
 };
-function QueryKey({ name, typeSchemas, paramsCasing, pathParamsType, operation, typeName, transformer = getTransformer }) {
-	const params = getParams$5({
+function QueryKey({ name, typeSchemas, paramsCasing, pathParamsType, operation, typeName, transformer = getTransformer$1 }) {
+	const params = getParams$8({
 		pathParamsType,
 		typeSchemas,
 		paramsCasing
@@ -234,12 +69,12 @@ function QueryKey({ name, typeSchemas, paramsCasing, pathParamsType, operation,
 		})
 	})] });
 }
-QueryKey.getParams = getParams$5;
-QueryKey.getTransformer = getTransformer;
+QueryKey.getParams = getParams$8;
+QueryKey.getTransformer = getTransformer$1;
 
 //#endregion
 //#region src/components/QueryOptions.tsx
-function getParams$4({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
+function getParams$7({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
 	if (paramsType === "object") return FunctionParams.factory({
 		data: {
 			mode: "object",
@@ -295,7 +130,7 @@ function getParams$4({ paramsType, paramsCasing, pathParamsType, typeSchemas })
 	});
 }
 function QueryOptions({ name, clientName, dataReturnType, typeSchemas, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
-	const params = getParams$4({
+	const params = getParams$7({
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -339,13 +174,11 @@ function QueryOptions({ name, clientName, dataReturnType, typeSchemas, paramsCas
 		})
 	});
 }
-QueryOptions.getParams = getParams$4;
+QueryOptions.getParams = getParams$7;
 
 //#endregion
-//#region src/components/Query.tsx
-function getParams$3({ paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas }) {
-	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
-	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+//#region src/components/InfiniteQuery.tsx
+function getParams$6({ paramsType, paramsCasing, pathParamsType, typeSchemas, pageParamGeneric }) {
 	if (paramsType === "object") return FunctionParams.factory({
 		data: {
 			mode: "object",
@@ -371,13 +204,7 @@ function getParams$3({ paramsType, paramsCasing, pathParamsType, dataReturnType,
 		options: {
 			type: `
 {
-  query?: Partial<QueryObserverOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: typeof fetch }` : "Partial<RequestConfig> & { client?: typeof fetch }"}
 }
 `,
@@ -408,13 +235,7 @@ function getParams$3({ paramsType, paramsCasing, pathParamsType, dataReturnType,
 		options: {
 			type: `
 {
-  query?: Partial<QueryObserverOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: typeof fetch }` : "Partial<RequestConfig> & { client?: typeof fetch }"}
 }
 `,
@@ -422,13 +243,17 @@ function getParams$3({ paramsType, paramsCasing, pathParamsType, dataReturnType,
 		}
 	});
 }
-function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas, operation }) {
-	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
-	const returnType = `UseQueryResult<${["TData", `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`].join(", ")}> & { queryKey: TQueryKey }`;
+function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas, operation, queryParam }) {
+	const responseType = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const errorType = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const pageParamType = (queryParam && typeSchemas.queryParams?.name ? `NonNullable<${typeSchemas.queryParams?.name}['${queryParam}']>` : void 0) ?? "number";
+	const returnType = "UseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }";
 	const generics = [
-		`TData = ${TData}`,
-		`TQueryData = ${TData}`,
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
+		`TQueryFnData = ${responseType}`,
+		`TError = ${errorType}`,
+		"TData = InfiniteData<TQueryFnData>",
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
+		`TPageParam = ${pageParamType}`
 	];
 	const queryKeyParams = QueryKey.getParams({
 		pathParamsType,
@@ -441,12 +266,12 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		typeSchemas,
 		paramsCasing
 	});
-	const params = getParams$3({
+	const params = getParams$6({
 		paramsCasing,
 		paramsType,
 		pathParamsType,
-		dataReturnType,
-		typeSchemas
+		typeSchemas,
+		pageParamGeneric: "TPageParam"
 	});
 	const queryOptions = `${queryOptionsName}(${queryOptionsParams.toCall()})`;
 	return /* @__PURE__ */ jsx(File.Source, {
@@ -464,11 +289,11 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
        const { client: queryClient, ...queryOptions } = queryConfig
        const queryKey = queryOptions?.queryKey ?? ${queryKeyName}(${queryKeyParams.toCall()})
 
-       const query = useQuery({
+       const query = useInfiniteQuery({
         ...${queryOptions},
         queryKey,
         ...queryOptions
-       } as unknown as QueryObserverOptions, queryClient) as ${returnType}
+       } as unknown as InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
 
        query.queryKey = queryKey as TQueryKey
 
@@ -477,11 +302,11 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 		})
 	});
 }
-Query.getParams = getParams$3;
+InfiniteQuery.getParams = getParams$6;
 
 //#endregion
 //#region src/components/InfiniteQueryOptions.tsx
-function getParams$2({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
+function getParams$5({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
 	if (paramsType === "object") return FunctionParams.factory({
 		data: {
 			mode: "object",
@@ -540,7 +365,7 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 	const queryFnDataType = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
 	const errorType = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
 	const pageParamType = queryParam && typeSchemas.queryParams?.name ? `NonNullable<${typeSchemas.queryParams?.name}['${queryParam}']>` : "number";
-	const params = getParams$2({
+	const params = getParams$5({
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -619,11 +444,235 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam,
 		})
 	});
 }
-InfiniteQueryOptions.getParams = getParams$2;
+InfiniteQueryOptions.getParams = getParams$5;
 
 //#endregion
-//#region src/components/InfiniteQuery.tsx
-function getParams$1({ paramsType, paramsCasing, pathParamsType, typeSchemas, pageParamGeneric }) {
+//#region src/components/MutationKey.tsx
+function getParams$4({}) {
+	return FunctionParams.factory({});
+}
+const getTransformer = ({ operation, casing }) => {
+	return [`{ url: '${new URLPath(operation.path, { casing }).toURLPath()}' }`];
+};
+function MutationKey({ name, typeSchemas, pathParamsType, paramsCasing, operation, typeName, transformer = getTransformer }) {
+	const params = getParams$4({
+		pathParamsType,
+		typeSchemas
+	});
+	const keys = transformer({
+		operation,
+		schemas: typeSchemas,
+		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: params.toConstructor(),
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			export: true,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+MutationKey.getParams = getParams$4;
+MutationKey.getTransformer = getTransformer;
+
+//#endregion
+//#region src/components/MutationOptions.tsx
+function getParams$3({ typeSchemas }) {
+	return FunctionParams.factory({ config: {
+		type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: typeof fetch }` : "Partial<RequestConfig> & { client?: typeof fetch }",
+		default: "{}"
+	} });
+}
+function MutationOptions({ name, clientName, dataReturnType, typeSchemas, paramsCasing, paramsType, pathParamsType, mutationKeyName }) {
+	const params = getParams$3({ typeSchemas });
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error";
+	const clientParams = Client.getParams({
+		typeSchemas,
+		paramsCasing,
+		paramsType,
+		pathParamsType,
+		isConfigurable: true
+	});
+	const mutationKeyParams = MutationKey.getParams({
+		pathParamsType,
+		typeSchemas
+	});
+	const mutationParams = FunctionParams.factory({
+		...getPathParams(typeSchemas.pathParams, {
+			typed: true,
+			casing: paramsCasing
+		}),
+		data: typeSchemas.request?.name ? {
+			type: typeSchemas.request?.name,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: typeSchemas.queryParams?.name,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: typeSchemas.headerParams?.name,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0
+	});
+	const dataParams = FunctionParams.factory({ data: {
+		mode: "object",
+		children: Object.entries(mutationParams.params).reduce((acc, [key, value]) => {
+			if (value) acc[key] = {
+				...value,
+				type: void 0
+			};
+			return acc;
+		}, {})
+	} });
+	const TRequest = mutationParams.toConstructor();
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			children: `
+      const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
+      return mutationOptions<${TData}, ResponseErrorConfig<${TError}>, ${TRequest ? `{${TRequest}}` : "void"}, typeof mutationKey>({
+        mutationKey,
+        mutationFn: async(${dataParams.toConstructor()}) => {
+          return ${clientName}(${clientParams.toCall()})
+        },
+      })
+`
+		})
+	});
+}
+MutationOptions.getParams = getParams$3;
+
+//#endregion
+//#region src/components/Mutation.tsx
+function getParams$2({ paramsCasing, dataReturnType, typeSchemas }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TRequest = FunctionParams.factory({
+		...getPathParams(typeSchemas.pathParams, {
+			typed: true,
+			casing: paramsCasing
+		}),
+		data: typeSchemas.request?.name ? {
+			type: typeSchemas.request?.name,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: typeSchemas.queryParams?.name,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: typeSchemas.headerParams?.name,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0
+	}).toConstructor();
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const generics = [
+		TData,
+		TError,
+		TRequest ? `{${TRequest}}` : "void",
+		"TContext"
+	].join(", ");
+	return FunctionParams.factory({ options: {
+		type: `
+{
+  mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: typeof fetch }` : "Partial<RequestConfig> & { client?: typeof fetch }"},
+}
+`,
+		default: "{}"
+	} });
+}
+function Mutation({ name, mutationOptionsName, paramsCasing, pathParamsType, dataReturnType, typeSchemas, operation, mutationKeyName }) {
+	const mutationKeyParams = MutationKey.getParams({
+		pathParamsType,
+		typeSchemas
+	});
+	const params = getParams$2({
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		typeSchemas
+	});
+	const mutationParams = FunctionParams.factory({
+		...getPathParams(typeSchemas.pathParams, {
+			typed: true,
+			casing: paramsCasing
+		}),
+		data: typeSchemas.request?.name ? {
+			type: typeSchemas.request?.name,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: typeSchemas.queryParams?.name,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: typeSchemas.headerParams?.name,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0
+	});
+	const mutationOptionsParams = MutationOptions.getParams({ typeSchemas });
+	const TRequest = mutationParams.toConstructor();
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const returnType = `UseMutationOptions<${[
+		TData,
+		TError,
+		TRequest ? `{${TRequest}}` : "void",
+		"TContext"
+	].join(", ")}>`;
+	const mutationOptions = `${mutationOptionsName}(${mutationOptionsParams.toCall()})`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			JSDoc: { comments: getComments(operation) },
+			generics: ["TContext"],
+			children: `
+        const { mutation = {}, client: config = {} } = options ?? {}
+        const { client: queryClient, ...mutationOptions } = mutation;
+        const mutationKey = mutationOptions.mutationKey ?? ${mutationKeyName}(${mutationKeyParams.toCall()})
+
+        return useMutation({
+          ...${mutationOptions},
+          mutationKey,
+          ...mutationOptions
+        } as unknown as UseMutationOptions, queryClient) as ${returnType}
+    `
+		})
+	});
+}
+
+//#endregion
+//#region src/components/Query.tsx
+function getParams$1({ paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
 	if (paramsType === "object") return FunctionParams.factory({
 		data: {
 			mode: "object",
@@ -649,7 +698,13 @@ function getParams$1({ paramsType, paramsCasing, pathParamsType, typeSchemas, pa
 		options: {
 			type: `
 {
-  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
+  query?: Partial<QueryObserverOptions<${[
+				TData,
+				TError,
+				"TData",
+				"TQueryData",
+				"TQueryKey"
+			].join(", ")}>> & { client?: QueryClient },
   client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: typeof fetch }` : "Partial<RequestConfig> & { client?: typeof fetch }"}
 }
 `,
@@ -680,7 +735,13 @@ function getParams$1({ paramsType, paramsCasing, pathParamsType, typeSchemas, pa
 		options: {
 			type: `
 {
-  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
+  query?: Partial<QueryObserverOptions<${[
+				TData,
+				TError,
+				"TData",
+				"TQueryData",
+				"TQueryKey"
+			].join(", ")}>> & { client?: QueryClient },
   client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: typeof fetch }` : "Partial<RequestConfig> & { client?: typeof fetch }"}
 }
 `,
@@ -688,17 +749,13 @@ function getParams$1({ paramsType, paramsCasing, pathParamsType, typeSchemas, pa
 		}
 	});
 }
-function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas, operation, queryParam }) {
-	const responseType = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
-	const errorType = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
-	const pageParamType = (queryParam && typeSchemas.queryParams?.name ? `NonNullable<${typeSchemas.queryParams?.name}['${queryParam}']>` : void 0) ?? "number";
-	const returnType = "UseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }";
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas, operation }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const returnType = `UseQueryResult<${["TData", `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`].join(", ")}> & { queryKey: TQueryKey }`;
 	const generics = [
-		`TQueryFnData = ${responseType}`,
-		`TError = ${errorType}`,
-		"TData = InfiniteData<TQueryFnData>",
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
-		`TPageParam = ${pageParamType}`
+		`TData = ${TData}`,
+		`TQueryData = ${TData}`,
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
 	];
 	const queryKeyParams = QueryKey.getParams({
 		pathParamsType,
@@ -715,8 +772,8 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		paramsCasing,
 		paramsType,
 		pathParamsType,
-		typeSchemas,
-		pageParamGeneric: "TPageParam"
+		dataReturnType,
+		typeSchemas
 	});
 	const queryOptions = `${queryOptionsName}(${queryOptionsParams.toCall()})`;
 	return /* @__PURE__ */ jsx(File.Source, {
@@ -734,11 +791,11 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
        const { client: queryClient, ...queryOptions } = queryConfig
        const queryKey = queryOptions?.queryKey ?? ${queryKeyName}(${queryKeyParams.toCall()})
 
-       const query = useInfiniteQuery({
+       const query = useQuery({
         ...${queryOptions},
         queryKey,
         ...queryOptions
-       } as unknown as InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
+       } as unknown as QueryObserverOptions, queryClient) as ${returnType}
 
        query.queryKey = queryKey as TQueryKey
 
@@ -747,7 +804,7 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 		})
 	});
 }
-InfiniteQuery.getParams = getParams$1;
+Query.getParams = getParams$1;
 
 //#endregion
 //#region src/components/SuspenseQuery.tsx
@@ -889,5 +946,5 @@ function SuspenseQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 SuspenseQuery.getParams = getParams;
 
 //#endregion
-export { InfiniteQuery, InfiniteQueryOptions, Mutation, MutationKey, Query, QueryKey, QueryOptions, SuspenseQuery };
-//# sourceMappingURL=components-BRLaeCYI.js.map
+export { InfiniteQuery, InfiniteQueryOptions, Mutation, MutationKey, MutationOptions, Query, QueryKey, QueryOptions, SuspenseQuery };
+//# sourceMappingURL=components-Dz_s6t75.js.map