@orval/query 8.24.0 → 8.26.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { GetterPropType, OutputClient, OutputHttpClient, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getFullRoute, getRoute, getRouteAsArray, getSuccessResponseType, isObject, isOperationInTagBucket, isString, isSyntheticDefaultImportsAllow, jsDoc, logWarning, makeRouteSafe, mergeDeep, pascal, stringify, toObjectString } from "@orval/core";
+import { GetterPropType, OutputClient, OutputHttpClient, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateResponseDateDeserializer, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getFullRoute, getRoute, getRouteAsArray, getSuccessResponseType, isObject, isOperationInTagBucket, isString, isSyntheticDefaultImportsAllow, jsDoc, logWarning, makeRouteSafe, mergeDeep, pascal, stringify, toObjectString } from "@orval/core";
 import { generateFetchHeader, generateRequestFunction } from "@orval/fetch";
 import nodePath from "node:path";
 import { styleText } from "node:util";
@@ -180,9 +180,7 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
 		case "delete":
 			httpCall = bodyArg ? `http.${verb}${httpGeneric}(url, { ${httpOptions.length > 0 ? httpOptions.join(", ") + ", " : ""}body: ${bodyArg} })` : `http.${verb}${httpGeneric}(url${optionsStr})`;
 			break;
-		default:
-			httpCall = `http.${verb}${httpGeneric}(url, ${bodyArg || "undefined"}${optionsStr})`;
-			break;
+		default: httpCall = `http.${verb}${httpGeneric}(url, ${bodyArg || "undefined"}${optionsStr})`;
 	}
 	const responseType = response.definition.success;
 	const isPrimitiveType = [
@@ -227,6 +225,13 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 		isFormData,
 		isFormUrlEncoded
 	});
