@povio/openapi-codegen-cli 3.0.0-rc.9 → 3.1.0-rc.1

package/dist/{generateCodeFromOpenAPIDoc-NA2XZmIv.mjs → generateCodeFromOpenAPIDoc-C-n0Knj8.mjs}

@@ -386,12 +386,23 @@ function replaceHyphenatedPath(path) {
 	});
 	return path;
 }
-const isSortingParameterObject = (param) => {
-	const enumNames = param["x-enumNames"];
-	const hasEnumNames = Array.isArray(enumNames) && enumNames.length > 0;
-	const isStringSchema = !!param.schema && isSchemaObject(param.schema) && param.schema.type === "string";
-	return hasEnumNames && isStringSchema;
+const isSortingParameterObject = (param, schema = param.schema, resolver) => {
+	const enumNames = getParameterEnumNames(param, schema);
+	return Array.isArray(enumNames) && enumNames.length > 0 && isStringLikeParameterSchema(schema, resolver);
 };
+function getParameterEnumNames(param, schema = param.schema) {
+	return param["x-enumNames"] ?? (schema && isSchemaObject(schema) ? schema["x-enumNames"] : void 0);
+}
+function isStringLikeParameterSchema(schema, resolver) {
+	if (!schema) return false;
+	if (isReferenceObject(schema)) return resolver ? isStringLikeParameterSchema(resolver.resolveObject(schema), resolver) : true;
+	if (schema.type === "string" || Array.isArray(schema.type) && schema.type.includes("string")) return true;
+	return [
+		...schema.allOf ?? [],
+		...schema.oneOf ?? [],
+		...schema.anyOf ?? []
+	].some((compositeSchema) => isStringLikeParameterSchema(compositeSchema, resolver));
+}
 const isPathExcluded = (path, options) => {
 	if (!options.excludePathRegex) return false;
 	return new RegExp(options.excludePathRegex).test(path);
@@ -1397,96 +1408,6 @@ const DEFAULT_GENERATE_OPTIONS = {
 //#region src/generators/utils/array.utils.ts
 const getUniqueArray = (...arrs) => [...new Set(arrs.flat())];
 
-//#endregion
-//#region src/generators/utils/generate/generate.acl.utils.ts
-const getAbilityFunctionName = (endpoint) => `canUse${capitalize(snakeToCamel(endpoint.operationName))}`;
-const getImportedAbilityFunctionName = (endpoint, options) => {
-	return `${options.tsNamespaces ? `${getNamespaceName({
-		type: GenerateType.Acl,
-		tag: getEndpointTag(endpoint, options),
-		options
-	})}.` : ""}${getAbilityFunctionName(endpoint)}`;
-};
-const getAbilityAction = (endpoint) => endpoint.acl?.[0].action;
-const getAbilitySubject = (endpoint) => endpoint.acl?.[0].subject;
-const hasAbilityConditions = (endpoint) => !!getAbilityConditionsTypes(endpoint)?.length;
-const getAbilityConditionsTypes = (endpoint) => endpoint.acl?.[0].conditionsTypes?.sort((a, b) => a.name.localeCompare(b.name));
-const getAbilityDescription = (endpoint) => endpoint.acl?.[0]?.description;
-const getAbilitySubjectTypes = (endpoint) => {
-	const abilitySubject = getAbilitySubject(endpoint);
-	const types = [`"${abilitySubject ?? ""}"`];
-	if (hasAbilityConditions(endpoint)) types.push(`ForcedSubject<"${abilitySubject}"> & { ${getAbilityConditionsTypes(endpoint)?.map((conditionType) => `${conditionType.name}${conditionType.required ? "" : "?"}: ${conditionType.type ?? ""}${conditionType.zodSchemaName ?? ""},`).join(" ")} }`);
-	return types;
-};
-function getAclData({ resolver, data, tag }) {
-	const endpoints = data.get(tag)?.endpoints.filter(({ acl }) => acl && acl.length > 0);
-	if (!endpoints || endpoints.length === 0) return;
-	return {
-		endpoints,
-		hasAdditionalAbilityImports: endpoints.some(({ acl }) => acl?.[0].conditions && Object.keys(acl[0].conditions).length > 0),
-		modelsImports: getModelsImports({
-			resolver,
-			tag,
-			zodSchemasAsTypes: getUniqueArray(endpoints.reduce((acc, endpoint) => {
-				const zodSchemas = endpoint.acl?.[0].conditionsTypes?.reduce((acc, propertyType) => [...acc, ...propertyType?.zodSchemaName ? [propertyType.zodSchemaName] : []], []);
-				return [...acc, ...zodSchemas ?? []];
-			}, []))
-		})
-	};
-}
-const getAppAbilitiesType = ({ resolver, data }) => {
-	const appAbilitiesTypeMap = /* @__PURE__ */ new Map();
-	const modelsImportsArr = [];
-	let hasAdditionalAbilityImports = false;
-	data.forEach((_, tag) => {
-		const aclData = getAclData({
-			resolver,
-			data,
-			tag
-		});
-		if (!aclData) return;
-		const { modelsImports: tagModelsImports, hasAdditionalAbilityImports: tagHasAdditionalAbilityImports, endpoints } = aclData;
-		modelsImportsArr.push(tagModelsImports);
-		hasAdditionalAbilityImports = hasAdditionalAbilityImports || tagHasAdditionalAbilityImports;
-		endpoints.forEach((endpoint) => {
-			const abilityAction = getAbilityAction(endpoint);
-			if (abilityAction) appAbilitiesTypeMap.set(abilityAction, new Set([...appAbilitiesTypeMap.get(abilityAction) ?? [], ...getAbilitySubjectTypes(endpoint)]));
-		});
-	});
-	const modelsImports = mergeImports(resolver.options, ...modelsImportsArr);
-	return {
-		appAbilitiesType: appAbilitiesTypeMap.size > 0 ? Object.fromEntries(Array.from(appAbilitiesTypeMap.entries()).map(([key, valueSet]) => [key, Array.from(valueSet)])) : void 0,
-		modelsImports,
-		hasAdditionalAbilityImports
-	};
-};
-
-//#endregion
-//#region src/generators/utils/generate/generate.query.utils.ts
-const getQueryName = (endpoint, mutation) => {
-	const addMutationSuffix = isQuery(endpoint) && isMutation(endpoint) && mutation;
-	return `use${capitalize(snakeToCamel(endpoint.operationName))}${addMutationSuffix ? "Mutation" : ""}`;
-};
-const getInfiniteQueryName = (endpoint) => `use${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
-const getQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}QueryOptions`;
-const getInfiniteQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}InfiniteQueryOptions`;
-const getPrefetchQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}`;
-const getPrefetchInfiniteQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
-const getImportedQueryName = (endpoint, options) => {
-	return `${options.tsNamespaces ? `${getNamespaceName({
-		type: GenerateType.Queries,
-		tag: getEndpointTag(endpoint, options),
-		options
-	})}.` : ""}${getQueryName(endpoint)}`;
-};
-const getImportedInfiniteQueryName = (endpoint, options) => {
-	return `${options.tsNamespaces ? `${getNamespaceName({
-		type: GenerateType.Queries,
-		tag: getEndpointTag(endpoint, options),
-		options
-	})}.` : ""}${getInfiniteQueryName(endpoint)}`;
-};
-
 //#endregion
 //#region src/generators/core/openapi/iterateSchema.ts
 function iterateSchema(schema, options) {
@@ -1573,16 +1494,20 @@ function getSchemaDescriptions(schemaObj) {
 const getZodSchemaInferedTypeName = (zodSchemaName, options) => removeSuffix(zodSchemaName, options.schemaSuffix);
 const getImportedZodSchemaName = (resolver, zodSchemaName, namespaceTag) => {
 	if (!isNamedZodSchema(zodSchemaName)) return zodSchemaName;
-	const tag = namespaceTag ?? resolver.getTagByZodSchemaName(zodSchemaName);
+	const tag = getOwningOrLocalProxyTag(resolver, zodSchemaName, namespaceTag);
 	return `${resolver.options.tsNamespaces ? `${getNamespaceName({
 		type: GenerateType.Models,
 		tag,
 		options: resolver.options
 	})}.` : ""}${zodSchemaName}`;
 };
+function getOwningOrLocalProxyTag(resolver, zodSchemaName, namespaceTag) {
+	if (namespaceTag && resolver.options.modelsInCommon && resolver.options.splitByTags) return namespaceTag;
+	return resolver.getTagByZodSchemaName(zodSchemaName) ?? namespaceTag;
+}
 const getImportedZodSchemaInferedTypeName = (resolver, zodSchemaName, currentTag, namespaceTag) => {
 	if (!isNamedZodSchema(zodSchemaName)) return zodSchemaName === VOID_SCHEMA ? "void" : zodSchemaName;
-	const tag = namespaceTag ?? resolver.getTagByZodSchemaName(zodSchemaName);
+	const tag = getOwningOrLocalProxyTag(resolver, zodSchemaName, namespaceTag);
 	return `${resolver.options.tsNamespaces && (Boolean(namespaceTag) || tag !== currentTag) ? `${getNamespaceName({
 		type: GenerateType.Models,
 		tag,
@@ -1655,6 +1580,113 @@ function getZodSchemaPropertyDescriptions(resolver, data, tag) {
 	return properties;
 }
 
+//#endregion
+//#region src/generators/utils/generate/generate.acl.utils.ts
+const getAbilityFunctionName = (endpoint) => `canUse${capitalize(snakeToCamel(endpoint.operationName))}`;
+const getImportedAbilityFunctionName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Acl,
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getAbilityFunctionName(endpoint)}`;
+};
+const getAbilityAction = (endpoint) => endpoint.acl?.[0].action;
+const getAbilitySubject = (endpoint) => endpoint.acl?.[0].subject;
+const hasAbilityConditions = (endpoint) => !!getAbilityConditionsTypes(endpoint)?.length;
+const getAbilityConditionsTypes = (endpoint) => endpoint.acl?.[0].conditionsTypes?.sort((a, b) => a.name.localeCompare(b.name));
+const getAbilityDescription = (endpoint) => endpoint.acl?.[0]?.description;
+const getAbilitySubjectTypes = (endpoint, resolver, tag) => {
+	const abilitySubject = getAbilitySubject(endpoint);
+	const types = [`"${abilitySubject ?? ""}"`];
+	if (hasAbilityConditions(endpoint)) types.push(`ForcedSubject<"${abilitySubject}"> & { ${getAbilityConditionsTypes(endpoint)?.map((conditionType) => `${conditionType.name}${conditionType.required ? "" : "?"}: ${getAbilityConditionType(conditionType, resolver, tag)},`).join(" ")} }`);
+	return types;
+};
+function getAbilityConditionType(conditionType, resolver, tag) {
+	if (!conditionType.zodSchemaName) return conditionType.type ?? "";
+	if (!resolver) return `${conditionType.type ?? ""}${conditionType.zodSchemaName}`;
+	return getImportedZodSchemaInferedTypeName(resolver, conditionType.zodSchemaName, tag, tag);
+}
+function getAclData({ resolver, data, tag }) {
+	const endpoints = data.get(tag)?.endpoints.filter(({ acl }) => acl && acl.length > 0);
+	if (!endpoints || endpoints.length === 0) return;
+	return {
+		endpoints,
+		hasAdditionalAbilityImports: endpoints.some(({ acl }) => acl?.[0].conditions && Object.keys(acl[0].conditions).length > 0),
+		modelsImports: getModelsImports({
+			resolver,
+			tag,
+			zodSchemasAsTypes: getUniqueArray(endpoints.reduce((acc, endpoint) => {
+				const zodSchemas = endpoint.acl?.[0].conditionsTypes?.reduce((acc, propertyType) => [...acc, ...propertyType?.zodSchemaName ? [propertyType.zodSchemaName] : []], []);
+				return [...acc, ...zodSchemas ?? []];
+			}, []))
+		})
+	};
+}
+const getAppAbilitiesType = ({ resolver, data }) => {
+	const appAbilitiesTypeMap = /* @__PURE__ */ new Map();
+	const modelsImportsArr = [];
+	let hasAdditionalAbilityImports = false;
+	data.forEach((_, tag) => {
+		const aclData = getAclData({
+			resolver,
+			data,
+			tag
+		});
+		if (!aclData) return;
+		const { modelsImports: tagModelsImports, hasAdditionalAbilityImports: tagHasAdditionalAbilityImports, endpoints } = aclData;
+		modelsImportsArr.push(tagModelsImports);
+		hasAdditionalAbilityImports = hasAdditionalAbilityImports || tagHasAdditionalAbilityImports;
+		endpoints.forEach((endpoint) => {
+			const abilityAction = getAbilityAction(endpoint);
+			if (abilityAction) appAbilitiesTypeMap.set(abilityAction, new Set([...appAbilitiesTypeMap.get(abilityAction) ?? [], ...getAbilitySubjectTypes(endpoint, resolver, tag)]));
+		});
+	});
+	const modelsImports = mergeImports(resolver.options, ...modelsImportsArr);
+	return {
+		appAbilitiesType: appAbilitiesTypeMap.size > 0 ? Object.fromEntries(Array.from(appAbilitiesTypeMap.entries()).map(([key, valueSet]) => [key, Array.from(valueSet)])) : void 0,
+		modelsImports,
+		hasAdditionalAbilityImports
+	};
+};
+/** Renders a `checkAcl(...)` call, passing the ability's conditions object only when the
+* ability function actually expects one (i.e. the endpoint declares matching conditions). */
+function renderAclCheckCall(resolver, endpoint, replacements, indent = "") {
+	const checkParams = getAbilityConditionsTypes(endpoint)?.map((condition) => invalidVariableNameCharactersToCamel(condition.name));
+	const paramNames = new Set(endpoint.parameters.map((param) => invalidVariableNameCharactersToCamel(param.name)));
+	const hasAllCheckParams = checkParams?.every((param) => paramNames.has(param));
+	const args = hasAbilityConditions(endpoint) && hasAllCheckParams ? `{ ${(checkParams ?? []).map((param) => {
+		const resolvedParam = replacements?.[param] ?? param;
+		return resolvedParam === param ? param : `${param}: ${resolvedParam}`;
+	}).join(", ")} } ` : "";
+	return `${indent}checkAcl(${getImportedAbilityFunctionName(endpoint, resolver.options)}(${args}));`;
+}
+
+//#endregion
+//#region src/generators/utils/generate/generate.query.utils.ts
+const getQueryName = (endpoint, mutation) => {
+	const addMutationSuffix = isQuery(endpoint) && isMutation(endpoint) && mutation;
+	return `use${capitalize(snakeToCamel(endpoint.operationName))}${addMutationSuffix ? "Mutation" : ""}`;
+};
+const getInfiniteQueryName = (endpoint) => `use${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
+const getQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}QueryOptions`;
+const getInfiniteQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}InfiniteQueryOptions`;
+const getPrefetchQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}`;
+const getPrefetchInfiniteQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
+const getImportedQueryName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Queries,
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getQueryName(endpoint)}`;
+};
+const getImportedInfiniteQueryName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Queries,
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getInfiniteQueryName(endpoint)}`;
+};
+
 //#endregion
 //#region src/generators/utils/generate/generate.imports.utils.ts
 function getModelsImports({ resolver, tag, zodSchemas = [], zodSchemasAsTypes = [] }) {
@@ -1972,7 +2004,8 @@ const getEndpointBody$1 = (endpoint) => endpoint.parameters.find((param) => para
 const hasEndpointConfig = (endpoint, resolver) => {
 	const endpointConfig = getEndpointConfig(endpoint);
 	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
-	return Object.keys(endpointConfig).length > 0 || hasAxiosRequestConfig;
+	const needsBlobConfig = endpoint.mediaDownload || endpoint.response === "z.instanceof(Blob)";
+	return Object.keys(endpointConfig).length > 0 || hasAxiosRequestConfig || needsBlobConfig;
 };
 const getEndpointPath = (endpoint) => endpoint.path.replace(/:([a-zA-Z0-9_]+)/g, "${$1}");
 function mapEndpointParamsToFunctionParams(resolver, endpoint, options) {
@@ -2039,6 +2072,40 @@ function getEndpointConfig(endpoint) {
 		...Object.keys(headers).length ? { headers } : {}
 	};
 }
+/** Renders the body of a media-upload mutationFn: call the endpoint (without the file arg) to
+* get upload instructions, then upload the file itself to the returned URL. Shared between
+* renderMutation (*.queries.ts) and renderMutationContent (*.configs.ts / builderConfigs) so
+* both mutation paths stay in sync. Lines are relative to the caller's own indent. */
+function renderMediaUploadMutationBody({ resolver, endpointFunction, resolvedEndpointArgs }) {
+	return [
+		`const uploadInstructions = await ${endpointFunction}(${resolvedEndpointArgs}${resolver.options.axiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""});`,
+		"",
+		"if (file && uploadInstructions.url) {",
+		`  const method = (${BODY_PARAMETER_NAME}?.method?.toLowerCase() ?? "put") as "put" | "post";`,
+		"  let dataToSend: File | FormData = file;",
+		"  if (method === \"post\") {",
+		"    dataToSend = new FormData();",
+		"    if (uploadInstructions.fields) {",
+		"      for (const [key, value] of uploadInstructions.fields) {",
+		"        dataToSend.append(key, value);",
+		"      }",
+		"    }",
+		"    dataToSend.append(\"file\", file);",
+		"  }",
+		"  await axios[method](uploadInstructions.url, dataToSend, {",
+		"    headers: {",
+		"      \"Content-Type\": file.type,",
+		"    },",
+		"    signal: abortController?.signal,",
+		"    onUploadProgress: onUploadProgress",
+		"    ? (progressEvent) => onUploadProgress({ loaded: progressEvent.loaded, total: progressEvent.total ?? 0 })",
+		"    : undefined,",
+		"  });",
+		"}",
+		"",
+		"return uploadInstructions;"
+	];
+}
 
 //#endregion
 //#region src/generators/utils/query.utils.ts
@@ -2096,7 +2163,9 @@ function getEndpointAclConditionPropertyType({ resolver, endpoint, acl, name })
 		const matchingMediaType = Object.keys(bodyParameter?.bodyObject?.content ?? {}).find(isParamMediaTypeAllowed);
 		if (matchingMediaType) {
 			schema = bodyParameter?.bodyObject?.content?.[matchingMediaType]?.schema;
+			required = bodyParameter?.bodyObject?.required;
 			info = `${isQuery(endpoint) ? "query" : "mutation"} data`;
+			if (pathSplits[index]?.startsWith("$")) index++;
 		}
 	}
 	while (schema && index < pathSplits.length) {
@@ -2171,13 +2240,16 @@ function resolveEndpointZodSchema({ resolver, schema, meta, tag, fallbackName, c
 		fallbackName,
 		resolver,
 		tag
-	}) : `${resolveZodSchemaName({
-		schema: schemaObject,
-		zodSchema,
-		fallbackName,
-		resolver,
-		tag
-	})}${zodChain}`;
+	}) : (() => {
+		const name = resolveZodSchemaName({
+			schema: schemaObject,
+			zodSchema,
+			fallbackName,
+			resolver,
+			tag
+		});
+		return isNamedZodSchema(name) ? name : name + zodChain;
+	})();
 	entries.set(metaKey, resolved);
 	return resolved;
 }
@@ -2228,9 +2300,9 @@ function getEndpointParameter({ resolver, param, operationName, isUniqueOperatio
 	if (resolver.options.withDescription && schema) schema.description = (paramObj.description ?? "").trim();
 	const fallbackName = getParamZodSchemaName(getZodSchemaOperationName(operationName, isUniqueOperationName, tag), paramObj.name);
 	let parameterSortingEnumSchemaName = void 0;
-	if (isSortingParameterObject(paramObj)) {
+	if (isSortingParameterObject(paramObj, schema, resolver)) {
 		const enumZodSchemaName = getEnumZodSchemaName(fallbackName, resolver.options.enumSuffix, resolver.options.schemaSuffix);
-		const code = getEnumZodSchemaCodeFromEnumNames(paramObj["x-enumNames"]);
+		const code = getEnumZodSchemaCodeFromEnumNames(getParameterEnumNames(paramObj, schema) ?? []);
 		resolver.setZodSchema(enumZodSchemaName, code, tag);
 		parameterSortingEnumSchemaName = enumZodSchemaName;
 	}
@@ -2344,7 +2416,7 @@ function getEndpointsFromOpenAPIDoc(resolver) {
 				}) ?? mediaTypes.find(isMediaTypeAllowed);
 				let schema;
 				if (matchingMediaType) {
-					endpoint.responseFormat = matchingMediaType;
+					if (isMainResponseStatus(Number(statusCode)) || statusCode === "default" && !endpoint.responseFormat) endpoint.responseFormat = matchingMediaType;
 					schema = responseObj.content?.[matchingMediaType]?.schema;
 				} else if (statusCode === "200") resolver.validationErrors.push(getInvalidStatusCodeError({
 					received: "200",
@@ -2388,7 +2460,7 @@ function getEndpointsFromOpenAPIDoc(resolver) {
 						const domainStr = rawSchema["x-domain-error-domain"];
 						const domainName = rawSchema["x-domain-error-name"];
 						const codeEnumArr = ((rawSchema?.properties)?.code)?.enum;
-						const domainCode = Array.isArray(codeEnumArr) && codeEnumArr.length === 1 && typeof codeEnumArr[0] === "number" ? codeEnumArr[0] : void 0;
+						const domainCode = Array.isArray(codeEnumArr) && codeEnumArr.length === 1 && (typeof codeEnumArr[0] === "number" || typeof codeEnumArr[0] === "string") ? codeEnumArr[0] : void 0;
 						endpoint.errors.push({
 							zodSchema: responseZodSchema,
 							status,
@@ -3278,9 +3350,9 @@ function renderWorkspaceAclHook({ resolver, endpoint }) {
 	const objectRequired = abilityConditionsTypes.some((propertyType) => propertyType.required && !workspaceConditionNameSet.has(propertyType.name));
 	const objectParams = abilityConditionsTypes.map((propertyType) => {
 		const isWorkspaceCondition = workspaceConditionNameSet.has(propertyType.name);
-		return `${propertyType.name}${propertyType.required && !isWorkspaceCondition ? "" : "?"}: ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")}, `;
+		return `${propertyType.name}${propertyType.required && !isWorkspaceCondition ? "" : "?"}: ${renderConditionType(resolver, endpoint, propertyType)}, `;
 	}).join("");
-	const contextType = abilityConditionsTypes.filter((propertyType) => workspaceConditionNameSet.has(propertyType.name)).map((propertyType) => `${propertyType.name}?: ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")}`).join("; ");
+	const contextType = abilityConditionsTypes.filter((propertyType) => workspaceConditionNameSet.has(propertyType.name)).map((propertyType) => `${propertyType.name}?: ${renderConditionType(resolver, endpoint, propertyType)}`).join("; ");
 	const contextBindings = workspaceConditionNames.map((name) => `${name}: ${name}Workspace`).join(", ");
 	const lines = [];
 	lines.push(`export const use${capitalize(getAbilityFunctionName(endpoint))} = (`);
@@ -3306,15 +3378,15 @@ function renderAbilityFunction({ resolver, endpoint }) {
 	lines.push("/**");
 	lines.push(` * Use for ${abilityQuery} ability. ${hasConditions ? "For global ability, omit the object parameter." : ""}${getAbilityDescription(endpoint) ? "" : ""}`);
 	if (getAbilityDescription(endpoint)) lines.push(` * @description ${getAbilityDescription(endpoint)}`);
-	if (hasConditions) for (const propertyType of abilityConditionsTypes) lines.push(` * @param { ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")} } object.${propertyType.name} ${propertyType.name} from ${propertyType.info}`);
+	if (hasConditions) for (const propertyType of abilityConditionsTypes) lines.push(` * @param { ${renderConditionType(resolver, endpoint, propertyType)} } object.${propertyType.name} ${propertyType.name} from ${propertyType.info}`);
 	lines.push(` * @returns { AbilityTuple } An ability tuple indicating the user's ability to use ${abilityQuery}`);
 	lines.push(" */");
 	lines.push(`export const ${getAbilityFunctionName(endpoint)} = (`);
-	if (hasConditions) lines.push(`  object?: { ${abilityConditionsTypes.map((propertyType) => `${propertyType.name}${propertyType.required ? "" : "?"}: ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")}, `).join("")} } `);
+	if (hasConditions) lines.push(`  object?: { ${abilityConditionsTypes.map((propertyType) => `${propertyType.name}${propertyType.required ? "" : "?"}: ${renderConditionType(resolver, endpoint, propertyType)}, `).join("")} } `);
 	lines.push(") => [");
 	lines.push(`  "${getAbilityAction(endpoint)}",`);
 	lines.push(`  ${hasConditions ? `object ? subject("${getAbilitySubject(endpoint)}", object) : "${getAbilitySubject(endpoint)}"` : `"${getAbilitySubject(endpoint)}"`}`);
-	lines.push(`] as ${CASL_ABILITY_BINDING.abilityTuple}<"${getAbilityAction(endpoint)}", ${getAbilitySubjectTypes(endpoint).join(" | ")}>;`);
+	lines.push(`] as ${CASL_ABILITY_BINDING.abilityTuple}<"${getAbilityAction(endpoint)}", ${getAbilitySubjectTypes(endpoint, resolver, getEndpointTag(endpoint, resolver.options)).join(" | ")}>;`);
 	const workspaceAclHook = renderWorkspaceAclHook({
 		resolver,
 		endpoint
@@ -3325,6 +3397,9 @@ function renderAbilityFunction({ resolver, endpoint }) {
 	}
 	return lines.join("\n");
 }
+function renderConditionType(resolver, endpoint, propertyType) {
+	return getAbilityConditionType(propertyType, resolver, getEndpointTag(endpoint, resolver.options));
+}
 
 //#endregion
 //#region src/generators/const/buildConfigs.const.ts
@@ -3537,7 +3612,7 @@ function getColumnsConfig(resolver, endpoint) {
 		...acc,
 		[key]: true
 	}), {});
-	const sortableEnumSchemaName = endpoint.parameters.find((param) => param.parameterObject && isSortingParameterObject(param.parameterObject))?.parameterSortingEnumSchemaName;
+	const sortableEnumSchemaName = endpoint.parameters.find((param) => param.parameterSortingEnumSchemaName)?.parameterSortingEnumSchemaName;
 	return {
 		columns: {
 			schema: getImportedZodSchemaName(resolver, zodSchema),
@@ -3580,7 +3655,7 @@ const QUERIES_MODULE_NAME = "moduleName";
 //#endregion
 //#region src/generators/generate/generateConfigs.ts
 function generateConfigs(generateTypeParams) {
-	const { configs, hasZodImport, modelsImports, aclImports } = getBuilderConfigs(generateTypeParams);
+	const { configs, hasZodImport, modelsImports, queriesImports, aclImports } = getBuilderConfigs(generateTypeParams);
 	if (configs.length === 0) return;
 	const { resolver, tag } = generateTypeParams;
 	const endpoints = configs.flatMap((config) => [
@@ -3590,10 +3665,18 @@ function generateConfigs(generateTypeParams) {
 		config.bulkDelete?.mutation
 	]).filter((m) => typeof m !== "string" && m !== void 0);
 	const hasMutation = endpoints.length > 0;
-	resolver.options.checkAcl && endpoints.some((e) => e.acl);
+	const hasAclCheck = resolver.options.checkAcl && endpoints.some((e) => e.acl);
 	const hasMutationEffects = resolver.options.mutationEffects && hasMutation;
 	const hasMutationDefaultOnError = resolver.options.mutationDefaultOnError && hasMutation;
-	const hasWorkspaceContext = resolver.options.workspaceContext && endpoints.some((e) => resolver.options.workspaceContext);
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const hasAxiosDefaultImport = endpoints.some((e) => e.mediaUpload);
+	const hasAxiosImport = hasAxiosRequestConfig || hasAxiosDefaultImport;
+	const axiosImport = {
+		defaultImport: hasAxiosDefaultImport ? AXIOS_DEFAULT_IMPORT_NAME : void 0,
+		bindings: [],
+		typeBindings: hasAxiosImport ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
+		from: "axios"
+	};
 	const endpointsImports = getEndpointsImports({
 		tag,
 		endpoints,
@@ -3621,10 +3704,6 @@ function generateConfigs(generateTypeParams) {
 		bindings: [ACL_CHECK_HOOK],
 		from: ACL_PACKAGE_IMPORT_PATH
 	};
-	const workspaceContextImport = {
-		bindings: ["OpenApiWorkspaceContext"],
-		from: PACKAGE_IMPORT_PATH
-	};
 	const hasDynamicInputsImport = configs.some((config) => config.readAll.filters || config.create?.inputDefs || config.update?.inputDefs);
 	const dynamicInputsImport = {
 		bindings: [BUILDERS_UTILS.dynamicInputs],
@@ -3636,10 +3715,12 @@ function generateConfigs(generateTypeParams) {
 		from: resolver.options.dynamicColumnsImportPath
 	};
 	const lines = [];
+	if (hasAxiosImport) lines.push(renderImport$3(axiosImport));
 	if (hasZodImport) lines.push(renderImport$3(ZOD_IMPORT));
 	if (hasDynamicInputsImport) lines.push(renderImport$3(dynamicInputsImport));
 	if (hasDynamicColumnsImport) lines.push(renderImport$3(dynamicColumnsImport));
 	for (const modelsImport of modelsImports) lines.push(renderImport$3(modelsImport));
+	for (const queriesImport of queriesImports) lines.push(renderImport$3(queriesImport));
 	for (const endpointsImport of endpointsImports) lines.push(renderImport$3(endpointsImport));
 	if (hasMutation) {
 		lines.push(renderImport$3(queryImport));
@@ -3648,8 +3729,7 @@ function generateConfigs(generateTypeParams) {
 			lines.push(renderImport$3(queryModulesImport));
 			lines.push(renderImport$3(mutationEffectsImport));
 		}
-		lines.push(renderImport$3(aclCheckImport));
-		if (hasWorkspaceContext) lines.push(renderImport$3(workspaceContextImport));
+		if (hasAclCheck) lines.push(renderImport$3(aclCheckImport));
 	}
 	for (const aclImport of aclImports) lines.push(renderImport$3(aclImport));
 	lines.push("");
@@ -3707,32 +3787,34 @@ function renderMutationContent(resolver, endpoint, tag) {
 	});
 	const endpointParamsStr = endpointParams.map((p) => `${p.name}${p.required ? "" : "?"}: ${p.type}`).join("; ");
 	const destructuredMutationArgs = endpointParams.map((p) => p.name).join(", ");
+	const resolvedEndpointArgs = mapEndpointParamsToFunctionParams(resolver, endpoint, { modelNamespaceTag: endpointTag }).map((p) => p.name).join(", ");
 	const endpointFunction = getImportedEndpointName(endpoint, resolver.options);
 	const mutationVariablesType = endpoint.mediaUpload ? `{ ${endpointParamsStr}${endpointParamsStr ? "; " : ""}abortController?: AbortController; onUploadProgress?: (progress: { loaded: number; total: number }) => void }` : `{ ${endpointParamsStr} }`;
 	const lines = [];
-	lines.push(`(options?: AppMutationOptions<typeof ${endpointFunction}, ${mutationVariablesType}>${hasAxiosRequestConfig ? `, config?: AxiosRequestConfig` : ""}) => {`);
+	lines.push(`(options?: AppMutationOptions<typeof ${endpointFunction}, ${mutationVariablesType}>${hasMutationEffects ? ` & ${MUTATION_EFFECTS.optionsType}` : ""}${hasAxiosRequestConfig ? `, config?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
 	if (hasMutationDefaultOnError) lines.push("  const queryConfig = OpenApiQueryConfig.useConfig();");
-	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects<typeof ${QUERY_MODULE_ENUM}.${endpointTag}>({ currentModule: ${QUERY_MODULE_ENUM}.${tag} });`);
-	lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
+	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects<${QUERY_MODULE_ENUM}.${endpointTag}>({ currentModule: ${QUERY_MODULE_ENUM}.${tag} });`);
+	if (hasAclCheck) lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
 	lines.push("");
 	lines.push(`  return ${QUERY_HOOKS.mutation}({`);
 	const mutationFnArg = destructuredMutationArgs ? `{ ${destructuredMutationArgs}${endpoint.mediaUpload ? `${destructuredMutationArgs ? ", " : ""}abortController, onUploadProgress` : ""} }` : "";
-	lines.push(`    mutationFn: (${mutationFnArg}) => {`);
-	if (hasAclCheck) lines.push(`      checkAcl(${getNamespaceName({
-		type: GenerateType.Acl,
-		tag: endpointTag,
-		options: resolver.options
-	})}.canUse${capitalize(snakeToCamel(endpoint.operationName))}({ ${destructuredMutationArgs} }));`);
-	lines.push(`      return ${endpointFunction}(${destructuredMutationArgs}${hasAxiosRequestConfig ? `${destructuredMutationArgs ? ", " : ""}config` : ""});`);
+	lines.push(`    mutationFn: ${endpoint.mediaUpload ? "async " : ""}(${mutationFnArg}) => {`);
+	if (hasAclCheck) lines.push(renderAclCheckCall(resolver, endpoint, void 0, "      "));
+	if (endpoint.mediaUpload) lines.push(...renderMediaUploadMutationBody({
+		resolver,
+		endpointFunction,
+		resolvedEndpointArgs
+	}).map((line) => `      ${line}`));
+	else lines.push(`      return ${endpointFunction}(${destructuredMutationArgs}${hasAxiosRequestConfig ? `${destructuredMutationArgs ? ", " : ""}config` : ""});`);
 	lines.push("    },");
+	lines.push("    ...options,");
+	if (hasMutationDefaultOnError) lines.push("    onError: options?.onError ?? queryConfig.onError,");
 	if (hasMutationEffects) {
-		lines.push("    onSuccess: async (...args) => {");
-		lines.push("      await runMutationEffects();");
-		lines.push("      await options?.onSuccess?.(...args);");
+		lines.push("    onSuccess: async (resData, variables, onMutateResult, context) => {");
+		lines.push("      await runMutationEffects(resData, variables, options);");
+		lines.push("      options?.onSuccess?.(resData, variables, onMutateResult, context);");
 		lines.push("    },");
 	}
-	lines.push("    ...options,");
-	if (hasMutationDefaultOnError) lines.push("    onError: options?.onError ?? queryConfig.onError,");
 	lines.push("  });");
 	lines.push("}");
 	return lines.map((line) => "        " + line).join("\n").trimStart();
@@ -3809,10 +3891,11 @@ function generateEndpoints({ resolver, data, tag }) {
 		from: getAppRestClientImportPath(resolver.options)
 	};
 	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
-	const hasAxiosImport = hasAxiosRequestConfig;
+	const hasGetEndpoints = endpoints.some((endpoint) => endpoint.method === "get");
+	const hasAxiosImport = hasAxiosRequestConfig || hasGetEndpoints;
 	const axiosImport = {
 		bindings: [],
-		typeBindings: hasAxiosRequestConfig ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
+		typeBindings: hasAxiosImport ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
 		from: AXIOS_IMPORT.from
 	};
 	const generateParse = resolver.options.parseRequestParams;
@@ -3850,9 +3933,10 @@ function generateEndpoints({ resolver, data, tag }) {
 		const endpointBody = getEndpointBody$1(endpoint);
 		const hasUndefinedEndpointBody = requiresBody(endpoint) && !endpointBody && hasEndpointConfig(endpoint, resolver);
 		const endpointConfig = renderEndpointConfig(resolver, endpoint, tag);
-		lines.push(`export const ${getEndpointName(endpoint)} = (${endpointParams}${hasAxiosRequestConfig ? `${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
+		const hasRequestConfigParam = hasAxiosRequestConfig || endpoint.method === "get";
+		lines.push(`export const ${getEndpointName(endpoint)} = (${endpointParams}${hasRequestConfigParam ? `${AXIOS_REQUEST_CONFIG_NAME}?: ${getRequestConfigType$1()}` : ""}) => {`);
 		lines.push(`    return ${APP_REST_CLIENT_NAME}.${endpoint.method}(`);
-		lines.push(`        { resSchema: ${getImportedZodSchemaName(resolver, endpoint.response)} },`);
+		lines.push(`        ${renderRequestInfo(resolver, endpoint, tag)},`);
 		lines.push(`        \`${getEndpointPath(endpoint)}\`,`);
 		if (endpointBody) lines.push(`        ${generateParse ? renderEndpointParamParse(resolver, endpointBody, endpointBody.name, tag) : endpointBody.name},`);
 		else if (hasUndefinedEndpointBody) lines.push("        undefined,");
@@ -3863,6 +3947,12 @@ function generateEndpoints({ resolver, data, tag }) {
 	if (resolver.options.tsNamespaces) lines.push("}");
 	return lines.join("\n").trimEnd() + "\n";
 }
+function renderRequestInfo(resolver, endpoint, tag) {
+	return `{ resSchema: ${getImportedZodSchemaName(resolver, endpoint.response, resolver.options.modelsInCommon && resolver.options.splitByTags ? tag : void 0)} }`;
+}
+function getRequestConfigType$1() {
+	return `${AXIOS_REQUEST_CONFIG_TYPE} & { allowInvalidResponseData?: boolean }`;
+}
 function renderImport$2(importData) {
 	const namedImports = [...importData.bindings, ...(importData.typeBindings ?? []).map((binding) => importData.typeOnly ? binding : `type ${binding}`)];
 	const names = [...importData.defaultImport ? [importData.defaultImport] : [], ...namedImports.length > 0 ? [`{ ${namedImports.join(", ")} }`] : []].join(", ");
@@ -3876,17 +3966,24 @@ function renderEndpointArgs$1(resolver, endpoint, options) {
 }
 function renderEndpointParamParse(resolver, param, paramName, modelNamespaceTag) {
 	const addOptional = !(param.parameterObject ?? param.bodyObject)?.required && (Boolean(param.parameterSortingEnumSchemaName) || isNamedZodSchema(param.zodSchema));
-	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${addOptional ? ".optional()" : ""}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
+	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${getSortingPresenceChain$1(resolver, param)}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
 	const queryArgs = param.type === "Query" ? `, { type: "query", name: "${paramName}" }` : "";
 	return `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.parse}(${schemaValue}, ${paramName}${queryArgs})`;
 }
+function getSortingPresenceChain$1(resolver, param) {
+	const zodSchemaCode = resolver.getCodeByZodSchemaName(param.zodSchema) ?? param.zodSchema;
+	if (zodSchemaCode.includes(".nullish()")) return ".nullish()";
+	if (zodSchemaCode.includes(".nullable()")) return ".nullable()";
+	return !(param.parameterObject ?? param.bodyObject)?.required ? ".optional()" : "";
+}
 function renderEndpointConfig(resolver, endpoint, modelNamespaceTag) {
 	const endpointConfig = getEndpointConfig(endpoint);
-	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
-	if (Object.keys(endpointConfig).length === 0) return hasAxiosRequestConfig ? AXIOS_REQUEST_CONFIG_NAME : "";
+	const hasRequestConfigParam = resolver.options.axiosRequestConfig || endpoint.method === "get";
+	const needsBlobConfig = endpoint.mediaDownload || endpoint.response === "z.instanceof(Blob)";
+	if (Object.keys(endpointConfig).length === 0 && !needsBlobConfig) return hasRequestConfigParam ? AXIOS_REQUEST_CONFIG_NAME : "";
 	const lines = [];
 	lines.push("{");
-	if (hasAxiosRequestConfig) lines.push(`    ...${AXIOS_REQUEST_CONFIG_NAME},`);
+	if (hasRequestConfigParam) lines.push(`    ...${AXIOS_REQUEST_CONFIG_NAME},`);
 	if (endpointConfig.params) {
 		lines.push("    params: {");
 		for (const param of endpointConfig.params) {
@@ -4061,11 +4158,12 @@ function generateQueries(params) {
 	const endpointGroups = groupEndpoints(endpoints, resolver);
 	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
 	const hasAxiosDefaultImport = endpoints.some(({ mediaUpload }) => mediaUpload);
-	const hasAxiosImport = hasAxiosRequestConfig || hasAxiosDefaultImport;
+	const hasGetEndpoints = endpoints.some((endpoint) => endpoint.method === "get");
+	const hasAxiosImport = hasAxiosRequestConfig || hasAxiosDefaultImport || hasGetEndpoints;
 	const axiosImport = {
 		defaultImport: hasAxiosDefaultImport ? AXIOS_DEFAULT_IMPORT_NAME : void 0,
 		bindings: [],
-		typeBindings: hasAxiosRequestConfig ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
+		typeBindings: hasAxiosImport ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
 		from: AXIOS_IMPORT.from
 	};
 	const { queryEndpoints, infiniteQueryEndpoints, mutationEndpoints, aclEndpoints } = endpointGroups;
@@ -4096,7 +4194,7 @@ function generateQueries(params) {
 		from: ACL_PACKAGE_IMPORT_PATH
 	};
 	const queryTypesImport = {
-		bindings: [...hasMutationDefaultOnError ? ["OpenApiQueryConfig"] : []],
+		bindings: [...queryEndpoints.length > 0 || infiniteQueryEndpoints.length > 0 || hasMutationDefaultOnError ? ["OpenApiQueryConfig"] : []],
 		typeBindings: [
 			...queryEndpoints.length > 0 ? [QUERY_OPTIONS_TYPES.query] : [],
 			...resolver.options.infiniteQueries && infiniteQueryEndpoints.length > 0 ? [QUERY_OPTIONS_TYPES.infiniteQuery] : [],
@@ -4335,16 +4433,6 @@ function renderWorkspaceParamResolutions({ replacements, paramTypes, indent }) {
 		indent
 	})];
 }
-function renderAclCheckCall(resolver, endpoint, replacements, indent = "") {
-	const checkParams = getAbilityConditionsTypes(endpoint)?.map((condition) => invalidVariableNameCharactersToCamel(condition.name));
-	const paramNames = new Set(endpoint.parameters.map((param) => invalidVariableNameCharactersToCamel(param.name)));
-	const hasAllCheckParams = checkParams?.every((param) => paramNames.has(param));
-	const args = hasAbilityConditions(endpoint) && hasAllCheckParams ? `{ ${(checkParams ?? []).map((param) => {
-		const resolvedParam = replacements?.[param] ?? param;
-		return resolvedParam === param ? param : `${param}: ${resolvedParam}`;
-	}).join(", ")} } ` : "";
-	return `${indent}checkAcl(${getImportedAbilityFunctionName(endpoint, resolver.options)}(${args}));`;
-}
 function addAsteriskAfterNewLine(str) {
 	return str.replace(/\n/g, "\n *");
 }
@@ -4399,9 +4487,10 @@ function renderInlineEndpoints({ resolver, endpoints, tag }) {
 		const endpointBody = getEndpointBody$1(endpoint);
 		const hasUndefinedEndpointBody = requiresBody(endpoint) && !endpointBody && hasEndpointConfig(endpoint, resolver);
 		const endpointConfig = renderInlineEndpointConfig(resolver, endpoint, tag);
-		lines.push(`const ${getEndpointName(endpoint)} = (${endpointParams}${resolver.options.axiosRequestConfig ? `${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
+		const hasRequestConfigParam = resolver.options.axiosRequestConfig || endpoint.method === "get";
+		lines.push(`const ${getEndpointName(endpoint)} = (${endpointParams}${hasRequestConfigParam ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}?: ${getRequestConfigType()}` : ""}) => {`);
 		lines.push(`  return ${APP_REST_CLIENT_NAME}.${endpoint.method}(`);
-		lines.push(`    { resSchema: ${getImportedZodSchemaName(resolver, endpoint.response, tag)} },`);
+		lines.push(`    ${renderInlineRequestInfo(resolver, endpoint, tag)},`);
 		lines.push(`    \`${getEndpointPath(endpoint)}\`,`);
 		if (endpointBody) lines.push(`    ${resolver.options.parseRequestParams ? renderInlineEndpointParamParse(resolver, endpointBody, endpointBody.name, tag) : endpointBody.name},`);
 		else if (hasUndefinedEndpointBody) lines.push("    undefined,");
@@ -4412,19 +4501,32 @@ function renderInlineEndpoints({ resolver, endpoints, tag }) {
 	}
 	return lines;
 }
+function renderInlineRequestInfo(resolver, endpoint, tag) {
+	return `{ resSchema: ${getImportedZodSchemaName(resolver, endpoint.response, tag)} }`;
+}
+function getRequestConfigType() {
+	return `${AXIOS_REQUEST_CONFIG_TYPE} & { allowInvalidResponseData?: boolean }`;
+}
 function renderInlineEndpointParamParse(resolver, param, paramName, modelNamespaceTag) {
 	const addOptional = !(param.parameterObject ?? param.bodyObject)?.required && (Boolean(param.parameterSortingEnumSchemaName) || isNamedZodSchema(param.zodSchema));
-	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${addOptional ? ".optional()" : ""}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
+	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${getSortingPresenceChain(resolver, param)}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
 	const queryArgs = param.type === "Query" ? `, { type: "query", name: "${paramName}" }` : "";
 	return `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.parse}(${schemaValue}, ${paramName}${queryArgs})`;
 }
+function getSortingPresenceChain(resolver, param) {
+	const zodSchemaCode = resolver.getCodeByZodSchemaName(param.zodSchema) ?? param.zodSchema;
+	if (zodSchemaCode.includes(".nullish()")) return ".nullish()";
+	if (zodSchemaCode.includes(".nullable()")) return ".nullable()";
+	return !(param.parameterObject ?? param.bodyObject)?.required ? ".optional()" : "";
+}
 function renderInlineEndpointConfig(resolver, endpoint, modelNamespaceTag) {
 	const endpointConfig = getEndpointConfig(endpoint);
-	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
-	if (Object.keys(endpointConfig).length === 0) return hasAxiosRequestConfig ? AXIOS_REQUEST_CONFIG_NAME : "";
+	const hasRequestConfigParam = resolver.options.axiosRequestConfig || endpoint.method === "get";
+	const needsBlobConfig = endpoint.mediaDownload || endpoint.response === "z.instanceof(Blob)";
+	if (Object.keys(endpointConfig).length === 0 && !needsBlobConfig) return hasRequestConfigParam ? AXIOS_REQUEST_CONFIG_NAME : "";
 	const lines = [];
 	lines.push("{");
-	if (hasAxiosRequestConfig) lines.push(`      ...${AXIOS_REQUEST_CONFIG_NAME},`);
+	if (hasRequestConfigParam) lines.push(`      ...${AXIOS_REQUEST_CONFIG_NAME},`);
 	if (endpointConfig.params) {
 		lines.push("      params: {");
 		for (const param of endpointConfig.params) {
@@ -4444,19 +4546,19 @@ function renderInlineEndpointConfig(resolver, endpoint, modelNamespaceTag) {
 	return lines.join("\n");
 }
 function renderQueryOptions({ resolver, endpoint, inlineEndpoints }) {
-	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const hasRequestConfigParam = resolver.options.axiosRequestConfig || endpoint.method === "get";
 	const endpointParams = renderEndpointParams(resolver, endpoint, { modelNamespaceTag: getEndpointTag(endpoint, resolver.options) });
 	const endpointArgs = renderEndpointArgs(resolver, endpoint, {});
 	const endpointFunction = inlineEndpoints ? getEndpointName(endpoint) : getImportedEndpointName(endpoint, resolver.options);
 	const lines = [];
-	lines.push(`const ${getQueryOptionsName(endpoint)} = (${endpointParams ? `{ ${endpointArgs} }: { ${endpointParams} }` : ""}${hasAxiosRequestConfig ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => ({`);
+	lines.push(`const ${getQueryOptionsName(endpoint)} = (${endpointParams ? `{ ${endpointArgs} }: { ${endpointParams} }` : ""}${hasRequestConfigParam ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}?: ${getRequestConfigType()}` : ""}) => ({`);
 	lines.push(`  queryKey: keys.${getEndpointName(endpoint)}(${endpointArgs}),`);
-	lines.push(`  queryFn: () => ${endpointFunction}(${endpointArgs}${hasAxiosRequestConfig ? `${endpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""}),`);
+	lines.push(`  queryFn: () => ${endpointFunction}(${endpointArgs}${hasRequestConfigParam ? `${endpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""}),`);
 	lines.push("});");
 	return lines.join("\n");
 }
 function renderInfiniteQueryOptions({ resolver, endpoint, inlineEndpoints }) {
-	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const hasRequestConfigParam = resolver.options.axiosRequestConfig || endpoint.method === "get";
 	const endpointParams = renderEndpointParams(resolver, endpoint, {
 		excludePageParam: true,
 		modelNamespaceTag: getEndpointTag(endpoint, resolver.options)
@@ -4465,13 +4567,13 @@ function renderInfiniteQueryOptions({ resolver, endpoint, inlineEndpoints }) {
 	const endpointArgsWithPage = renderEndpointArgs(resolver, endpoint, { replacePageParam: true });
 	const endpointFunction = inlineEndpoints ? getEndpointName(endpoint) : getImportedEndpointName(endpoint, resolver.options);
 	const lines = [];
-	lines.push(`const ${getInfiniteQueryOptionsName(endpoint)} = (${endpointParams ? `{ ${endpointArgsWithoutPage} }: { ${endpointParams} }` : ""}${hasAxiosRequestConfig ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => ({`);
+	lines.push(`const ${getInfiniteQueryOptionsName(endpoint)} = (${endpointParams ? `{ ${endpointArgsWithoutPage} }: { ${endpointParams} }` : ""}${hasRequestConfigParam ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}?: ${getRequestConfigType()}` : ""}) => ({`);
 	lines.push(`  queryKey: keys.${getEndpointName(endpoint)}Infinite(${endpointArgsWithoutPage}),`);
-	lines.push(`  queryFn: ({ pageParam }: { pageParam: number }) => ${endpointFunction}(${endpointArgsWithPage}${hasAxiosRequestConfig ? `, ${AXIOS_REQUEST_CONFIG_NAME}` : ""}),`);
+	lines.push(`  queryFn: ({ pageParam }: { pageParam: number }) => ${endpointFunction}(${endpointArgsWithPage}${hasRequestConfigParam ? `, ${AXIOS_REQUEST_CONFIG_NAME}` : ""}),`);
 	lines.push("  initialPageParam: 1,");
 	lines.push(`  getNextPageParam: ({ ${resolver.options.infiniteQueryResponseParamNames.page}, ${resolver.options.infiniteQueryResponseParamNames.totalItems}, ${resolver.options.infiniteQueryResponseParamNames.limit}: limitParam }: Awaited<ReturnType<typeof ${endpointFunction}>>) => {`);
 	lines.push(`    const pageParam = ${resolver.options.infiniteQueryResponseParamNames.page} ?? 1;`);
-	lines.push(`    return pageParam * limitParam < ${resolver.options.infiniteQueryResponseParamNames.totalItems} ? pageParam + 1 : null;`);
+	lines.push(`    return pageParam * limitParam < (${resolver.options.infiniteQueryResponseParamNames.totalItems} ?? 0) ? pageParam + 1 : null;`);
 	lines.push("  },");
 	lines.push("});");
 	return lines.join("\n");
@@ -4514,7 +4616,8 @@ function renderQuery({ resolver, endpoint, inlineEndpoints }) {
 	});
 	const queryOptionsName = getQueryOptionsName(endpoint);
 	const hasQueryFnOverride = hasAclCheck;
-	const queryOptionsArgs = `${resolvedEndpointArgs ? `{ ${resolvedEndpointArgs} }` : ""}${hasAxiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""}`;
+	const requestConfig = `{ ${hasAxiosRequestConfig ? `...${AXIOS_REQUEST_CONFIG_NAME}, ` : ""}allowInvalidResponseData: queryConfig.allowInvalidResponseData }`;
+	const queryOptionsArgs = `${resolvedEndpointArgs ? `{ ${resolvedEndpointArgs} }, ` : ""}${requestConfig}`;
 	const lines = [];
 	lines.push(renderQueryJsDocs({
 		resolver,
@@ -4523,6 +4626,7 @@ function renderQuery({ resolver, endpoint, inlineEndpoints }) {
 		tag
 	}));
 	lines.push(`export const ${getQueryName(endpoint)} = <TData>(${endpointParams ? `{ ${endpointArgs} }: { ${endpointParams} }, ` : ""}options?: AppQueryOptions<typeof ${inlineEndpoints ? getEndpointName(endpoint) : getImportedEndpointName(endpoint, resolver.options)}, TData>${hasAxiosRequestConfig ? `, ${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
+	lines.push("  const queryConfig = OpenApiQueryConfig.useConfig();");
 	if (hasAclCheck) lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
 	lines.push(...renderWorkspaceParamResolutions({
 		replacements: workspaceParamReplacements,
@@ -4615,34 +4719,12 @@ function renderMutation({ resolver, endpoint, inlineEndpoints, precomputed }) {
 		indent: "      "
 	}));
 	if (hasAclCheck) lines.push(renderAclCheckCall(resolver, endpoint, workspaceParamReplacements, "      "));
-	if (endpoint.mediaUpload) {
-		lines.push(`      const uploadInstructions = await ${endpointFunction}(${resolvedEndpointArgs}${hasAxiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""});`);
-		lines.push("      ");
-		lines.push("      if (file && uploadInstructions.url) {");
-		lines.push("        const method = (data?.method?.toLowerCase() ?? \"put\") as \"put\" | \"post\";");
-		lines.push("        let dataToSend: File | FormData = file;");
-		lines.push("        if (method === \"post\") {");
-		lines.push("          dataToSend = new FormData();");
-		lines.push("          if (uploadInstructions.fields) {");
-		lines.push("            for (const [key, value] of uploadInstructions.fields) {");
-		lines.push("              dataToSend.append(key, value);");
-		lines.push("            }");
-		lines.push("          }");
-		lines.push("          dataToSend.append(\"file\", file);");
-		lines.push("        }");
-		lines.push("        await axios[method](uploadInstructions.url, dataToSend, {");
-		lines.push("          headers: {");
-		lines.push("            \"Content-Type\": file.type,");
-		lines.push("          },");
-		lines.push("          signal: abortController?.signal,");
-		lines.push("          onUploadProgress: onUploadProgress");
-		lines.push("          ? (progressEvent) => onUploadProgress({ loaded: progressEvent.loaded, total: progressEvent.total ?? 0 })");
-		lines.push("          : undefined,");
-		lines.push("        });");
-		lines.push("      }");
-		lines.push("      ");
-		lines.push("      return uploadInstructions;");
-	} else lines.push(`      ${hasMutationFnBody ? "return " : ""}${endpointFunction}(${resolvedEndpointArgs}${hasAxiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""})`);
+	if (endpoint.mediaUpload) lines.push(...renderMediaUploadMutationBody({
+		resolver,
+		endpointFunction,
+		resolvedEndpointArgs
+	}).map((line) => `      ${line}`));
+	else lines.push(`      ${hasMutationFnBody ? "return " : ""}${endpointFunction}(${resolvedEndpointArgs}${hasAxiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""})`);
 	if (hasMutationFnBody) lines.push("    },");
 	else lines.push(",");
 	if (isScoped) {
@@ -4722,7 +4804,8 @@ function renderInfiniteQuery({ resolver, endpoint, inlineEndpoints }) {
 	const endpointArgsWithoutPage = renderEndpointArgs(resolver, endpoint, { excludePageParam: true });
 	const resolvedEndpointArgsWithoutPage = renderEndpointObjectArgs(resolver, endpoint, { excludePageParam: true }, workspaceParamReplacements);
 	const queryOptionsName = getInfiniteQueryOptionsName(endpoint);
-	const queryOptionsArgs = `${resolvedEndpointArgsWithoutPage ? `{ ${resolvedEndpointArgsWithoutPage} }` : ""}${hasAxiosRequestConfig ? `${resolvedEndpointArgsWithoutPage ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""}`;
+	const requestConfig = `{ ${hasAxiosRequestConfig ? `...${AXIOS_REQUEST_CONFIG_NAME}, ` : ""}allowInvalidResponseData: queryConfig.allowInvalidResponseData }`;
+	const queryOptionsArgs = `${resolvedEndpointArgsWithoutPage ? `{ ${resolvedEndpointArgsWithoutPage} }, ` : ""}${requestConfig}`;
 	const hasQueryFnOverride = hasAclCheck;
 	const lines = [];
 	lines.push(renderQueryJsDocs({
@@ -4732,6 +4815,7 @@ function renderInfiniteQuery({ resolver, endpoint, inlineEndpoints }) {
 		tag
 	}));
 	lines.push(`export const ${getInfiniteQueryName(endpoint)} = <TData>(${endpointParams ? `{ ${endpointArgsWithoutPage} }: { ${endpointParams} }, ` : ""}options?: AppInfiniteQueryOptions<typeof ${inlineEndpoints ? getEndpointName(endpoint) : getImportedEndpointName(endpoint, resolver.options)}, TData>${hasAxiosRequestConfig ? `, ${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
+	lines.push("  const queryConfig = OpenApiQueryConfig.useConfig();");
 	if (hasAclCheck) lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
 	lines.push(...renderWorkspaceParamResolutions({
 		replacements: workspaceParamReplacements,
@@ -4771,6 +4855,7 @@ export const ${APP_REST_CLIENT_NAME} = new RestClient({
 function domainToPascalCase(domain) {
 	return domain.split(/[-_]/).map(capitalize).join("");
 }
+const VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 function generateDomainErrors({ data }) {
 	const byDomain = /* @__PURE__ */ new Map();
 	for (const { endpoints } of data.values()) for (const endpoint of endpoints) for (const error of endpoint.errors) {
@@ -4788,8 +4873,16 @@ function generateDomainErrors({ data }) {
 	const blocks = [];
 	for (const [domain, codes] of [...byDomain.entries()].sort(([a], [b]) => a.localeCompare(b))) {
 		const pascalName = domainToPascalCase(domain);
-		const entries = [...codes.values()].sort((a, b) => a.code - b.code).map(({ code, name, description }) => {
-			return `${description ? `  /** ${description} */\n  ` : "  "}${name ?? `ERROR_${code}`}: ${code}`;
+		const entries = [...codes.values()].sort((a, b) => {
+			if (typeof a.code === "number" && typeof b.code === "number") return a.code - b.code;
+			const sa = String(a.code);
+			const sb = String(b.code);
+			return sa < sb ? -1 : sa > sb ? 1 : 0;
+		}).map(({ code, name, description }) => {
+			const comment = description ? `  /** ${description} */\n  ` : "  ";
+			const key = name ?? (typeof code === "string" ? code : `ERROR_${code}`);
+			if (!VALID_IDENTIFIER.test(key)) throw new Error(`Domain error code "${code}" produces an invalid identifier "${key}". Use the 'name' field on @ApiDomainErrorResponse to provide a valid identifier.`);
+			return `${comment}${key}: ${typeof code === "string" ? `"${code}"` : String(code)}`;
 		}).join(",\n");
 		blocks.push(`export const ${pascalName}DomainErrors = {\n${entries},\n} as const;`);
 		blocks.push(`export type ${pascalName}DomainErrorCode = (typeof ${pascalName}DomainErrors)[keyof typeof ${pascalName}DomainErrors];`);