@orval/query 8.1.0 → 8.3.0

package/dist/index.mjs

@@ -58,11 +58,6 @@ const vueUnRefParams = (props) => {
 };
 const wrapRouteParameters = (route, prepend, append) => route.replaceAll(TEMPLATE_TAG_REGEX, `\${${prepend}$1${append}}`);
 const makeRouteSafe = (route) => wrapRouteParameters(route, "encodeURIComponent(String(", "))");
-const isVue = (client) => OutputClient.VUE_QUERY === client;
-const isSolid = (client) => OutputClient.SOLID_QUERY === client;
-const isAngular = (client) => OutputClient.ANGULAR_QUERY === client;
-const isReact = (client) => OutputClient.REACT_QUERY === client;
-const isSvelte = (client) => OutputClient.SVELTE_QUERY === client;
 const getQueryTypeForFramework = (type) => {
 	switch (type) {
 		case "suspenseQuery": return "query";
@@ -121,14 +116,13 @@ const ANGULAR_HTTP_DEPENDENCIES = [
 		exports: [{
 			name: "takeUntil",
 			values: true
+		}, {
+			name: "map",
+			values: true
 		}],
 		dependency: "rxjs/operators"
 	}
 ];
-const generateQueryRequestFunction = (verbOptions, options, isVue$1, isAngularClient = false) => {
-	if (isAngularClient || options.context.output.httpClient === OutputHttpClient.ANGULAR) return generateAngularHttpRequestFunction(verbOptions, options);
-	return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, isVue$1) : generateRequestFunction(verbOptions, options);
-};
 const generateAngularHttpRequestFunction = ({ headers, queryParams, operationName, response, mutator, body, props, verb, formData, formUrlEncoded, override }, { route, context }) => {
 	const isRequestOptions = override.requestOptions !== false;
 	const isFormData = !override.formData.disabled;
@@ -180,7 +174,7 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
 	if (headers) httpOptions.push("headers: new HttpHeaders(headers)");
 	const optionsStr = httpOptions.length > 0 ? `, { ${httpOptions.join(", ")} }` : "";
 	let httpCall;
-	const bodyArg = body.definition ? toObjectString([body], "implementation").replace(/,\s*$/, "") : "";
+	const bodyArg = isFormData && body.formData ? "formData" : isFormUrlEncoded && body.formUrlEncoded ? "formUrlEncoded" : body.definition ? toObjectString([body], "implementation").replace(/,\s*$/, "") : "";
 	switch (verb) {
 		case "get":
 		case "head":
@@ -193,6 +187,17 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
 			httpCall = `http.${verb}<${dataType}>(url, ${bodyArg || "undefined"}${optionsStr})`;
 			break;
 	}
+	const responseType = response.definition.success;
+	const isPrimitiveType = [
+		"string",
+		"number",
+		"boolean",
+		"void",
+		"unknown"
+	].includes(responseType);
+	const hasSchema = response.imports.some((imp) => imp.name === responseType);
+	const isZodOutput = isObject(context.output.schemas) && context.output.schemas.type === "zod";
+	if (override.query.runtimeValidation && isZodOutput && !isPrimitiveType && hasSchema) httpCall = `${httpCall}.pipe(map(data => ${responseType}.parse(data)))`;
 	const additionalParams = [queryProps, hasSignal ? "options?: { signal?: AbortSignal | null }" : ""].filter(Boolean).join(", ");
 	return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (
     http: HttpClient${additionalParams ? `,\n    ${additionalParams}` : ""}
@@ -207,10 +212,10 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
   }
 `;
 };
-const generateAxiosRequestFunction = ({ headers, queryParams, operationName, response, mutator, body, props: _props, verb, formData, formUrlEncoded, override, paramsSerializer }, { route: _route, context }, isVue$1) => {
+const generateAxiosRequestFunction = ({ headers, queryParams, operationName, response, mutator, body, props: _props, verb, formData, formUrlEncoded, override, paramsSerializer }, { route: _route, context }, isVue) => {
 	let props = _props;
 	let route = _route;
-	if (isVue$1) props = vueWrapTypeWithMaybeRef(_props);
+	if (isVue) props = vueWrapTypeWithMaybeRef(_props);
 	if (context.output.urlEncodeParameters) route = makeRouteSafe(route);
 	const isRequestOptions = override.requestOptions !== false;
 	const isFormData = !override.formData.disabled;
@@ -238,7 +243,7 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 			hasSignal,
 			hasSignalParam,
 			isExactOptionalPropertyTypes,
-			isVue: isVue$1
+			isVue
 		});
 		const bodyDefinition = body.definition.replace("[]", String.raw`\[\]`);
 		const propsImplementation = mutator.bodyTypeName && body.definition ? toObjectString(props, "implementation").replace(new RegExp(String.raw`(\w*):\s?${bodyDefinition}`), `$1: ${mutator.bodyTypeName}<${body.definition}>`) : toObjectString(props, "implementation");
@@ -270,13 +275,13 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
         }
       }
     `;
-			return isVue$1 ? vueRet : ret;
+			return isVue ? vueRet : ret;
 		}
 		return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<typeof ${mutator.name}>,` : ""}${getSignalDefinition({
 			hasSignal,
 			hasSignalParam
 		})}) => {
-      ${isVue$1 ? vueUnRefParams(props) : ""}
+      ${isVue ? vueUnRefParams(props) : ""}
       ${bodyForm}
       return ${mutator.name}<${response.definition.success || "unknown"}>(
       ${mutatorConfig},
@@ -300,7 +305,7 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 		isExactOptionalPropertyTypes,
 		hasSignal,
 		hasSignalParam,
-		isVue: isVue$1
+		isVue
 	});
 	const optionsArgs = generateRequestOptionsArguments({
 		isRequestOptions,
@@ -309,7 +314,7 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 	});
 	const queryProps = toObjectString(props, "implementation");
 	return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${queryProps} ${optionsArgs} ): Promise<AxiosResponse<${response.definition.success || "unknown"}>> => {
-    ${isVue$1 ? vueUnRefParams(props) : ""}
+    ${isVue ? vueUnRefParams(props) : ""}
     ${bodyForm}
     return axios${isSyntheticDefaultImportsAllowed ? "" : ".default"}.${verb}(${options});
   }
@@ -389,11 +394,6 @@ const getMutationRequestArgs = (isRequestOptions, httpClient, mutator) => {
 	if (mutator?.hasSecondArg && httpClient === OutputHttpClient.ANGULAR) return "http";
 	return isRequestOptions ? mutator ? mutator.hasSecondArg ? "requestOptions" : "" : options : "";
 };
-const getHttpFunctionQueryProps = (isVue$1, httpClient, queryProperties, isAngular$1 = false, hasMutator = false) => {
-	const result = isVue$1 && httpClient === OutputHttpClient.FETCH && queryProperties ? queryProperties.split(",").map((prop) => `unref(${prop})`).join(",") : queryProperties;
-	if ((isAngular$1 || httpClient === OutputHttpClient.ANGULAR) && !hasMutator) return result ? `http, ${result}` : "http";
-	return result;
-};
 const getQueryHeader = (params) => {
 	return params.output.httpClient === OutputHttpClient.FETCH ? generateFetchHeader(params) : "";
 };
@@ -583,7 +583,8 @@ const REACT_QUERY_DEPENDENCIES = [{
 const getReactQueryDependencies = (hasGlobalMutator, hasParamsSerializerOptions, packageJson, httpClient, hasTagsMutator, override) => {
 	const hasReactQuery = packageJson?.dependencies?.["react-query"] ?? packageJson?.devDependencies?.["react-query"] ?? packageJson?.peerDependencies?.["react-query"];
 	const hasReactQueryV4 = packageJson?.dependencies?.["@tanstack/react-query"] ?? packageJson?.devDependencies?.["@tanstack/react-query"] ?? packageJson?.peerDependencies?.["@tanstack/react-query"];
-	const useReactQueryV3 = override.query.version === void 0 ? hasReactQuery && !hasReactQueryV4 : override.query.version <= 3;
+	const queryVersion = override?.query.version;
+	const useReactQueryV3 = queryVersion === void 0 ? hasReactQuery && !hasReactQueryV4 : queryVersion <= 3;
 	return [
 		...hasGlobalMutator || hasTagsMutator ? REACT_DEPENDENCIES : [],
 		...!hasGlobalMutator && httpClient === OutputHttpClient.AXIOS ? AXIOS_DEPENDENCIES : [],
@@ -682,36 +683,39 @@ const VUE_QUERY_DEPENDENCIES = [{
 	],
 	dependency: "vue"
 }];
-const SOLID_QUERY_DEPENDENCIES = [{
-	exports: [
-		{
-			name: "createQuery",
-			values: true
-		},
-		{
-			name: "createInfiniteQuery",
-			values: true
-		},
-		{
-			name: "createMutation",
-			values: true
-		},
-		{ name: "CreateQueryOptions" },
-		{ name: "CreateInfiniteQueryOptions" },
-		{ name: "CreateMutationOptions" },
-		{ name: "QueryFunction" },
-		{ name: "MutationFunction" },
-		{ name: "CreateQueryResult" },
-		{ name: "CreateInfiniteQueryResult" },
-		{ name: "QueryKey" },
-		{ name: "InfiniteData" },
-		{ name: "CreateMutationResult" },
-		{ name: "DataTag" },
-		{ name: "QueryClient" },
-		{ name: "InvalidateOptions" }
-	],
-	dependency: "@tanstack/solid-query"
-}];
+const getSolidQueryImports = (prefix) => {
+	const capitalized = prefix === "use" ? "Use" : "Create";
+	return [{
+		exports: [
+			{
+				name: `${prefix}Query`,
+				values: true
+			},
+			{
+				name: `${prefix}InfiniteQuery`,
+				values: true
+			},
+			{
+				name: `${prefix}Mutation`,
+				values: true
+			},
+			{ name: `${capitalized}QueryOptions` },
+			{ name: `${capitalized}InfiniteQueryOptions` },
+			{ name: `${capitalized}MutationOptions` },
+			{ name: "QueryFunction" },
+			{ name: "MutationFunction" },
+			{ name: `${capitalized}QueryResult` },
+			{ name: `${capitalized}InfiniteQueryResult` },
+			{ name: "QueryKey" },
+			{ name: "InfiniteData" },
+			{ name: `${capitalized}MutationResult` },
+			{ name: "DataTag" },
+			{ name: "QueryClient" },
+			{ name: "InvalidateOptions" }
+		],
+		dependency: "@tanstack/solid-query"
+	}];
+};
 const ANGULAR_QUERY_DEPENDENCIES = [{
 	exports: [
 		{
@@ -778,7 +782,7 @@ const getSolidQueryDependencies = (hasGlobalMutator, hasParamsSerializerOptions,
 	return [
 		...!hasGlobalMutator && httpClient === OutputHttpClient.AXIOS ? AXIOS_DEPENDENCIES : [],
 		...hasParamsSerializerOptions ? PARAMS_SERIALIZER_DEPENDENCIES : [],
-		...SOLID_QUERY_DEPENDENCIES
+		...getSolidQueryImports(isSolidQueryWithUsePrefix(packageJson) ? "use" : "create")
 	];
 };
 const getAngularQueryDependencies = (hasGlobalMutator, hasParamsSerializerOptions, packageJson, httpClient) => {
@@ -818,6 +822,12 @@ const isQueryV5WithInfiniteQueryOptionsError = (packageJson, queryClient) => {
 	const withoutRc = version.split("-")[0];
 	return compareVersions(withoutRc, "5.80.0");
 };
+const isSolidQueryWithUsePrefix = (packageJson) => {
+	const version = getPackageByQueryClient(packageJson, "solid-query");
+	if (!version) return false;
+	const withoutRc = version.split("-")[0];
+	return compareVersions(withoutRc, "5.71.5");
+};
 const getPackageByQueryClient = (packageJson, queryClient) => {
 	switch (queryClient) {
 		case "react-query": return packageJson?.dependencies?.["@tanstack/react-query"] ?? packageJson?.devDependencies?.["@tanstack/react-query"] ?? packageJson?.peerDependencies?.["@tanstack/react-query"];
@@ -837,21 +847,20 @@ const QueryType = {
 	SUSPENSE_INFINITE: "suspenseInfiniteQuery"
 };
 const INFINITE_QUERY_PROPERTIES = new Set(["getNextPageParam", "getPreviousPageParam"]);
-const generateQueryOptions = ({ params, options, type, outputClient }) => {
+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)}` : "";
 	if (params.length === 0 || isSuspenseQuery(type)) {
 		if (options) return `${queryConfig} ...queryOptions`;
 		return "...queryOptions";
 	}