+	const dateDeserializer = override.useDatesTransform ? generateResponseDateDeserializer({
+		operationName,
+		response,
+		context
+	}) : void 0;
+	const dateDeserializerImplementation = dateDeserializer ? `\n${dateDeserializer.implementation}` : "";
+	const thenDateDeserializer = dateDeserializer ? `.then(${dateDeserializer.name})` : "";
 	if (mutator) {
 		const mutatorConfig = generateMutatorConfig({
 			route,
@@ -253,14 +258,14 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
         ${bodyForm}
         return ${operationName}(
           ${mutatorConfig},
-          ${requestOptions});
+          ${requestOptions})${thenDateDeserializer};
         }`;
 			return `${override.query.shouldExportMutatorHooks ? "export " : ""}const use${pascal(operationName)}Hook = () => {
         const ${operationName} = ${mutator.name}<${response.definition.success || "unknown"}>();
 
         return ${adapter.wrapHookMutatorCallback(callback, operationName)}
       }
-    `;
+    ${dateDeserializerImplementation}`;
 		}
 		return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<typeof ${mutator.name}>,` : ""}${getSignalDefinition({
 			hasSignal,
@@ -270,9 +275,9 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
       ${bodyForm}
       return ${mutator.name}<${response.definition.success || "unknown"}>(
       ${mutatorConfig},
-      ${requestOptions});
+      ${requestOptions})${thenDateDeserializer};
     }
-  `;
+  ${dateDeserializerImplementation}`;
 	}
 	const isSyntheticDefaultImportsAllowed = isSyntheticDefaultImportsAllow(context.output.tsconfig);
 	const options = generateOptions({
@@ -300,9 +305,9 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 	return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${queryProps} ${optionsArgs} ): Promise<AxiosResponse<${response.definition.success || "unknown"}>> => {
     ${unrefStatements}
     ${bodyForm}
-    return axios${isSyntheticDefaultImportsAllowed ? "" : ".default"}.${verb}(${options});
+    return axios${isSyntheticDefaultImportsAllowed ? "" : ".default"}.${verb}(${options})${dateDeserializer ? `.then((res) => { res.data = ${dateDeserializer.name}(res.data); return res; })` : ""};
   }
-`;
+${dateDeserializerImplementation}`;
 };
 const generateRequestOptionsArguments = ({ isRequestOptions, hasSignal, hasSignalParam = false }) => {
 	if (isRequestOptions) return "options?: AxiosRequestConfig\n";
@@ -352,9 +357,11 @@ const getQueryOptions = ({ isRequestOptions, mutator, isExactOptionalPropertyTyp
 const getHookOptions = ({ isRequestOptions, httpClient, mutator, useRuntimeFetcher = false }) => {
 	if (!isRequestOptions) return "";
 	let value = "const {query: queryOptions";
-	if (!mutator) if (httpClient === OutputHttpClient.AXIOS) value += ", axios: axiosOptions";
-	else if (httpClient === OutputHttpClient.FETCH && useRuntimeFetcher) value += ", fetch: fetchOptions, fetcher: fetcherFn";
-	else value += ", fetch: fetchOptions";
+	if (!mutator) {
+		if (httpClient === OutputHttpClient.AXIOS) value += ", axios: axiosOptions";
+		else if (httpClient === OutputHttpClient.FETCH && useRuntimeFetcher) value += ", fetch: fetchOptions, fetcher: fetcherFn";
+		else value += ", fetch: fetchOptions";
+	}
 	if (mutator?.hasSecondArg) value += ", request: requestOptions";
 	value += "} = options ?? {};";
 	return value;
@@ -715,6 +722,12 @@ const getSolidQueryImports = (prefix, hasRenamedOptionsTypes) => {
 			{ name: "MutationFunction" },
 			{ name: `${capitalized}QueryResult` },
 			{ name: `${capitalized}InfiniteQueryResult` },
+			{ name: `Defined${capitalized}QueryResult` },
+			{ name: `Defined${capitalized}InfiniteQueryResult` },
+			{ name: "DefinedInitialDataOptions" },
+			{ name: "UndefinedInitialDataOptions" },
+			{ name: "DefinedInitialDataInfiniteOptions" },
+			{ name: "UndefinedInitialDataInfiniteOptions" },
 			{ name: "QueryKey" },
 			{ name: "InfiniteData" },
 			{ name: `${capitalized}MutationResult` },
@@ -906,10 +919,16 @@ const QueryType = {
 	SUSPENSE_QUERY: "suspenseQuery",
 	SUSPENSE_INFINITE: "suspenseInfiniteQuery"
 };
-const INFINITE_QUERY_PROPERTIES = new Set(["getNextPageParam", "getPreviousPageParam"]);
+const INFINITE_QUERY_PROPERTIES = /* @__PURE__ */ new Set(["getNextPageParam", "getPreviousPageParam"]);
+/**
+* Whether a key from `override.query.options` reaches the emitted options
+* literal for this query type. Page-param callbacks are meaningless on a plain
+* query, so they are dropped there.
+*/
+const isConfiguredOptionEmitted = (key, type) => isInfiniteQuery(type) || !INFINITE_QUERY_PROPERTIES.has(key);
 const generateQueryOptions = ({ params, options, type, adapter }) => {
 	if (options === false) return "";
-	const queryConfig = isObject(options) ? ` ${stringify(omitBy(options, (_, key) => type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE && INFINITE_QUERY_PROPERTIES.has(key)))?.slice(1, -1)}` : "";
+	const queryConfig = isObject(options) ? ` ${stringify(omitBy(options, (_, key) => !isConfiguredOptionEmitted(key, type)))?.slice(1, -1)}` : "";
 	if (params.length === 0 || isSuspenseQuery(type)) {
 		if (options) return `${queryConfig} ...queryOptions`;
 		return "...queryOptions";
@@ -919,24 +938,71 @@ const generateQueryOptions = ({ params, options, type, adapter }) => {
 const isSuspenseQuery = (type) => {
 	return [QueryType.SUSPENSE_INFINITE, QueryType.SUSPENSE_QUERY].includes(type);
 };
-const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type, prefix, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData, adapter }) => {
+const isInfiniteQuery = (type) => {
+	return [QueryType.INFINITE, QueryType.SUSPENSE_INFINITE].includes(type);
+};
+const getOptionsKind = (type) => isInfiniteQuery(type) ? "infiniteQuery" : "query";
+/**
+* Resolves the adapter's constraint together with the plain options type it has
+* to be rendered against. Both are optional on `FrameworkAdapter` and neither is
+* useful alone: without a type name there is nothing to `Pick` from, and without
+* required keys the caller has nothing to supply. Returning them as one value is
+* what stops the signature and the type disagreeing about whether `options` is
+* mandatory.
+*/
+const resolveUserQueryOptionsConstraint = (adapter, type, options) => {
+	const constraint = adapter?.getUserQueryOptionsConstraint?.(type);
+	if (!constraint) return;
+	const optionsTypeName = adapter?.getOptionsReturnTypeName?.(getOptionsKind(type));
+	if (!optionsTypeName) return;
+	const require = isObject(options) ? constraint.require?.filter((key) => !(isConfiguredOptionEmitted(key, type) && Object.hasOwn(options, key))) : constraint.require;
+	return {
+		...constraint,
+		require,
+		optionsTypeName
+	};
+};
+/**
+* Whether the caller must supply options the generator cannot infer, which is
+* what makes the whole `options` parameter mandatory. An `exclude`-only
+* constraint reshapes the type without requiring anything, so it does not count.
+*/
+const requiresUserSuppliedQueryOptions = (adapter, type, options) => !!type && !!resolveUserQueryOptionsConstraint(adapter, type, options)?.require?.length;
+const getQueryOptionsDefinition = ({ operationName, mutator, definitions, mutationVariablesType, type, prefix, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData, adapter, options }) => {
 	const isMutatorHook = mutator?.isHook;
 	const partialOptions = !isReturnType && hasQueryV5;
 	if (type) {
 		const funcReturnType = `Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>`;
-		const optionTypeInitialDataPostfix = initialData && !isSuspenseQuery(type) ? ` & Pick<
-        ${pascal(initialData)}InitialDataOptions<
+		const isInfiniteType = isInfiniteQuery(type);
+		const infiniteTypeArgs = hasQueryV5 && isInfiniteType && queryParam && queryParams ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : "";
+		const initialDataOptionsType = initialData && adapter?.getInitialDataOptionsType ? adapter.getInitialDataOptionsType({
+			initialData,
+			isInfinite: isInfiniteType,
+			funcReturnType,
+			infiniteTypeArgs
+		}) : `${pascal(initialData ?? "")}InitialDataOptions<
           ${funcReturnType},
           TError,
-          ${funcReturnType}${hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) && queryParam && queryParams ? `, QueryKey` : ""}
-        > , 'initialData'
+          ${funcReturnType}${hasQueryV5 && isInfiniteType && queryParam && queryParams ? `, QueryKey` : ""}
+        >`;
+		const optionTypeInitialDataPostfix = initialData && !isSuspenseQuery(type) ? ` & Pick<
+        ${initialDataOptionsType} , 'initialData'
       >` : "";
-		const optionsTypeName = isReturnType && adapter?.getOptionsReturnTypeName ? adapter.getOptionsReturnTypeName(type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE ? "infiniteQuery" : "query") : void 0;
-		const optionType = optionsTypeName ? `${optionsTypeName}<${funcReturnType}, TError, TData${hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) && queryParam && queryParams ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : ""}>` : `${prefix}${pascal(type)}Options<${funcReturnType}, TError, TData${hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) && queryParam && queryParams ? hasQueryV5WithInfiniteQueryOptionsError ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : `, ${funcReturnType}, QueryKey, ${queryParams.schema.name}['${queryParam}']` : ""}>`;
+		const userOptionsConstraint = isReturnType ? void 0 : resolveUserQueryOptionsConstraint(adapter, type, options);
+		if (userOptionsConstraint) {
+			const { optionsTypeName, require = [], exclude = [] } = userOptionsConstraint;
+			const plainOptionsType = `${optionsTypeName}<${funcReturnType}, TError, TData${infiniteTypeArgs}>`;
+			const quoteKeys = (keys) => keys.map((key) => `'${key}'`).join(" | ");
+			const omitted = [...require, ...exclude];
+			return `${omitted.length ? `Omit<Partial<${plainOptionsType}>, ${quoteKeys(omitted)}>` : `Partial<${plainOptionsType}>`}${require.length ? ` & Pick<${plainOptionsType}, ${quoteKeys(require)}>` : ""}${optionTypeInitialDataPostfix}`;
+		}
+		const optionsTypeName = isReturnType ? adapter?.getOptionsReturnTypeName?.(getOptionsKind(type)) : void 0;
+		const optionType = optionsTypeName ? `${optionsTypeName}<${funcReturnType}, TError, TData${infiniteTypeArgs}>` : `${prefix}${pascal(type)}Options<${funcReturnType}, TError, TData${hasQueryV5 && isInfiniteType && queryParam && queryParams ? hasQueryV5WithInfiniteQueryOptionsError ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : `, ${funcReturnType}, QueryKey, ${queryParams.schema.name}['${queryParam}']` : ""}>`;
 		return `${partialOptions ? "Partial<" : ""}${optionType}${partialOptions ? ">" : ""}${optionTypeInitialDataPostfix}`;
 	}
 	const mutationOptionsTypeName = adapter?.getOptionsReturnTypeName ? adapter.getOptionsReturnTypeName("mutation") : void 0;
-	return mutationOptionsTypeName ? `${mutationOptionsTypeName}<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError,${definitions ? `{${definitions}}` : "void"}, TContext>` : `${prefix}MutationOptions<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError,${definitions ? `{${definitions}}` : "void"}, TContext>`;
+	const variablesType = mutationVariablesType ?? (definitions ? `{${definitions}}` : "void");
+	return mutationOptionsTypeName ? `${mutationOptionsTypeName}<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError,${variablesType}, TContext>` : `${prefix}MutationOptions<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError,${variablesType}, TContext>`;
 };
 //#endregion
 //#region src/frameworks/angular.ts
@@ -1017,11 +1083,12 @@ const createAngularAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQuery
 		getQueryOptionsDefinitionPrefix() {
 			return prefix;
 		},