-	return `${!isObject(options) || !Object.hasOwn(options, "enabled") ? isVue(outputClient) ? `enabled: computed(() => !!(${params.map(({ name }) => `unref(${name})`).join(" && ")})),` : `enabled: !!(${params.map(({ name }) => name).join(" && ")}),` : ""}${queryConfig} ...queryOptions`;
+	return `${adapter ? adapter.generateEnabledOption(params, options) : !isObject(options) || !Object.hasOwn(options, "enabled") ? `enabled: !!(${params.map(({ name }) => name).join(" && ")}),` : ""}${queryConfig} ...queryOptions`;
 };
 const isSuspenseQuery = (type) => {
 	return [QueryType.SUSPENSE_INFINITE, QueryType.SUSPENSE_QUERY].includes(type);
 };
-const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type, hasSvelteQueryV4, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData, isAngularClient }) => {
+const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type, prefix, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData }) => {
 	const isMutatorHook = mutator?.isHook;
-	const prefix = !hasSvelteQueryV4 && !isAngularClient ? "Use" : "Create";
 	const partialOptions = !isReturnType && hasQueryV5;
 	if (type) {
 		const funcReturnType = `Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>`;
@@ -867,109 +876,562 @@ const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type,
 	}
 	return `${prefix}MutationOptions<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError,${definitions ? `{${definitions}}` : "void"}, TContext>`;
 };