-		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation, useRuntimeFetcher }) {
+		generateQueryArguments({ operationName, definitions, mutationVariablesType, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation, useRuntimeFetcher }) {
 			const definition = getQueryOptionsDefinition({
 				operationName,
 				mutator,
 				definitions,
+				mutationVariablesType,
 				type,
 				prefix,
 				hasQueryV5,
@@ -1117,6 +1184,11 @@ const createReactAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5
 });
 //#endregion
 //#region src/frameworks/solid.ts
+const QUERY_OPTIONS_CONSTRAINT = { exclude: ["initialData"] };
+const INFINITE_QUERY_OPTIONS_CONSTRAINT = {
+	require: ["initialPageParam", "getNextPageParam"],
+	exclude: ["initialData"]
+};
 const createSolidAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError, hasQueryV5WithMutationContextOnSuccess, hasQueryV5WithRequiredContextOnSuccess, hasSolidQueryUsePrefix, hasSolidQueryRenamedOptionsTypes }) => ({
 	outputClient: OutputClient.SOLID_QUERY,
 	hookPrefix: hasSolidQueryUsePrefix ? "use" : "create",
@@ -1145,11 +1217,25 @@ const createSolidAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5
 	shouldCastQueryOptions() {
 		return false;
 	},
-	getQueryReturnType({ type }) {
+	getUserQueryOptionsConstraint(type) {
+		if (!hasQueryV5) return;
+		if (isInfiniteQuery(type)) return INFINITE_QUERY_OPTIONS_CONSTRAINT;
+		return hasSolidQueryUsePrefix ? QUERY_OPTIONS_CONSTRAINT : void 0;
+	},
+	getQueryType(type) {
+		return getQueryTypeForFramework(type);
+	},
+	shouldGenerateOverrideTypes() {
+		return hasQueryV5 && hasSolidQueryUsePrefix;
+	},
+	getInitialDataOptionsType({ initialData, isInfinite, funcReturnType, infiniteTypeArgs }) {
+		return `ReturnType<${`${pascal(initialData)}InitialData${isInfinite ? "Infinite" : ""}Options`}<${funcReturnType}, TError, TData${infiniteTypeArgs}>>`;
+	},
+	getQueryReturnType({ type, isInitialDataDefined }) {
 		const prefix = hasSolidQueryUsePrefix ? "Use" : "Create";
 		const queryKeyType = hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey";
-		if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `${prefix}QueryResult<TData, TError> & { queryKey: ${queryKeyType} }`;
-		return `${prefix}InfiniteQueryResult<TData, TError> & { queryKey: ${queryKeyType} }`;
+		const resultName = isInfiniteQuery(type) ? "InfiniteQueryResult" : "QueryResult";
+		return `${isInitialDataDefined ? "Defined" : ""}${prefix}${resultName}<TData, TError> & { queryKey: ${queryKeyType} }`;
 	},
 	getMutationReturnType({ dataType, variableType }) {
 		return `: ${hasSolidQueryUsePrefix ? "Use" : "Create"}MutationResult<
@@ -1242,11 +1328,12 @@ const createSvelteAdapter = ({ hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, h
 		getQueryOptionsDefinitionPrefix() {
 			return prefix;
 		},
-		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation, useRuntimeFetcher }) {
+		generateQueryArguments({ operationName, definitions, mutationVariablesType, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation, useRuntimeFetcher }) {
 			const definition = getQueryOptionsDefinition({
 				operationName,
 				mutator,
 				definitions,
+				mutationVariablesType,
 				type,
 				prefix,
 				hasQueryV5,
@@ -1386,27 +1473,28 @@ const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagErro
 	supportsMutationInvalidation() {
 		return hasQueryV5;
 	},
-	generateMutationOnSuccess({ operationName, definitions, isRequestOptions, generateInvalidateCall, uniqueInvalidates }) {
+	generateMutationOnSuccess({ operationName, definitions, mutationVariablesType, isRequestOptions, generateInvalidateCall, uniqueInvalidates }) {
 		const invalidateCalls = uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n");
+		const variablesType = mutationVariablesType ?? (definitions ? `{${definitions}}` : "void");
 		if (hasQueryV5WithMutationContextOnSuccess) {
-			if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
+			if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, onMutateResult: TContext, context: MutationFunctionContext) => {
         if (!options?.skipInvalidation) {
     ${invalidateCalls}
         }
         unref(unref(typeof mutationOptions === 'function' ? mutationOptions() : mutationOptions)?.onSuccess)?.(data, variables, onMutateResult, context);
       };`;
-			return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
+			return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, onMutateResult: TContext, context: MutationFunctionContext) => {
     ${invalidateCalls}
         unref(unref(typeof mutationOptions === 'function' ? mutationOptions() : mutationOptions)?.onSuccess)?.(data, variables, onMutateResult, context);
       };`;
 		}
-		if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
+		if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, context: TContext${hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
         if (!options?.skipInvalidation) {
     ${invalidateCalls}
         }
         unref(unref(typeof mutationOptions === 'function' ? mutationOptions() : mutationOptions)?.onSuccess)?.(data, variables, context);
       };`;
-		return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
+		return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, context: TContext${hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
     ${invalidateCalls}
         unref(unref(typeof mutationOptions === 'function' ? mutationOptions() : mutationOptions)?.onSuccess)?.(data, variables, context);
       };`;
@@ -1472,48 +1560,53 @@ const withDefaults = (adapter) => {
 		getOptionalQueryClientArgument() {
 			return composed.hasQueryV5 ? ", queryClient?: QueryClient" : "";
 		},
-		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation, useRuntimeFetcher }) {
+		generateQueryArguments({ operationName, definitions, mutationVariablesType, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation, useRuntimeFetcher, options }) {
+			const prefix = composed.getQueryOptionsDefinitionPrefix();
 			const definition = getQueryOptionsDefinition({
 				operationName,
 				mutator,
 				definitions,
+				mutationVariablesType,
 				type,
-				prefix: composed.getQueryOptionsDefinitionPrefix(),
+				prefix,
 				hasQueryV5: composed.hasQueryV5,
 				hasQueryV5WithInfiniteQueryOptionsError: composed.hasQueryV5WithInfiniteQueryOptionsError,
 				queryParams,
 				queryParam,
 				isReturnType: false,
 				initialData,
-				adapter: composed
+				adapter: composed,
+				options
 			});
-			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
+			const requiresUserQueryOptions = requiresUserSuppliedQueryOptions(composed, type, options);
+			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" || requiresUserQueryOptions ? "" : "?"}: ${definition}`;
 			const requestType = getQueryArgumentsRequestType(httpClient, mutator, useRuntimeFetcher);
-			const isQueryRequired = initialData === "defined";
+			const isQueryRequired = initialData === "defined" || requiresUserQueryOptions;
 			const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
 			return `options${isQueryRequired ? "" : "?"}: ${optionsType}\n`;
 		},
-		generateMutationOnSuccess({ operationName, definitions, isRequestOptions, generateInvalidateCall, uniqueInvalidates }) {
+		generateMutationOnSuccess({ operationName, definitions, mutationVariablesType, isRequestOptions, generateInvalidateCall, uniqueInvalidates }) {
 			const invalidateCalls = uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n");
+			const variablesType = mutationVariablesType ?? (definitions ? `{${definitions}}` : "void");
 			if (composed.hasQueryV5WithMutationContextOnSuccess) {
-				if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
+				if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, onMutateResult: TContext, context: MutationFunctionContext) => {
         if (!options?.skipInvalidation) {
     ${invalidateCalls}
         }
         mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
       };`;
-				return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
+				return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, onMutateResult: TContext, context: MutationFunctionContext) => {
     ${invalidateCalls}
         mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
       };`;
 			} else {
-				if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${composed.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
+				if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, context: TContext${composed.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
         if (!options?.skipInvalidation) {
     ${invalidateCalls}
         }
         mutationOptions?.onSuccess?.(data, variables, context);
       };`;
-				return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${composed.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
+				return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${variablesType}, context: TContext${composed.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
     ${invalidateCalls}
         mutationOptions?.onSuccess?.(data, variables, context);
       };`;
@@ -1535,23 +1628,30 @@ const createFrameworkAdapter = ({ outputClient, packageJson, queryVersion }) =>
 	const _hasQueryV5WithMutationContextOnSuccess = isQueryV5WithMutationContextOnSuccess(packageJson, clientType);
 	const _hasQueryV5WithRequiredContextOnSuccess = isQueryV5WithRequiredContextOnSuccess(packageJson, clientType);
 	switch (outputClient) {
-		case OutputClient.VUE_QUERY: return withDefaults(createVueAdapter({
-			hasVueQueryV4: !isVueQueryV3(packageJson) || queryVersion === 4,
-			hasQueryV5: _hasQueryV5,
-			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
-			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
-			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
-			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
-		}));
-		case OutputClient.SVELTE_QUERY: return withDefaults(createSvelteAdapter({
-			hasSvelteQueryV4: !isSvelteQueryV3(packageJson) || queryVersion === 4,
-			hasSvelteQueryV6: isSvelteQueryV6(packageJson),
-			hasQueryV5: _hasQueryV5,
-			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
-			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
-			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
-			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
-		}));
+		case OutputClient.VUE_QUERY: {
+			const hasVueQueryV4 = !isVueQueryV3(packageJson) || queryVersion === 4;
+			return withDefaults(createVueAdapter({
+				hasVueQueryV4,
+				hasQueryV5: _hasQueryV5,
+				hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+				hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
+				hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
+				hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
+			}));
+		}
+		case OutputClient.SVELTE_QUERY: {
+			const hasSvelteQueryV4 = !isSvelteQueryV3(packageJson) || queryVersion === 4;
+			const _hasSvelteQueryV6 = isSvelteQueryV6(packageJson);
+			return withDefaults(createSvelteAdapter({
+				hasSvelteQueryV4,
+				hasSvelteQueryV6: _hasSvelteQueryV6,
+				hasQueryV5: _hasQueryV5,
+				hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+				hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
+				hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
+				hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
+			}));
+		}
 		case OutputClient.ANGULAR_QUERY: return withDefaults(createAngularAdapter({
 			hasQueryV5: _hasQueryV5,
 			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
@@ -1559,15 +1659,19 @@ const createFrameworkAdapter = ({ outputClient, packageJson, queryVersion }) =>
 			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
 			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
 		}));
-		case OutputClient.SOLID_QUERY: return withDefaults(createSolidAdapter({
-			hasQueryV5: _hasQueryV5,
-			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
-			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
-			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
-			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess,
-			hasSolidQueryUsePrefix: isSolidQueryWithUsePrefix(packageJson),
-			hasSolidQueryRenamedOptionsTypes: isSolidQueryWithRenamedOptionsTypes(packageJson)
-		}));
+		case OutputClient.SOLID_QUERY: {
+			const hasSolidQueryWithUsePrefix = isSolidQueryWithUsePrefix(packageJson);
+			const hasSolidQueryWithRenamedOptionsTypes = isSolidQueryWithRenamedOptionsTypes(packageJson);
+			return withDefaults(createSolidAdapter({
+				hasQueryV5: _hasQueryV5,
+				hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+				hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
+				hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
+				hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess,
+				hasSolidQueryUsePrefix: hasSolidQueryWithUsePrefix,
+				hasSolidQueryRenamedOptionsTypes: hasSolidQueryWithRenamedOptionsTypes
+			}));
+		}
 		default: return withDefaults(createReactAdapter({
 			hasQueryV5: _hasQueryV5,
 			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
@@ -1603,7 +1707,7 @@ const HTTP_METHODS = [
 	"head",
 	"trace"
 ];
-const MUTATION_OPERATION_LOCAL_NAMES = new Set([
+const MUTATION_OPERATION_LOCAL_NAMES = /* @__PURE__ */ new Set([
 	"backupQueryClient",
 	"context",
 	"customOptions",
@@ -1774,6 +1878,8 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 	}) : void 0;
 	const bodyOptionalMark = body.isOptional ? "?" : "";
 	const definitions = props.map(({ definition, type }) => type === GetterPropType.BODY ? mutator?.bodyTypeName ? `data${bodyOptionalMark}: ${mutator.bodyTypeName}<${body.definition}>` : `data${bodyOptionalMark}: ${body.definition}` : definition).join(";");
+	const variablesTypeName = definitions ? `${pascal(typeName)}MutationVariables` : void 0;
+	const mutationVariablesType = variablesTypeName ?? "void";
 	const properties = props.map(({ name, type }) => type === GetterPropType.BODY ? "data" : name).join(",");
 	const operationLocalNames = new Set(MUTATION_OPERATION_LOCAL_NAMES);
 	for (const { name, type } of props) operationLocalNames.add(type === GetterPropType.BODY ? "data" : name);
@@ -1785,6 +1891,7 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 		operationName: operationTypeReferenceName,
 		mutator,
 		definitions,
+		mutationVariablesType,
 		prefix: adapter.getQueryOptionsDefinitionPrefix(),
 		hasQueryV5: adapter.hasQueryV5,
 		hasQueryV5WithInfiniteQueryOptionsError: adapter.hasQueryV5WithInfiniteQueryOptionsError,
@@ -1804,6 +1911,7 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 	const mutationArguments = adapter.generateQueryArguments({
 		operationName: operationTypeReferenceName,
 		definitions,
+		mutationVariablesType,
 		mutator,
 		isRequestOptions,
 		httpClient,
@@ -1813,6 +1921,7 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 	const mutationArgumentsForOptions = adapter.generateQueryArguments({
 		operationName: operationTypeReferenceName,
 		definitions,
+		mutationVariablesType,
 		mutator,
 		isRequestOptions,
 		httpClient,
@@ -1830,7 +1939,7 @@ ${hooksOptionImplementation}
       ${mutator?.isHook ? `const ${operationReferenceName} =  use${pascal(operationName)}Hook()` : ""}
 
 
-      const mutationFn: MutationFunction<Awaited<ReturnType<${dataType}>>, ${definitions ? `{${definitions}}` : "void"}> = (${properties ? "props" : ""}) => {
+      const mutationFn: MutationFunction<Awaited<ReturnType<${dataType}>>, ${mutationVariablesType}> = (${properties ? "props" : ""}) => {
           ${properties ? `const {${properties}} = props ?? {};` : ""}
 
           return  ${operationReferenceName}(${adapter.getMutationHttpPrefix(mutator)}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator, useRuntimeFetcher)})
@@ -1839,6 +1948,7 @@ ${hooksOptionImplementation}
 ${hasInvalidation ? adapter.generateMutationOnSuccess({
 		operationName,
 		definitions,
+		mutationVariablesType,
 		isRequestOptions,
 		generateInvalidateCall: createGenerateInvalidateCall(context.spec, !!query.shouldSplitQueryKey, !!query.useOperationIdAsQueryKey, context.output.baseUrl, context.spec.servers),
 		uniqueInvalidates
@@ -1858,7 +1968,7 @@ ${hasInvalidation ? adapter.generateMutationOnSuccess({
 	const mutationOptionsVarName = camel(`${operationName}-mutation-options`);
 	const mutationReturnType = adapter.getMutationReturnType({
 		dataType,
-		variableType: definitions ? `{${definitions}}` : "void"
+		variableType: mutationVariablesType
 	});
 	const mutationHookBody = adapter.generateMutationHookBody({
 		operationPrefix,
@@ -1878,6 +1988,7 @@ ${mutationOptionsFn}
     export type ${pascal(typeName)}MutationResult = NonNullable<Awaited<ReturnType<${dataType}>>>
     ${body.definition ? `export type ${pascal(typeName)}MutationBody = ${mutator?.bodyTypeName ? `${mutator.bodyTypeName}<${body.definition}>` : body.definition}${body.isOptional ? " | undefined" : ""}` : ""}
     export type ${pascal(typeName)}MutationError = ${errorType}
+    ${variablesTypeName ? `export type ${variablesTypeName} = {${definitions}}` : ""}
 
     ${doc}export const ${camel(`${operationPrefix}-${operationName}`)} = <TError = ${errorType},
     TContext = unknown>(${mutationArguments} ${optionalQueryClientArgument})${mutationReturnType} => {
@@ -2000,6 +2111,26 @@ const renderSetQueryDataHelper = ({ doc, isReactQuery, fnName, propsSig, body })
 }\n`;
 };
 /**
+* Rewrites `name?: T` to `name: undefined | T` so a required parameter can follow
+* it (TS1016).
+*
+* Keep `undefined` first. `wrapPropsBodyWithMutatorBodyType` matches an optional
+* `undefined\s*\|\s*` prefix when it swaps in a mutator body type, and misses the
+* `T | undefined` form that `allowUndefinedParam` emits.
+*/
+const widenOptionalPropsToUndefined = (props, field) => props.map((prop) => {
+	const regex = new RegExp(String.raw`^${escapeRegExpMetaChars(prop.name)}\s*\?:`);
+	if (!regex.test(prop[field])) return prop;
+	const widened = prop[field].replace(regex, `${prop.name}: undefined | `);
+	return field === "definition" ? {
+		...prop,
+		definition: widened
+	} : {
+		...prop,
+		implementation: widened
+	};
+});
+/**
 * Renders the prop list shared by `getXxxQueryKey`, `setXxxQueryData` and
 * `getXxxQueryData` helpers: headers are dropped (unless `includeHeaders`
 * is set — key-mutator factories need them), path params stay required,
@@ -2070,21 +2201,15 @@ const generatePrefetch = ({ usePrefetch, type, useQuery, useInfinite, operationN
 const generateQueryImplementation = ({ queryOption: { name, typeName: optionTypeName, queryParam, options, type, queryKeyFnName }, operationId, operationName, typeName, queryProperties, queryKeyProperties, queryParams, params, props, body, mutator, queryOptionsMutator, queryKeyMutator, isRequestOptions, response, httpClient, isExactOptionalPropertyTypes, hasSignal, useRuntimeFetcher, forceSuccessResponse, route, doc, usePrefetch, useQuery, useInfinite, useInvalidate, useSetQueryData, useGetQueryData, adapter }) => {
 	const { hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError } = adapter;
 	const hasSignalParam = props.some((prop) => prop.name === "signal");
+	const requiresUserQueryOptions = requiresUserSuppliedQueryOptions(adapter, type, options);
+	const signatureProps = requiresUserQueryOptions ? widenOptionalPropsToUndefined(props, "implementation") : props;
 	const queryPropDefinitions = wrapPropsBodyWithMutatorBodyType({
-		propsString: toObjectString(props, "definition"),
+		propsString: toObjectString(requiresUserQueryOptions ? widenOptionalPropsToUndefined(props, "definition") : props, "definition"),
 		body,
 		mutator
 	});
 	const definedInitialDataQueryPropsDefinitions = wrapPropsBodyWithMutatorBodyType({
-		propsString: toObjectString(props.map((prop) => {
-			const regex = new RegExp(String.raw`^${prop.name}\s*\?:`);
-			if (!regex.test(prop.definition)) return prop;
-			const definitionWithUndefined = prop.definition.replace(regex, `${prop.name}: undefined | `);
-			return {
-				...prop,
-				definition: definitionWithUndefined
-			};
-		}), "definition"),
+		propsString: toObjectString(widenOptionalPropsToUndefined(props, "definition"), "definition"),
 		body,
 		mutator
 	});
@@ -2093,6 +2218,11 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		body,
 		mutator
 	});
+	const queryPropsBeforeRequiredOptions = requiresUserQueryOptions ? wrapPropsBodyWithMutatorBodyType({
+		propsString: toObjectString(signatureProps, "implementation"),
+		body,
+		mutator
+	}) : queryProps;
 	const infiniteQueryParamType = hasQueryParam(queryParams, queryParam) && queryParams && queryParam ? `${queryParams.schema.name}['${queryParam}']` : "";
 	const hasInfiniteQueryParam = !!infiniteQueryParamType;
 	const httpFunctionProps = queryParam ? adapter.getInfiniteQueryHttpProps(props, queryParam, httpClient, !!mutator) : adapter.getHttpFunctionQueryProps(queryProperties, httpClient, !!mutator);
@@ -2123,7 +2253,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParam,
 		initialData: "defined",
 		httpClient,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const undefinedInitialDataQueryArguments = adapter.generateQueryArguments({
 		operationName,
@@ -2135,7 +2266,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParam,
 		initialData: "undefined",
 		httpClient,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const queryArguments = adapter.generateQueryArguments({
 		operationName,
@@ -2146,7 +2278,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParams,
 		queryParam,
 		httpClient,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const queryArgumentsForOptions = adapter.generateQueryArguments({
 		operationName,
@@ -2158,7 +2291,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParam,
 		httpClient,
 		forQueryOptions: true,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const queryOptions = getQueryOptions({
 		isRequestOptions,
@@ -2204,7 +2338,7 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 	const queryResultVarName = props.some((prop) => prop.name === "query") ? "_query" : "query";
 	const infiniteParam = infiniteQueryParamType ? `, ${infiniteQueryParamType}` : "";
 	const TData = hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) ? `InfiniteData<Awaited<ReturnType<${dataType}>>${infiniteParam}>` : `Awaited<ReturnType<${dataType}>>`;
-	const queryOptionsFn = `export const ${queryOptionsFnName} = <TData = ${TData}, TError = ${errorType}>(${adapter.getHttpFirstParam(mutator)}${queryProps} ${queryArgumentsForOptions}) => {
+	const queryOptionsFn = `export const ${queryOptionsFnName} = <TData = ${TData}, TError = ${errorType}>(${adapter.getHttpFirstParam(mutator)}${queryPropsBeforeRequiredOptions} ${queryArgumentsForOptions}) => {
 
 ${hookOptions}
 
@@ -2212,7 +2346,7 @@ ${hookOptions}
 
   ${mutator?.isHook ? `const ${operationName} =  use${pascal(operationName)}Hook();` : ""}
 
-    const queryFn: QueryFunction<Awaited<ReturnType<${mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>${hasQueryV5 && hasInfiniteQueryParam ? `, QueryKey, ${infiniteQueryParamType}` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
+    const queryFn: QueryFunction<Awaited<ReturnType<${mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>${hasQueryV5 && hasInfiniteQueryParam ? `, QueryKey, ${infiniteQueryParamType}` : hasQueryV5 && isInfiniteQuery(type) && adapter.shouldCastQueryOptions?.() === false ? `, QueryKey, unknown` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
 
       ${adapter.getQueryOptionsUnrefStatements(props)}
 
@@ -2234,7 +2368,7 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${q
 		useInfinite,
 		operationName,
 		mutator,
-		queryProps,
+		queryProps: queryPropsBeforeRequiredOptions,
 		dataType,
 		errorType,
 		queryArguments: queryArgumentsForOptions,
@@ -2297,7 +2431,7 @@ export type ${pascal(optionTypeName)}QueryError = ${errorType}
 ${adapter.shouldGenerateOverrideTypes() ? overrideTypes : ""}
 ${doc}
 export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${wrapPropsBodyWithMutatorBodyType({
-		propsString: adapter.getHookPropsDefinitions(props),
+		propsString: adapter.getHookPropsDefinitions(signatureProps),
 		body,
 		mutator
 	})} ${queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
@@ -2355,7 +2489,8 @@ const generateQueryHook = async (verbOptions, options, outputClient, adapter) =>
 	const effectiveUseMutation = operationQueryOptions?.useMutation ?? override.query.useMutation ?? verb !== Verbs.GET;
 	const globalSuspenseOrInfiniteOnlyForGet = (flag) => flag === true && verb === Verbs.GET;
 	const effectiveUseSuspenseQuery = operationQueryOptions?.useSuspenseQuery ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useSuspenseQuery);
-	const { queryParam: infiniteQueryParam, infiniteHookAllowed } = resolveInfiniteQueryParam(queryParams, operationQueryOptions?.useInfiniteQueryParam ?? query.useInfiniteQueryParam);
+	const configuredInfiniteQueryParam = operationQueryOptions?.useInfiniteQueryParam ?? query.useInfiniteQueryParam;
+	const { queryParam: infiniteQueryParam, infiniteHookAllowed } = resolveInfiniteQueryParam(queryParams, configuredInfiniteQueryParam);
 	const effectiveUseInfinite = (operationQueryOptions?.useInfinite ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useInfinite)) && infiniteHookAllowed;
 	const effectiveUseSuspenseInfiniteQuery = (operationQueryOptions?.useSuspenseInfiniteQuery ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useSuspenseInfiniteQuery)) && infiniteHookAllowed;
 	let isQuery = effectiveUseQuery || effectiveUseSuspenseQuery || effectiveUseInfinite || effectiveUseSuspenseInfiniteQuery;