-const generateQueryArguments = ({ operationName, definitions, mutator, isRequestOptions, type, hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, initialData, httpClient, isAngularClient, forQueryOptions = false, forAngularInject = false }) => {
-	const definition = getQueryOptionsDefinition({
-		operationName,
-		mutator,
-		definitions,
-		type,
-		hasSvelteQueryV4,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
-		queryParams,
-		queryParam,
-		isReturnType: false,
-		initialData,
-		isAngularClient
-	});
-	if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
-	const requestType = getQueryArgumentsRequestType(httpClient, mutator);
-	const isQueryRequired = initialData === "defined";
-	const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${requestType}}`;
-	if (forAngularInject) return `options${isQueryRequired ? "" : "?"}: ${optionsType} | (() => ${optionsType})\n`;
-	return `options${isQueryRequired ? "" : "?"}: ${hasSvelteQueryV6 && !forQueryOptions ? "() => " : ""}${optionsType}\n`;
-};
 
 //#endregion
-//#region src/return-types.ts
-const generateQueryReturnType = ({ outputClient, type, isMutatorHook, operationName, hasVueQueryV4, hasSvelteQueryV4, hasQueryV5, hasQueryV5WithDataTagError, isInitialDataDefined }) => {
-	switch (outputClient) {
-		case OutputClient.ANGULAR_QUERY:
+//#region src/frameworks/angular.ts
+const createAngularAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError }) => {
+	const prefix = "Create";
+	return {
+		outputClient: OutputClient.ANGULAR_QUERY,
+		hookPrefix: "inject",
+		isAngularHttp: true,
+		hasQueryV5,
+		hasQueryV5WithDataTagError,
+		hasQueryV5WithInfiniteQueryOptionsError,
+		getHookPropsDefinitions(props) {
+			return toObjectString(props.map((prop) => {
+				const getterType = prop.definition.replace(/^(\w+)(\??): (.+)$/, (_match, name, optional, type) => `${name}${optional}: ${type} | (() => ${type.replace(" | undefined", "")}${optional ? " | undefined" : ""})`);
+				return {
+					...prop,
+					definition: getterType
+				};
+			}), "definition");
+		},
+		getHttpFunctionQueryProps(queryProperties, _httpClient, hasMutator) {
+			if (!hasMutator) return queryProperties ? `http, ${queryProperties}` : "http";
+			return queryProperties;
+		},
+		getInfiniteQueryHttpProps(props, queryParam, hasMutator) {
+			let result = props.map((param) => {
+				if (param.type === GetterPropType.NAMED_PATH_PARAMS) return param.destructured;
+				return param.name === "params" ? `{...params, '${queryParam}': pageParam || params?.['${queryParam}']}` : param.name;
+			}).join(",");
+			if (!hasMutator) result = result ? `http, ${result}` : "http";
+			return result;
+		},
+		getHttpFirstParam(mutator) {
+			if (!mutator || mutator.hasSecondArg) return "http: HttpClient, ";
+			return "";
+		},
+		getMutationHttpPrefix(mutator) {
+			if (!mutator) return "http, ";
+			return "";
+		},
+		getQueryReturnType({ type }) {
 			if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `CreateQueryResult<TData, TError>`;
 			return `CreateInfiniteQueryResult<TData, TError>`;
-		case OutputClient.SOLID_QUERY:
-			if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `CreateQueryResult<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
-			return `CreateInfiniteQueryResult<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
-		case OutputClient.SVELTE_QUERY:
-			if (!hasSvelteQueryV4) return `Use${pascal(type)}StoreResult<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError, TData, QueryKey> & { queryKey: QueryKey} }`;
-			return `Create${pascal(type)}Result<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
-		case OutputClient.VUE_QUERY:
-			if (!hasVueQueryV4) return ` UseQueryReturnType<TData, TError, Use${pascal(type)}Result<TData, TError>> & { queryKey: QueryKey} }`;
-			if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `UseQueryReturnType<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
-			return `UseInfiniteQueryReturnType<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
-		default: return ` ${isInitialDataDefined && !isSuspenseQuery(type) ? "Defined" : ""}Use${pascal(type)}Result<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
-	}
-};
-const generateMutatorReturnType = ({ outputClient, dataType, variableType }) => {
-	if (outputClient === OutputClient.ANGULAR_QUERY) return `: CreateMutationResult<
+		},
+		getMutationReturnType({ dataType, variableType }) {
+			return `: CreateMutationResult<
         Awaited<ReturnType<${dataType}>>,
         TError,
         ${variableType},
         TContext
       >`;
-	if (outputClient === OutputClient.REACT_QUERY) return `: UseMutationResult<
+		},
+		getQueryReturnStatement({ queryResultVarName }) {
+			return `return ${queryResultVarName};`;
+		},
+		shouldAnnotateQueryKey() {
+			return false;
+		},
+		generateQueryInit({ mutator }) {
+			if (!mutator || mutator.hasSecondArg) return `const http = inject(HttpClient);`;
+			return "";
+		},
+		generateQueryInvocationArgs({ props, queryOptionsFnName, isRequestOptions, mutator }) {
+			return `() => {${props.length > 0 ? `
+    // Resolve params if getter function (for signal reactivity)
+    ${props.map((p) => `const _${p.name} = typeof ${p.name} === 'function' ? ${p.name}() : ${p.name};`).join("\n    ")}` : ""}
+    // Resolve options if getter function (for signal reactivity)
+    const _options = typeof ${isRequestOptions ? "options" : "queryOptions"} === 'function' ? ${isRequestOptions ? "options" : "queryOptions"}() : ${isRequestOptions ? "options" : "queryOptions"};
+    return ${queryOptionsFnName}(${!mutator || mutator.hasSecondArg ? "http" : ""}${props.length > 0 ? `${!mutator || mutator.hasSecondArg ? ", " : ""}${props.map((p) => `_${p.name}`).join(", ")}` : ""}, _options);
+  }`;
+		},
+		getOptionalQueryClientArgument() {
+			return "";
+		},
+		getQueryOptionsDefinitionPrefix() {
+			return prefix;
+		},
+		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation }) {
+			const definition = getQueryOptionsDefinition({
+				operationName,
+				mutator,
+				definitions,
+				type,
+				prefix,
+				hasQueryV5,
+				hasQueryV5WithInfiniteQueryOptionsError,
+				queryParams,
+				queryParam,
+				isReturnType: false,
+				initialData
+			});
+			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
+			const requestType = getQueryArgumentsRequestType(httpClient, mutator);
+			const isQueryRequired = initialData === "defined";
+			const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
+			if (type !== void 0 && !forQueryOptions) return `options${isQueryRequired ? "" : "?"}: ${optionsType} | (() => ${optionsType})\n`;
+			return `options${isQueryRequired ? "" : "?"}: ${optionsType}\n`;
+		},
+		generateMutationImplementation({ mutationOptionsFnName, hasInvalidation, isRequestOptions }) {
+			return `${mutationOptionsFnName}(${hasInvalidation ? `queryClient, ` : ""}${isRequestOptions ? "options" : "mutationOptions"})`;
+		},
+		supportsMutationInvalidation() {
+			return true;
+		},
+		generateMutationOnSuccess({ operationName, definitions, isRequestOptions, generateInvalidateCall: generateInvalidateCall$1, uniqueInvalidates }) {
+			const invalidateCalls = uniqueInvalidates.map((t) => generateInvalidateCall$1(t)).join("\n");
+			if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, 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) => {
+${invalidateCalls}
+    mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
+  };`;
+		},
+		generateMutationHookBody({ operationPrefix, mutationOptionsFnName, mutationOptionsVarName, isRequestOptions, mutator, hasInvalidation }) {
+			if (!mutator || mutator.hasSecondArg) return `      const http = inject(HttpClient);${hasInvalidation ? "\n      const queryClient = inject(QueryClient);" : ""}
+      const ${mutationOptionsVarName} = ${mutationOptionsFnName}(http${hasInvalidation ? ", queryClient" : ""}${isRequestOptions ? ", options" : ", mutationOptions"});
+
+      return ${operationPrefix}Mutation(() => ${mutationOptionsVarName});`;
+			return `      const ${mutationOptionsVarName} = ${`${mutationOptionsFnName}(${hasInvalidation ? `queryClient, ` : ""}${isRequestOptions ? "options" : "mutationOptions"})`};
+
+      return ${operationPrefix}Mutation(() => ${mutationOptionsVarName});`;
+		},
+		getQueryType(type) {
+			return getQueryTypeForFramework(type);
+		},
+		generateRequestFunction(verbOptions, options) {
+			return generateAngularHttpRequestFunction(verbOptions, options);
+		}
+	};
+};
+
+//#endregion
+//#region src/frameworks/react.ts
+const createReactAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError }) => ({
+	outputClient: OutputClient.REACT_QUERY,
+	hookPrefix: "use",
+	hasQueryV5,
+	hasQueryV5WithDataTagError,
+	hasQueryV5WithInfiniteQueryOptionsError,
+	getQueryReturnType({ type, isInitialDataDefined }) {
+		return ` ${isInitialDataDefined && !isSuspenseQuery(type) ? "Defined" : ""}Use${pascal(type)}Result<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
+	},
+	getMutationReturnType({ dataType, variableType }) {
+		return `: UseMutationResult<
         Awaited<ReturnType<${dataType}>>,
         TError,
         ${variableType},
         TContext
       >`;
-	if (outputClient === OutputClient.SOLID_QUERY) return `: CreateMutationResult<
+	},
+	getQueryReturnStatement({ queryResultVarName, queryOptionsVarName }) {
+		return `return { ...${queryResultVarName}, queryKey: ${queryOptionsVarName}.queryKey };`;
+	},
+	shouldGenerateOverrideTypes() {
+		return hasQueryV5;
+	},
+	generateMutationImplementation({ mutationOptionsFnName, hasInvalidation, isRequestOptions }) {
+		return `${mutationOptionsFnName}(${hasInvalidation ? `queryClient ?? backupQueryClient, ` : ""}${isRequestOptions ? "options" : "mutationOptions"})`;
+	},
+	supportsMutationInvalidation() {
+		return true;
+	},
+	generateMutationOnSuccess({ operationName, definitions, isRequestOptions, generateInvalidateCall: generateInvalidateCall$1, uniqueInvalidates }) {
+		const invalidateCalls = uniqueInvalidates.map((t) => generateInvalidateCall$1(t)).join("\n");
+		if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext) => {
+    if (!options?.skipInvalidation) {
+${invalidateCalls}
+    }
+    mutationOptions?.onSuccess?.(data, variables, context);
+  };`;
+		return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext) => {
+${invalidateCalls}
+    mutationOptions?.onSuccess?.(data, variables, context);
+  };`;
+	},
+	generateMutationHookBody({ operationPrefix, mutationImplementation, hasInvalidation, optionalQueryClientArgument }) {
+		return `      ${hasInvalidation ? `const backupQueryClient = useQueryClient();\n      ` : ""}return ${operationPrefix}Mutation(${mutationImplementation}${optionalQueryClientArgument ? `, queryClient` : ""});`;
+	},
+	generateRequestFunction(verbOptions, options) {
+		return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, false) : generateRequestFunction(verbOptions, options);
+	}
+});
+
+//#endregion
+//#region src/frameworks/solid.ts
+const createSolidAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError, hasSolidQueryUsePrefix }) => ({
+	outputClient: OutputClient.SOLID_QUERY,
+	hookPrefix: hasSolidQueryUsePrefix ? "use" : "create",
+	hasQueryV5,
+	hasQueryV5WithDataTagError,
+	hasQueryV5WithInfiniteQueryOptionsError,
+	getQueryOptionsDefinitionPrefix() {
+		return hasSolidQueryUsePrefix ? "Use" : "Create";
+	},
+	getQueryReturnType({ type }) {
+		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} }`;
+	},
+	getMutationReturnType({ dataType, variableType }) {
+		return `: ${hasSolidQueryUsePrefix ? "Use" : "Create"}MutationResult<
         Awaited<ReturnType<${dataType}>>,
         TError,
         ${variableType},
         TContext
       >`;
-	if (outputClient === OutputClient.SVELTE_QUERY) return `: CreateMutationResult<
+	},
+	getQueryReturnStatement({ queryResultVarName, queryOptionsVarName }) {
+		return `return { ...${queryResultVarName}, queryKey: ${queryOptionsVarName}.queryKey };`;
+	},
+	generateMutationImplementation({ mutationOptionsFnName, isRequestOptions }) {
+		return `${mutationOptionsFnName}(${isRequestOptions ? "options" : "mutationOptions"})`;
+	},
+	supportsMutationInvalidation() {
+		return false;
+	},
+	generateMutationOnSuccess() {
+		return "";
+	},
+	generateMutationHookBody({ operationPrefix, mutationImplementation, optionalQueryClientArgument }) {
+		return `      return ${operationPrefix}Mutation(${mutationImplementation}${optionalQueryClientArgument ? `, queryClient` : ""});`;
+	},
+	generateRequestFunction(verbOptions, options) {
+		return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, false) : generateRequestFunction(verbOptions, options);
+	}
+});
+
+//#endregion
+//#region src/frameworks/svelte.ts
+const createSvelteAdapter = ({ hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError }) => {
+	const prefix = hasSvelteQueryV4 ? "Create" : "Use";
+	return {
+		outputClient: OutputClient.SVELTE_QUERY,
+		hookPrefix: hasSvelteQueryV4 ? "create" : "use",
+		hasQueryV5,
+		hasQueryV5WithDataTagError,
+		hasQueryV5WithInfiniteQueryOptionsError,
+		getHookPropsDefinitions(props) {
+			if (hasSvelteQueryV6) return toObjectString(props.map((p) => ({
+				...p,
+				definition: p.definition.replace(":", ": () => ")
+			})), "definition");
+			return toObjectString(props, "implementation");
+		},
+		getQueryReturnType({ type, isMutatorHook, operationName }) {
+			if (!hasSvelteQueryV4) return `Use${pascal(type)}StoreResult<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError, TData, QueryKey> & { queryKey: QueryKey }`;
+			return `Create${pascal(type)}Result<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
+		},
+		getMutationReturnType({ dataType, variableType }) {
+			return `: CreateMutationResult<
         Awaited<ReturnType<${dataType}>>,
         TError,
         ${variableType},
         TContext
       >`;
-	if (outputClient === OutputClient.VUE_QUERY) return `: UseMutationReturnType<
+		},
+		getQueryReturnStatement({ queryResultVarName, queryOptionsVarName }) {
+			if (hasSvelteQueryV6) return `return ${queryResultVarName}`;
+			if (hasSvelteQueryV4) return `${queryResultVarName}.queryKey = ${queryOptionsVarName}.queryKey;
+
+  return ${queryResultVarName};`;
+			return `return { ...${queryResultVarName}, queryKey: ${queryOptionsVarName}.queryKey };`;
+		},
+		generateQueryInit({ queryOptionsFnName, queryProperties, isRequestOptions }) {
+			if (hasSvelteQueryV6) return "";
+			return `const ${isRequestOptions ? "queryOptions" : "options"} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})`;
+		},
+		generateQueryInvocationArgs({ props, queryOptionsFnName, isRequestOptions, queryOptionsVarName, optionalQueryClientArgument }) {
+			if (hasSvelteQueryV6) return `() => ${queryOptionsFnName}(${toObjectString(props.map((p) => ({
+				...p,
+				name: p.default || !p.required ? `${p.name}?.()` : `${p.name}()`
+			})), "name")}${isRequestOptions ? "options?.()" : "queryOptions?.()"})`;
+			return `${queryOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""}`;
+		},
+		getQueryInvocationSuffix() {
+			return hasSvelteQueryV6 ? `, queryClient` : "";
+		},
+		getOptionalQueryClientArgument(hasInvalidation) {
+			if (hasSvelteQueryV6) return `, queryClient?: () => QueryClient`;
+			if (hasQueryV5 || hasInvalidation) return ", queryClient?: QueryClient";
+			return "";
+		},
+		getQueryOptionsDefinitionPrefix() {
+			return prefix;
+		},
+		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation }) {
+			const definition = getQueryOptionsDefinition({
+				operationName,
+				mutator,
+				definitions,
+				type,
+				prefix,
+				hasQueryV5,
+				hasQueryV5WithInfiniteQueryOptionsError,
+				queryParams,
+				queryParam,
+				isReturnType: false,
+				initialData
+			});
+			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
+			const requestType = getQueryArgumentsRequestType(httpClient, mutator);
+			const isQueryRequired = initialData === "defined";
+			const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
+			return `options${isQueryRequired ? "" : "?"}: ${hasSvelteQueryV6 && !forQueryOptions ? "() => " : ""}${optionsType}\n`;
+		},
+		generateMutationImplementation({ mutationOptionsFnName, hasInvalidation, isRequestOptions }) {
+			if (hasSvelteQueryV6) return `${mutationOptionsFnName}(${hasInvalidation ? `backupQueryClient, ` : ""}${isRequestOptions ? "options" : "mutationOptions"}?.())`;
+			return `${mutationOptionsFnName}(${hasInvalidation ? `queryClient ?? backupQueryClient, ` : ""}${isRequestOptions ? "options" : "mutationOptions"})`;
+		},
+		supportsMutationInvalidation() {
+			return true;
+		},
+		generateMutationOnSuccess({ operationName, definitions, isRequestOptions, generateInvalidateCall: generateInvalidateCall$1, uniqueInvalidates }) {
+			const invalidateCalls = uniqueInvalidates.map((t) => generateInvalidateCall$1(t)).join("\n");
+			if (hasSvelteQueryV6) {
+				if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, 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) => {
+${invalidateCalls}
+    mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
+  };`;
+			}
+			if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext | undefined) => {
+    if (!options?.skipInvalidation) {
+${invalidateCalls}
+    }
+    mutationOptions?.onSuccess?.(data, variables, context);
+  };`;
+			return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext | undefined) => {
+${invalidateCalls}
+    mutationOptions?.onSuccess?.(data, variables, context);
+  };`;
+		},
+		generateMutationHookBody({ operationPrefix, mutationImplementation, hasInvalidation, optionalQueryClientArgument }) {
+			if (hasSvelteQueryV6) return `      ${hasInvalidation ? `const backupQueryClient = useQueryClient(${optionalQueryClientArgument ? "queryClient?.()" : ""});\n      ` : ""}return ${operationPrefix}Mutation(() => ({ ...${mutationImplementation} })${optionalQueryClientArgument ? `, queryClient` : ""});`;
+			return `      ${hasInvalidation ? `const backupQueryClient = useQueryClient();\n      ` : ""}return ${operationPrefix}Mutation(${mutationImplementation});`;
+		},
+		getQueryType(type) {
+			if (hasSvelteQueryV4) return getQueryTypeForFramework(type);
+			return type;
+		},
+		generateRequestFunction(verbOptions, options) {
+			return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, false) : generateRequestFunction(verbOptions, options);
+		}
+	};
+};
+
+//#endregion
+//#region src/frameworks/vue.ts
+const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError }) => ({
+	outputClient: OutputClient.VUE_QUERY,
+	hookPrefix: "use",
+	hasQueryV5,
+	hasQueryV5WithDataTagError,
+	hasQueryV5WithInfiniteQueryOptionsError,
+	transformProps(props) {
+		return vueWrapTypeWithMaybeRef(props);
+	},
+	shouldDestructureNamedPathParams() {
+		return false;
+	},
+	getHttpFunctionQueryProps(queryProperties, httpClient) {
+		if (httpClient === OutputHttpClient.FETCH && queryProperties) return queryProperties.split(",").map((prop) => `unref(${prop})`).join(",");
+		return queryProperties;
+	},
+	getInfiniteQueryHttpProps(props, queryParam) {
+		return props.map((param) => {
+			return param.name === "params" ? `{...unref(params), '${queryParam}': pageParam || unref(params)?.['${queryParam}']}` : param.name;
+		}).join(",");
+	},
+	getQueryReturnType({ type }) {
+		if (!hasVueQueryV4) return ` UseQueryReturnType<TData, TError, Use${pascal(type)}Result<TData, TError>> & { queryKey: QueryKey }`;
+		if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `UseQueryReturnType<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
+		return `UseInfiniteQueryReturnType<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
+	},
+	getMutationReturnType({ dataType, variableType }) {
+		return `: UseMutationReturnType<
         Awaited<ReturnType<${dataType}>>,
         TError,
         ${variableType},
         TContext
       >`;
-	return "";
-};
-const getQueryFnArguments = ({ hasQueryParam, hasSignal, hasSignalParam = false }) => {
-	if (!hasQueryParam && !hasSignal) return "";
-	const signalDestructure = hasSignalParam ? "signal: querySignal" : "signal";
-	if (hasQueryParam) {
-		if (hasSignal) return `{ ${signalDestructure}, pageParam }`;
-		return "{ pageParam }";
-	}
-	return `{ ${signalDestructure} }`;
-};
-const getQueryReturnStatement = ({ outputClient, hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, hasQueryV5WithDataTagError, queryResultVarName, queryOptionsVarName }) => {
-	if (isAngular(outputClient)) return `return ${queryResultVarName};`;
-	if (isVue(outputClient)) return `${queryResultVarName}.queryKey = unref(${queryOptionsVarName}).queryKey as ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"};
+	},
+	getQueryReturnStatement({ queryResultVarName, queryOptionsVarName }) {
+		return `${queryResultVarName}.queryKey = unref(${queryOptionsVarName}).queryKey as ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"};
 
   return ${queryResultVarName};`;
-	if (hasSvelteQueryV6) return `return ${queryResultVarName}`;
-	if (hasSvelteQueryV4) return `${queryResultVarName}.queryKey = ${queryOptionsVarName}.queryKey;
+	},
+	getQueryKeyRouteString(route) {
+		return getRouteAsArray(route);
+	},
+	shouldAnnotateQueryKey() {
+		return false;
+	},
+	getUnrefStatements(props) {
+		return vueUnRefParams(props.filter((prop) => prop.type === GetterPropType.NAMED_PATH_PARAMS));
+	},
+	generateEnabledOption(params, options) {
+		if (!isObject(options) || !Object.hasOwn(options, "enabled")) return `enabled: computed(() => !!(${params.map(({ name }) => `unref(${name})`).join(" && ")})),`;
+		return "";
+	},
+	getQueryKeyPrefix() {
+		return hasVueQueryV4 ? "" : "queryOptions?.queryKey ?? ";
+	},
+	generateMutationImplementation({ mutationOptionsFnName, isRequestOptions }) {
+		return `${mutationOptionsFnName}(${isRequestOptions ? "options" : "mutationOptions"})`;
+	},
+	supportsMutationInvalidation() {
+		return false;
+	},
+	generateMutationOnSuccess() {
+		return "";
+	},
+	generateMutationHookBody({ operationPrefix, mutationImplementation, optionalQueryClientArgument }) {
+		return `      return ${operationPrefix}Mutation(${mutationImplementation}${optionalQueryClientArgument ? `, queryClient` : ""});`;
+	},
+	generateRequestFunction(verbOptions, options) {
+		return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, true) : generateRequestFunction(verbOptions, options);
+	},
+	getQueryPropertyForProp(prop, body) {
+		return prop.type === GetterPropType.BODY ? body.implementation : prop.name;
+	}
+});
 
-  return ${queryResultVarName};`;
-	return `return { ...${queryResultVarName}, queryKey: ${queryOptionsVarName}.queryKey };`;
+//#endregion
+//#region src/frameworks/index.ts
+/** Fill in defaults for fields that most adapters leave empty or share a common implementation. */
+const withDefaults = (adapter) => ({
+	isAngularHttp: false,
+	getHttpFirstParam: () => "",
+	getMutationHttpPrefix: () => "",
+	getUnrefStatements: () => "",
+	getQueryInvocationSuffix: () => "",
+	transformProps: (props) => props,
+	getHttpFunctionQueryProps: (qp) => qp,
+	getQueryType: (type) => type,
+	shouldDestructureNamedPathParams: () => true,
+	shouldAnnotateQueryKey: () => true,
+	shouldGenerateOverrideTypes: () => false,
+	getQueryKeyPrefix: () => "queryOptions?.queryKey ?? ",
+	getQueryOptionsDefinitionPrefix: () => "Use",
+	getHookPropsDefinitions: (props) => toObjectString(props, "implementation"),
+	getQueryKeyRouteString(route, shouldSplitQueryKey) {
+		if (shouldSplitQueryKey) return getRouteAsArray(route);
+		return `\`${route}\``;
+	},
+	generateEnabledOption(params, options) {
+		if (!isObject(options) || !Object.hasOwn(options, "enabled")) return `enabled: !!(${params.map(({ name }) => name).join(" && ")}),`;
+		return "";
+	},
+	getQueryPropertyForProp(prop, body) {
+		if (prop.type === GetterPropType.NAMED_PATH_PARAMS) return prop.destructured;
+		return prop.type === GetterPropType.BODY ? body.implementation : prop.name;
+	},
+	getInfiniteQueryHttpProps(props, queryParam) {
+		return props.map((param) => {
+			if (param.type === GetterPropType.NAMED_PATH_PARAMS) return param.destructured;
+			return param.name === "params" ? `{...params, '${queryParam}': pageParam || params?.['${queryParam}']}` : param.name;
+		}).join(",");
+	},
+	generateQueryInit({ queryOptionsFnName, queryProperties, isRequestOptions }) {
+		return `const ${isRequestOptions ? "queryOptions" : "options"} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})`;
+	},
+	generateQueryInvocationArgs({ queryOptionsVarName, optionalQueryClientArgument }) {
+		return `${queryOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""}`;
+	},
+	getOptionalQueryClientArgument() {
+		return adapter.hasQueryV5 ? ", queryClient?: QueryClient" : "";
+	},
+	generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation }) {
+		const definition = getQueryOptionsDefinition({
+			operationName,
+			mutator,
+			definitions,
+			type,
+			prefix: adapter.getQueryOptionsDefinitionPrefix?.() ?? "Use",
+			hasQueryV5: adapter.hasQueryV5,
+			hasQueryV5WithInfiniteQueryOptionsError: adapter.hasQueryV5WithInfiniteQueryOptionsError,
+			queryParams,
+			queryParam,
+			isReturnType: false,
+			initialData
+		});
+		if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
+		const requestType = getQueryArgumentsRequestType(httpClient, mutator);
+		const isQueryRequired = initialData === "defined";
+		const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
+		return `options${isQueryRequired ? "" : "?"}: ${optionsType}\n`;
+	},
+	...adapter
+});
+/**
+* Create a FrameworkAdapter for the given output client, resolving version flags
+* from the packageJson and query config.
+*/
+const createFrameworkAdapter = ({ outputClient, packageJson, queryVersion }) => {
+	const clientType = outputClient;
+	const _hasQueryV5 = queryVersion === 5 || isQueryV5(packageJson, clientType);
+	const _hasQueryV5WithDataTagError = queryVersion === 5 || isQueryV5WithDataTagError(packageJson, clientType);
+	const _hasQueryV5WithInfiniteQueryOptionsError = queryVersion === 5 || isQueryV5WithInfiniteQueryOptionsError(packageJson, clientType);
+	switch (outputClient) {
+		case OutputClient.VUE_QUERY: return withDefaults(createVueAdapter({
+			hasVueQueryV4: !isVueQueryV3(packageJson) || queryVersion === 4,
+			hasQueryV5: _hasQueryV5,
+			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError
+		}));
+		case OutputClient.SVELTE_QUERY: return withDefaults(createSvelteAdapter({
+			hasSvelteQueryV4: !isSvelteQueryV3(packageJson) || queryVersion === 4,
+			hasSvelteQueryV6: isSvelteQueryV6(packageJson),
+			hasQueryV5: _hasQueryV5,
+			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError
+		}));
+		case OutputClient.ANGULAR_QUERY: return withDefaults(createAngularAdapter({
+			hasQueryV5: _hasQueryV5,
+			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError
+		}));
+		case OutputClient.SOLID_QUERY: return withDefaults(createSolidAdapter({
+			hasQueryV5: _hasQueryV5,
+			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
+			hasSolidQueryUsePrefix: isSolidQueryWithUsePrefix(packageJson)
+		}));
+		default: return withDefaults(createReactAdapter({
+			hasQueryV5: _hasQueryV5,
+			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError
+		}));
+	}
 };
 
 //#endregion
 //#region src/mutation-generator.ts
-const normalizeTarget = (target) => typeof target === "string" ? { query: target } : target;
+const normalizeTarget = (target) => isString(target) ? {
+	query: target,
+	invalidateMode: "invalidate"
+} : {
+	...target,
+	invalidateMode: target.invalidateMode ?? "invalidate"
+};
 const serializeTarget = (target) => JSON.stringify({
 	query: target.query,
-	params: target.params ?? []
+	params: target.params ?? [],
+	invalidateMode: target.invalidateMode
 });
 const generateVariableRef = (varName) => {
 	const parts = varName.split(".");
@@ -981,9 +1443,11 @@ const generateParamArgs = (params) => {
 	return Object.values(params).map((v) => generateVariableRef(v)).join(", ");
 };
 const generateInvalidateCall = (target) => {
-	return `    queryClient.invalidateQueries({ queryKey: ${camel(`get-${target.query}-query-key`)}(${target.params ? generateParamArgs(target.params) : ""}) });`;
+	const queryKeyFn = camel(`get-${target.query}-query-key`);
+	const args = target.params ? generateParamArgs(target.params) : "";
+	return `    queryClient.${target.invalidateMode === "reset" ? "resetQueries" : "invalidateQueries"}({ queryKey: ${queryKeyFn}(${args}) });`;
 };
-const generateMutationHook = async ({ verbOptions, options, outputClient, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, hasSvelteQueryV4, hasSvelteQueryV6, isRequestOptions, httpClient, doc, isAngularHttp }) => {
+const generateMutationHook = async ({ verbOptions, options, isRequestOptions, httpClient, doc, adapter }) => {
 	const { operationName, body, props, mutator, response, operationId, override } = verbOptions;
 	const { route, context, output } = options;
 	const query = override.query;
@@ -998,55 +1462,45 @@ const generateMutationHook = async ({ verbOptions, options, outputClient, hasQue
 	const properties = props.map(({ name, type }) => type === GetterPropType.BODY ? "data" : name).join(",");
 	const errorType = getQueryErrorType(operationName, response, httpClient, mutator);
 	const dataType = mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`;
-	const isAngularClient = isAngular(outputClient);
 	const mutationOptionFnReturnType = getQueryOptionsDefinition({
 		operationName,
 		mutator,
 		definitions,
-		hasSvelteQueryV4,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
-		isReturnType: true,
-		isAngularClient
+		prefix: adapter.getQueryOptionsDefinitionPrefix(),
+		hasQueryV5: adapter.hasQueryV5,
+		hasQueryV5WithInfiniteQueryOptionsError: adapter.hasQueryV5WithInfiniteQueryOptionsError,
+		isReturnType: true
+	});
+	const invalidatesConfig = (query.mutationInvalidates ?? []).filter((rule) => rule.onMutations.includes(operationName)).flatMap((rule) => rule.invalidates).map((t) => normalizeTarget(t));
+	const seenTargets = /* @__PURE__ */ new Set();
+	const uniqueInvalidates = invalidatesConfig.filter((target) => {
+		const key = serializeTarget(target);
+		if (seenTargets.has(key)) return false;
+		seenTargets.add(key);
+		return true;
 	});
-	const mutationArguments = generateQueryArguments({
+	const hasInvalidation = uniqueInvalidates.length > 0 && adapter.supportsMutationInvalidation();
+	const mutationArguments = adapter.generateQueryArguments({
 		operationName,
 		definitions,
 		mutator,
 		isRequestOptions,
-		hasSvelteQueryV4,
-		hasSvelteQueryV6,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
 		httpClient,
-		isAngularClient
+		hasInvalidation
 	});
-	const mutationArgumentsForOptions = generateQueryArguments({
+	const mutationArgumentsForOptions = adapter.generateQueryArguments({
 		operationName,
 		definitions,
 		mutator,
 		isRequestOptions,
-		hasSvelteQueryV4,
-		hasSvelteQueryV6,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
 		httpClient,
-		isAngularClient,
-		forQueryOptions: true
+		forQueryOptions: true,
+		hasInvalidation
 	});
 	const mutationOptionsFnName = camel(mutationOptionsMutator || mutator?.isHook ? `use-${operationName}-mutationOptions` : `get-${operationName}-mutationOptions`);
 	const hooksOptionImplementation = getHooksOptionImplementation(isRequestOptions, httpClient, camel(operationName), mutator);
-	const invalidatesConfig = (query.mutationInvalidates ?? []).filter((rule) => rule.onMutations.includes(operationName)).flatMap((rule) => rule.invalidates).map((t) => normalizeTarget(t));
-	const seenTargets = /* @__PURE__ */ new Set();
-	const uniqueInvalidates = invalidatesConfig.filter((target) => {
-		const key = serializeTarget(target);
-		if (seenTargets.has(key)) return false;
-		seenTargets.add(key);
-		return true;
-	});
-	const hasInvalidation = uniqueInvalidates.length > 0 && (isAngularClient || isReact(outputClient) || isSvelte(outputClient));
 	const mutationOptionsFn = `export const ${mutationOptionsFnName} = <TError = ${errorType},
-    TContext = unknown>(${isAngularHttp && (!mutator || mutator.hasSecondArg) ? "http: HttpClient, " : ""}${hasInvalidation ? "queryClient: QueryClient, " : ""}${mutationArgumentsForOptions}): ${mutationOptionFnReturnType} => {
+    TContext = unknown>(${adapter.getHttpFirstParam(mutator)}${hasInvalidation ? "queryClient: QueryClient, " : ""}${mutationArgumentsForOptions}): ${mutationOptionFnReturnType} => {
 
 ${hooksOptionImplementation}
 
@@ -1056,31 +1510,43 @@ ${hooksOptionImplementation}
       const mutationFn: MutationFunction<Awaited<ReturnType<${dataType}>>, ${definitions ? `{${definitions}}` : "void"}> = (${properties ? "props" : ""}) => {
           ${properties ? `const {${properties}} = props ?? {};` : ""}
 
-          return  ${operationName}(${isAngularHttp && !mutator ? "http, " : ""}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator)})
+          return  ${operationName}(${adapter.getMutationHttpPrefix(mutator)}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator)})
         }
 
-${hasInvalidation ? isAngular(outputClient) ? `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
-${uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n")}
-    mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
-  };` : isReact(outputClient) ? `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext) => {
-${uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n")}
-    mutationOptions?.onSuccess?.(data, variables, context);
-  };` : isSvelte(outputClient) ? hasSvelteQueryV6 ? `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
-${uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n")}
-    mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
-  };` : `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext | undefined) => {
-${uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n")}
-    mutationOptions?.onSuccess?.(data, variables, context);
-  };` : "" : ""}
+${hasInvalidation ? adapter.generateMutationOnSuccess({
+		operationName,
+		definitions,
+		isRequestOptions,
+		generateInvalidateCall,
+		uniqueInvalidates
+	}) : ""}
 
         ${mutationOptionsMutator ? `const customOptions = ${mutationOptionsMutator.name}({...mutationOptions, mutationFn}${mutationOptionsMutator.hasSecondArg ? `, { url: \`${route.replaceAll("/${", "/{")}\` }` : ""}${mutationOptionsMutator.hasThirdArg ? `, { operationId: '${operationId}', operationName: '${operationName}' }` : ""});` : ""}
 
 
-  return  ${mutationOptionsMutator ? "customOptions" : hasInvalidation ? "{ mutationFn, onSuccess, ...mutationOptions }" : "{ mutationFn, ...mutationOptions }"}}`;
-	const operationPrefix = getFrameworkPrefix(hasSvelteQueryV4, isAngular(outputClient), isSolid(outputClient));
-	const optionalQueryClientArgument = hasSvelteQueryV6 ? ", queryClient?: () => QueryClient" : (hasQueryV5 || isSvelte(outputClient) && hasInvalidation) && !isAngular(outputClient) ? ", queryClient?: QueryClient" : "";
-	const mutationImplementation = `${mutationOptionsFnName}(${hasInvalidation ? `queryClient${isReact(outputClient) || isSvelte(outputClient) && !hasSvelteQueryV6 ? " ?? backupQueryClient" : ""}${hasSvelteQueryV6 ? "?.() ?? backupQueryClient" : ""}, ` : ""}${isRequestOptions ? "options" : "mutationOptions"}${hasSvelteQueryV6 ? "?.()" : ""})`;
+  return  ${mutationOptionsMutator ? "customOptions" : hasInvalidation ? "{ ...mutationOptions, mutationFn, onSuccess }" : "{ mutationFn, ...mutationOptions }"}}`;
+	const operationPrefix = adapter.hookPrefix;
+	const optionalQueryClientArgument = adapter.getOptionalQueryClientArgument(hasInvalidation);
+	const mutationImplementation = adapter.generateMutationImplementation({
+		mutationOptionsFnName,
+		hasInvalidation,
+		isRequestOptions
+	});
 	const mutationOptionsVarName = camel(`${operationName}-mutation-options`);
+	const mutationReturnType = adapter.getMutationReturnType({
+		dataType,
+		variableType: definitions ? `{${definitions}}` : "void"
+	});
+	const mutationHookBody = adapter.generateMutationHookBody({
+		operationPrefix,
+		mutationOptionsFnName,
+		mutationImplementation,
+		mutationOptionsVarName,
+		isRequestOptions,
+		mutator,
+		hasInvalidation,
+		optionalQueryClientArgument
+	});
 	return {
 		implementation: `
 ${mutationOptionsFn}
@@ -1090,17 +1556,8 @@ ${mutationOptionsFn}
     export type ${pascal(operationName)}MutationError = ${errorType}
 
     ${doc}export const ${camel(`${operationPrefix}-${operationName}`)} = <TError = ${errorType},
-    TContext = unknown>(${mutationArguments} ${optionalQueryClientArgument})${generateMutatorReturnType({
-			outputClient,
-			dataType,
-			variableType: definitions ? `{${definitions}}` : "void"
-		})} => {
-${isAngular(outputClient) ? isAngularHttp && (!mutator || mutator.hasSecondArg) ? `      const http = inject(HttpClient);${hasInvalidation ? "\n      const queryClient = inject(QueryClient);" : ""}
-      const ${mutationOptionsVarName} = ${mutationOptionsFnName}(http${hasInvalidation ? ", queryClient" : ""}${isRequestOptions ? ", options" : ", mutationOptions"});
-
-      return ${operationPrefix}Mutation(() => ${mutationOptionsVarName});` : `      const ${mutationOptionsVarName} = ${mutationImplementation};
-
-      return ${operationPrefix}Mutation(() => ${mutationOptionsVarName});` : `      ${(isReact(outputClient) || isSvelte(outputClient)) && hasInvalidation ? "const backupQueryClient = useQueryClient();\n      " : ""}return ${operationPrefix}Mutation(${hasSvelteQueryV6 ? `() => ({ ...${mutationImplementation}${optionalQueryClientArgument ? `, queryClient` : ""} })` : isSvelte(outputClient) ? mutationImplementation : `${mutationImplementation}${optionalQueryClientArgument ? `, queryClient` : ""}`});`}
+    TContext = unknown>(${mutationArguments} ${optionalQueryClientArgument})${mutationReturnType} => {
+${mutationHookBody}
     }
     `,
 		mutators: mutationOptionsMutator ? [mutationOptionsMutator] : void 0
@@ -1109,20 +1566,14 @@ ${isAngular(outputClient) ? isAngularHttp && (!mutator || mutator.hasSecondArg)
 
 //#endregion
 //#region src/query-generator.ts
-/**
-* Get framework-aware prefix for hook names and type definitions
-* @param hasSvelteQueryV4 - Whether using Svelte Query v4
-* @param isAngularClient - Whether using Angular client
-* @param isSolidClient - Whether using Solid Query client
-* @param capitalize - Whether to capitalize the prefix (for type definitions)
-* @returns The appropriate prefix string
-*/
-const getFrameworkPrefix = (hasSvelteQueryV4, isAngularClient, isSolidClient, capitalize = false) => {
-	let prefix;
-	if (hasSvelteQueryV4 || isSolidClient) prefix = "create";
-	else if (isAngularClient) prefix = "inject";
-	else prefix = "use";
-	return capitalize ? prefix.charAt(0).toUpperCase() + prefix.slice(1) : prefix;
+const getQueryFnArguments = ({ hasQueryParam, hasSignal, hasSignalParam = false }) => {
+	if (!hasQueryParam && !hasSignal) return "";
+	const signalDestructure = hasSignalParam ? "signal: querySignal" : "signal";
+	if (hasQueryParam) {
+		if (hasSignal) return `{ ${signalDestructure}, pageParam }`;
+		return "{ pageParam }";
+	}
+	return `{ ${signalDestructure} }`;
 };
 const generatePrefetch = ({ usePrefetch, type, useQuery, useInfinite, operationName, mutator, doc, queryProps, dataType, errorType, queryArguments, queryOptionsVarName, queryOptionsFnName, queryProperties, isRequestOptions }) => {
 	if (!(usePrefetch && (type === QueryType.QUERY || type === QueryType.INFINITE || type === QueryType.SUSPENSE_QUERY && !useQuery || type === QueryType.SUSPENSE_INFINITE && !useInfinite))) return "";
@@ -1145,7 +1596,8 @@ const generatePrefetch = ({ usePrefetch, type, useQuery, useInfinite, operationN
   return queryClient;
 }\n`;
 };
-const generateQueryImplementation = ({ queryOption: { name, queryParam, options, type, queryKeyFnName }, operationName, queryProperties, queryKeyProperties, queryParams, params, props, mutator, queryOptionsMutator, queryKeyMutator, isRequestOptions, response, outputClient, httpClient, isExactOptionalPropertyTypes, hasSignal, route, hasVueQueryV4, hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError, doc, usePrefetch, useQuery, useInfinite, useInvalidate }) => {
+const generateQueryImplementation = ({ queryOption: { name, queryParam, options, type, queryKeyFnName }, operationName, queryProperties, queryKeyProperties, queryParams, params, props, mutator, queryOptionsMutator, queryKeyMutator, isRequestOptions, response, httpClient, isExactOptionalPropertyTypes, hasSignal, route, doc, usePrefetch, useQuery, useInfinite, useInvalidate, adapter }) => {
+	const { hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError } = adapter;
 	const hasSignalParam = props.some((prop) => prop.name === "signal");
 	const queryPropDefinitions = toObjectString(props, "definition");
 	const definedInitialDataQueryPropsDefinitions = toObjectString(props.map((prop) => {
@@ -1158,105 +1610,66 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		};
 	}), "definition");
 	const queryProps = toObjectString(props, "implementation");
-	const angularQueryPropsDefinitions = toObjectString(props.map((prop) => {
-		const getterType = prop.definition.replace(/^(\w+)(\??): (.+)$/, (_match, name$1, optional, type$1) => `${name$1}${optional}: ${type$1} | (() => ${type$1.replace(" | undefined", "")}${optional ? " | undefined" : ""})`);
-		return {
-			...prop,
-			definition: getterType
-		};
-	}), "definition");
 	const hasInfiniteQueryParam = queryParam && queryParams?.schema.name;
-	const isAngularHttp = isAngular(outputClient) || httpClient === OutputHttpClient.ANGULAR;
-	let httpFunctionProps = queryParam ? props.map((param) => {
-		if (param.type === GetterPropType.NAMED_PATH_PARAMS && !isVue(outputClient)) return param.destructured;
-		return param.name === "params" ? `{...${isVue(outputClient) ? `unref(params)` : "params"}, '${queryParam}': pageParam || ${isVue(outputClient) ? `unref(params)?.['${queryParam}']` : `params?.['${queryParam}']`}}` : param.name;
-	}).join(",") : getHttpFunctionQueryProps(isVue(outputClient), httpClient, queryProperties, isAngularHttp, !!mutator);
-	if (queryParam && isAngularHttp && !mutator) httpFunctionProps = httpFunctionProps ? `http, ${httpFunctionProps}` : "http";
-	const definedInitialDataReturnType = generateQueryReturnType({
-		outputClient,
+	const httpFunctionProps = queryParam ? adapter.getInfiniteQueryHttpProps(props, queryParam, !!mutator) : adapter.getHttpFunctionQueryProps(queryProperties, httpClient, !!mutator);
+	const definedInitialDataReturnType = adapter.getQueryReturnType({
 		type,
 		isMutatorHook: mutator?.isHook,
 		operationName,
-		hasVueQueryV4,
-		hasSvelteQueryV4,
 		hasQueryV5,
 		hasQueryV5WithDataTagError,
 		isInitialDataDefined: true
 	});
-	const returnType = generateQueryReturnType({
-		outputClient,
+	const returnType = adapter.getQueryReturnType({
 		type,
 		isMutatorHook: mutator?.isHook,
 		operationName,
-		hasVueQueryV4,
-		hasSvelteQueryV4,
 		hasQueryV5,
 		hasQueryV5WithDataTagError
 	});
 	const errorType = getQueryErrorType(operationName, response, httpClient, mutator);
 	const dataType = mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`;
-	const definedInitialDataQueryArguments = generateQueryArguments({
+	const definedInitialDataQueryArguments = adapter.generateQueryArguments({
 		operationName,
 		mutator,
 		definitions: "",
 		isRequestOptions,
 		type,
-		hasSvelteQueryV4,
-		hasSvelteQueryV6,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
 		queryParams,
 		queryParam,
 		initialData: "defined",
-		httpClient,
-		isAngularClient: isAngular(outputClient)
+		httpClient
 	});
-	const undefinedInitialDataQueryArguments = generateQueryArguments({
+	const undefinedInitialDataQueryArguments = adapter.generateQueryArguments({
 		operationName,
 		definitions: "",
 		mutator,
 		isRequestOptions,
 		type,
-		hasSvelteQueryV4,
-		hasSvelteQueryV6,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
 		queryParams,
 		queryParam,
 		initialData: "undefined",
-		httpClient,
-		isAngularClient: isAngular(outputClient)
+		httpClient
 	});
-	const queryArguments = generateQueryArguments({
+	const queryArguments = adapter.generateQueryArguments({
 		operationName,
 		definitions: "",
 		mutator,
 		isRequestOptions,
 		type,
-		hasSvelteQueryV4,
-		hasSvelteQueryV6,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
 		queryParams,
 		queryParam,
-		httpClient,
-		isAngularClient: isAngular(outputClient),
-		forAngularInject: isAngular(outputClient)
+		httpClient
 	});
-	const queryArgumentsForOptions = generateQueryArguments({
+	const queryArgumentsForOptions = adapter.generateQueryArguments({
 		operationName,
 		definitions: "",
 		mutator,
 		isRequestOptions,
 		type,
-		hasSvelteQueryV4,
-		hasSvelteQueryV6,
-		hasQueryV5,
-		hasQueryV5WithInfiniteQueryOptionsError,
 		queryParams,
 		queryParam,
 		httpClient,
-		isAngularClient: isAngular(outputClient),
 		forQueryOptions: true
 	});
 	const queryOptions = getQueryOptions({
@@ -1282,43 +1695,42 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		mutator,
 		definitions: "",
 		type,
-		hasSvelteQueryV4,
+		prefix: adapter.getQueryOptionsDefinitionPrefix(),
 		hasQueryV5,
 		hasQueryV5WithInfiniteQueryOptionsError,
 		queryParams,
 		queryParam,
-		isReturnType: true,
-		isAngularClient: isAngular(outputClient)
+		isReturnType: true
 	});
 	const queryOptionsImp = generateQueryOptions({
 		params,
 		options,
 		type,
-		outputClient
+		adapter
 	});
 	const queryOptionsFnName = camel(queryKeyMutator || queryOptionsMutator || mutator?.isHook ? `use-${name}-queryOptions` : `get-${name}-queryOptions`);
 	const queryOptionsVarName = isRequestOptions ? "queryOptions" : "options";
 	const queryResultVarName = props.some((prop) => prop.name === "query") ? "_query" : "query";
 	const infiniteParam = queryParams && queryParam ? `, ${queryParams.schema.name}['${queryParam}']` : "";
 	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}>(${isAngularHttp && (!mutator || mutator.hasSecondArg) ? "http: HttpClient, " : ""}${queryProps} ${queryArgumentsForOptions}) => {
+	const queryOptionsFn = `export const ${queryOptionsFnName} = <TData = ${TData}, TError = ${errorType}>(${adapter.getHttpFirstParam(mutator)}${queryProps} ${queryArgumentsForOptions}) => {
 
 ${hookOptions}
 
-  const queryKey =  ${queryKeyMutator ? `${queryKeyMutator.name}({ ${queryProperties} }${queryKeyMutator.hasSecondArg ? `, { url: \`${route}\`, queryOptions }` : ""});` : `${hasVueQueryV4 ? "" : "queryOptions?.queryKey ?? "}${queryKeyFnName}(${queryKeyProperties});`}
+  const queryKey =  ${queryKeyMutator ? `${queryKeyMutator.name}({ ${queryProperties} }${queryKeyMutator.hasSecondArg ? `, { url: \`${route}\`, queryOptions }` : ""});` : `${adapter.getQueryKeyPrefix()}${queryKeyFnName}(${queryKeyProperties});`}
 
   ${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, ${queryParams.schema.name}['${queryParam}']` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
 
-      ${isVue(outputClient) ? vueUnRefParams(props.filter((prop) => prop.type === GetterPropType.NAMED_PATH_PARAMS)) : ""}
+      ${adapter.getUnrefStatements(props)}
 
       ${queryOptionsMutator ? `const customOptions = ${queryOptionsMutator.name}({...queryOptions, queryKey, queryFn}${queryOptionsMutator.hasSecondArg ? `, { ${queryProperties} }` : ""}${queryOptionsMutator.hasThirdArg ? `, { url: \`${route}\` }` : ""});` : ""}
 
-   return  ${queryOptionsMutator ? "customOptions" : `{ queryKey, queryFn, ${queryOptionsImp}}`} as ${queryOptionFnReturnType} ${isVue(outputClient) || isAngular(outputClient) ? "" : `& { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`}
+   return  ${queryOptionsMutator ? "customOptions" : `{ queryKey, queryFn, ${queryOptionsImp}}`} as ${queryOptionFnReturnType} ${adapter.shouldAnnotateQueryKey() ? `& { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }` : ""}
 }`;
-	const operationPrefix = getFrameworkPrefix(hasSvelteQueryV4, isAngular(outputClient), isSolid(outputClient));
-	const optionalQueryClientArgument = hasSvelteQueryV6 ? `, queryClient?: () => QueryClient` : hasQueryV5 && !isAngular(outputClient) ? ", queryClient?: QueryClient" : "";
+	const operationPrefix = adapter.hookPrefix;
+	const optionalQueryClientArgument = adapter.getOptionalQueryClientArgument();
 	const queryHookName = camel(`${operationPrefix}-${name}`);
 	const overrideTypes = `
 export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${definedInitialDataQueryPropsDefinitions} ${definedInitialDataQueryArguments} ${optionalQueryClientArgument}\n  ): ${definedInitialDataReturnType}
@@ -1343,36 +1755,39 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${q
 	});
 	const shouldGenerateInvalidate = useInvalidate && (type === QueryType.QUERY || type === QueryType.INFINITE || type === QueryType.SUSPENSE_QUERY && !useQuery || type === QueryType.SUSPENSE_INFINITE && !useInfinite);
 	const invalidateFnName = camel(`invalidate-${name}`);
+	const queryInit = adapter.generateQueryInit({
+		queryOptionsFnName,
+		queryProperties,
+		isRequestOptions,
+		mutator
+	});
+	const queryInvocationArgs = adapter.generateQueryInvocationArgs({
+		props,
+		queryOptionsFnName,
+		queryProperties,
+		isRequestOptions,
+		mutator,
+		operationPrefix,
+		type,
+		queryOptionsVarName,
+		optionalQueryClientArgument
+	});
+	const queryInvocationSuffix = adapter.getQueryInvocationSuffix();
 	return `
 ${queryOptionsFn}
 
 export type ${pascal(name)}QueryResult = NonNullable<Awaited<ReturnType<${dataType}>>>
 export type ${pascal(name)}QueryError = ${errorType}
 
-${hasQueryV5 && OutputClient.REACT_QUERY === outputClient ? overrideTypes : ""}
+${adapter.shouldGenerateOverrideTypes() ? overrideTypes : ""}
 ${doc}
-export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${hasSvelteQueryV6 ? toObjectString(props.map((p) => ({
-		...p,
-		definition: p.definition.replace(":", ": () => ")
-	})), "definition") : isAngular(outputClient) ? angularQueryPropsDefinitions : queryProps} ${queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
+export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${adapter.getHookPropsDefinitions(props)} ${queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
 
-  ${hasSvelteQueryV6 ? "" : isAngular(outputClient) && (!mutator || mutator.hasSecondArg) ? `const http = inject(HttpClient);` : isAngular(outputClient) ? "" : `const ${queryOptionsVarName} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})`}
+  ${queryInit}
 
-  const ${queryResultVarName} = ${camel(`${operationPrefix}-${isAngular(outputClient) || hasSvelteQueryV4 ? getQueryTypeForFramework(type) : type}`)}(${isAngular(outputClient) ? `() => {${props.length > 0 ? `
-    // Resolve params if getter function (for signal reactivity)
-    ${props.map((p) => `const _${p.name} = typeof ${p.name} === 'function' ? ${p.name}() : ${p.name};`).join("\n    ")}` : ""}
-    // Resolve options if getter function (for signal reactivity)
-    const _options = typeof ${isRequestOptions ? "options" : "queryOptions"} === 'function' ? ${isRequestOptions ? "options" : "queryOptions"}() : ${isRequestOptions ? "options" : "queryOptions"};
-    return ${queryOptionsFnName}(${!mutator || mutator.hasSecondArg ? "http" : ""}${props.length > 0 ? `${!mutator || mutator.hasSecondArg ? ", " : ""}${props.map((p) => `_${p.name}`).join(", ")}` : ""}, _options);
-  }` : hasSvelteQueryV6 ? `() => ${queryOptionsFnName}(${toObjectString(props.map((p) => ({
-		...p,
-		name: p.default || !p.required ? `${p.name}?.()` : `${p.name}()`
-	})), "name")}${isRequestOptions ? "options?.()" : "queryOptions?.()"})` : `${queryOptionsVarName}${!isAngular(outputClient) && optionalQueryClientArgument ? ", queryClient" : ""}`}${hasSvelteQueryV6 ? `, queryClient` : ""}) as ${returnType};
+  const ${queryResultVarName} = ${camel(`${operationPrefix}-${adapter.getQueryType(type)}`)}(${queryInvocationArgs}${queryInvocationSuffix}) as ${returnType};
 
-  ${getQueryReturnStatement({
-		outputClient,
-		hasSvelteQueryV4,
-		hasSvelteQueryV6,
+  ${adapter.getQueryReturnStatement({
 		hasQueryV5,
 		hasQueryV5WithDataTagError,
 		queryResultVarName,
@@ -1388,24 +1803,17 @@ ${shouldGenerateInvalidate ? `${doc}export const ${invalidateFnName} = async (\n
 }\n` : ""}
 `;
 };
-const generateQueryHook = async (verbOptions, options, outputClient) => {
+const generateQueryHook = async (verbOptions, options, outputClient, adapter) => {
+	if (!adapter) throw new Error("FrameworkAdapter is required for generateQueryHook");
 	const { queryParams, operationName, body, props: _props, verb, params, override, mutator, response, operationId, summary, deprecated } = verbOptions;
 	const { route, override: { operations }, context, output } = options;
-	let props = _props;
-	if (isVue(outputClient)) props = vueWrapTypeWithMaybeRef(_props);
+	const props = adapter.transformProps(_props);
 	const query = override.query;
 	const isRequestOptions = override.requestOptions !== false;
 	const operationQueryOptions = operations[operationId]?.query;
 	const isExactOptionalPropertyTypes = !!context.output.tsconfig?.compilerOptions?.exactOptionalPropertyTypes;
-	const queryVersion = query.version;
-	const hasVueQueryV4 = OutputClient.VUE_QUERY === outputClient && (!isVueQueryV3(context.output.packageJson) || queryVersion === 4);
-	const hasSvelteQueryV4 = OutputClient.SVELTE_QUERY === outputClient && (!isSvelteQueryV3(context.output.packageJson) || queryVersion === 4);
-	const hasSvelteQueryV6 = OutputClient.SVELTE_QUERY === outputClient && isSvelteQueryV6(context.output.packageJson);
-	const hasQueryV5 = queryVersion === 5 || isQueryV5(context.output.packageJson, outputClient);
-	const hasQueryV5WithDataTagError = queryVersion === 5 || isQueryV5WithDataTagError(context.output.packageJson, outputClient);
-	const hasQueryV5WithInfiniteQueryOptionsError = queryVersion === 5 || isQueryV5WithInfiniteQueryOptionsError(context.output.packageJson, outputClient);
+	const { hasQueryV5 } = adapter;
 	const httpClient = context.output.httpClient;
-	const isAngularHttp = isAngular(outputClient) || httpClient === OutputHttpClient.ANGULAR;
 	const doc = jsDoc({
 		summary,
 		deprecated
@@ -1444,12 +1852,10 @@ const generateQueryHook = async (verbOptions, options, outputClient) => {
 			tsconfig: context.output.tsconfig
 		}) : void 0;
 		const queryProperties = props.map((param) => {
-			if (param.type === GetterPropType.NAMED_PATH_PARAMS && !isVue(outputClient)) return param.destructured;
-			return param.type === GetterPropType.BODY ? body.implementation : param.name;
+			return adapter.getQueryPropertyForProp(param, body);
 		}).join(",");
 		const queryKeyProperties = props.filter((prop) => prop.type !== GetterPropType.HEADER).map((param) => {
-			if (param.type === GetterPropType.NAMED_PATH_PARAMS && !isVue(outputClient)) return param.destructured;
-			return param.type === GetterPropType.BODY ? body.implementation : param.name;
+			return adapter.getQueryPropertyForProp(param, body);
 		}).join(",");
 		const queries = [
 			...query.useInfinite || operationQueryOptions?.useInfinite ? [{
@@ -1490,7 +1896,7 @@ ${queryKeyMutator ? "" : uniqueQueryOptionsByKeys.reduce((acc, queryOption) => {
 				...prop,
 				implementation: prop.type === GetterPropType.PARAM || prop.type === GetterPropType.NAMED_PATH_PARAMS ? prop.implementation : makeOptionalParam(prop.implementation)
 			})), "implementation");
-			const routeString = isVue(outputClient) || override.query.shouldSplitQueryKey ? getRouteAsArray(route) : `\`${route}\``;
+			const routeString = adapter.getQueryKeyRouteString(route, !!override.query.shouldSplitQueryKey);
 			const queryKeyIdentifier = override.query.useOperationIdAsQueryKey ? `"${operationName}"` : routeString;
 			const queryKeyParams = props.filter((p) => override.query.useOperationIdAsQueryKey ? true : p.type === GetterPropType.QUERY_PARAM).toSorted((a) => a.required ? -1 : 1).map((p) => `...(${p.name} ? [${p.name}] : [])`).join(", ");
 			return acc + `
@@ -1519,24 +1925,18 @@ ${override.query.shouldExportQueryKey ? "export " : ""}const ${queryOption.query
 				isRequestOptions,
 				queryParams,
 				response,
-				outputClient,
 				httpClient,
 				isExactOptionalPropertyTypes,
 				hasSignal: getHasSignal({ overrideQuerySignal: override.query.signal }),
 				queryOptionsMutator,
 				queryKeyMutator,
 				route,
-				hasVueQueryV4,
-				hasSvelteQueryV4,
-				hasSvelteQueryV6,
-				hasQueryV5,
-				hasQueryV5WithDataTagError,
-				hasQueryV5WithInfiniteQueryOptionsError,
 				doc,
 				usePrefetch: query.usePrefetch,
 				useQuery: query.useQuery,
 				useInfinite: query.useInfinite,
-				useInvalidate: query.useInvalidate
+				useInvalidate: query.useInvalidate,
+				adapter
 			});
 		}, "")}
 `;
@@ -1549,15 +1949,10 @@ ${override.query.shouldExportQueryKey ? "export " : ""}const ${queryOption.query
 				props
 			},
 			options,
-			outputClient,
-			hasQueryV5,
-			hasQueryV5WithInfiniteQueryOptionsError,
-			hasSvelteQueryV4,
-			hasSvelteQueryV6,
 			isRequestOptions,
 			httpClient,
 			doc,
-			isAngularHttp
+			adapter
 		});
 		implementation += mutationResult.implementation;
 		mutators = mutationResult.mutators ? [...mutators ?? [], ...mutationResult.mutators] : mutators;
@@ -1578,9 +1973,14 @@ ${getQueryHeader(params)}
 `;
 };
 const generateQuery = async (verbOptions, options, outputClient) => {
+	const adapter = createFrameworkAdapter({
+		outputClient,
+		packageJson: options.context.output.packageJson,
+		queryVersion: verbOptions.override.query.version
+	});
 	const imports = generateVerbImports(verbOptions);
-	const functionImplementation = generateQueryRequestFunction(verbOptions, options, isVue(outputClient));
-	const { implementation: hookImplementation, mutators } = await generateQueryHook(verbOptions, options, outputClient);
+	const functionImplementation = adapter.generateRequestFunction(verbOptions, options);
+	const { implementation: hookImplementation, mutators } = await generateQueryHook(verbOptions, options, outputClient, adapter);
 	return {
 		implementation: `${functionImplementation}\n\n${hookImplementation}`,
 		imports,