@povio/openapi-codegen-cli 3.1.0 → 3.2.0-rc.2

package/dist/generateCodeFromOpenAPIDoc-CLQbTTwF.mjs

@@ -0,0 +1,2004 @@
+import { r as getZodSchemaRefs, t as getDataFromOpenAPIDoc } from "./getDataFromOpenAPIDoc-fPRPa4_t.mjs";
+import { $ as getImportedAbilityFunctionName, $t as isParamMediaTypeAllowed, A as getEndpointsImports, B as getPrefetchInfiniteQueryName, Bt as QUERY_MODULE_ENUM, C as getAppRestClientImportPath, Ct as isReadEndpoint, D as getTagFileName, Dn as AXIOS_IMPORT, E as getQueryTypesImportPath, En as AXIOS_DEFAULT_IMPORT_NAME, F as mergeImports, Ft as APP_REST_CLIENT_NAME, G as getAbilityConditionType, H as getQueryName, Ht as ZOD_EXTENDED, I as getImportedInfiniteQueryName, In as shouldInlineEndpointsForTag, It as BUILDERS_UTILS, J as getAbilityFunctionName, K as getAbilityConditionsTypes, L as getImportedQueryName, Ln as camelToSpaceSeparated, Lt as DOMAIN_ERRORS_FILE, M as getInfiniteQueriesImports, Mt as isEnumZodSchema, N as getModelsImports, Nn as getEndpointTag, Nt as isNamedZodSchema, O as getTagImportPath, On as AXIOS_REQUEST_CONFIG_NAME, P as getQueriesImports, Pt as APP_REST_CLIENT_FILE, Q as getAppAbilitiesType, R as getInfiniteQueryName, Rn as capitalize, Rt as MUTATION_EFFECTS, St as isReadAllEndpoint, T as getQueryModulesImportPath, Tn as ZOD_IMPORT, Tt as invalidVariableNameCharactersToCamel, U as getQueryOptionsName, Ut as PACKAGE_IMPORT_PATH, V as getPrefetchQueryName, Vn as kebabToCamel, Vt as QUERY_OPTIONS_TYPES, W as getAbilityAction, Wn as Profiler, Wt as getNamespaceName, X as getAbilitySubjectTypes, Y as getAbilitySubject, Z as getAclData, _ as hasEndpointConfig, _t as getPathSegments, at as getZodSchemaInferedTypeName, b as requiresBody, bt as isDeleteEndpoint, c as getDestructuredVariables, ct as getSchemaDescriptions, d as isQuery, dn as isSchemaObject, dt as DEFAULT_GENERATE_OPTIONS, et as hasAbilityConditions, f as getEndpointBody, ft as ACL_APP_ABILITIES, g as getImportedEndpointName, gt as CASL_ABILITY_IMPORT, h as getEndpointPath, ht as CASL_ABILITY_BINDING, i as shouldUseNativeCodegen, it as getZodSchemaDescription, j as getImportPath, jn as JSON_APPLICATION_FORMAT, k as getAclImports, kn as AXIOS_REQUEST_CONFIG_TYPE, l as isInfiniteQuery, m as getEndpointName, mn as ANY_SCHEMA, mt as ACL_CHECK_HOOK, nt as getImportedZodSchemaInferedTypeName, o as getOutputFileName, ot as getZodSchemaPropertyDescriptions, p as getEndpointConfig, pt as ACL_APP_ABILITY_FILE, q as getAbilityDescription, r as compileNativeData, rt as getImportedZodSchemaName, st as getZodSchemaType, tt as renderAclCheckCall, u as isMutation, un as isReferenceObject, ut as getUniqueArray, v as mapEndpointParamsToFunctionParams, vt as isBulkDeleteEndpoint, w as getFileNameWithExtension, wt as isUpdateEndpoint, xt as isPathSegmentParam, y as renderMediaUploadMutationBody, yt as isCreateEndpoint, z as getInfiniteQueryOptionsName, zt as QUERY_MODULES_FILE } from "./generate.runner-BGhsnDm8.mjs";
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/generators/generate/generateAcl.ts
+function generateAcl({ resolver, data, tag }) {
+	const nativeContent = resolver.getNativeRenderedAcl?.(tag);
+	if (nativeContent) return nativeContent;
+	const aclData = getAclData({
+		resolver,
+		data,
+		tag
+	});
+	if (!aclData) return;
+	const { hasAdditionalAbilityImports, modelsImports, endpoints } = aclData;
+	const hasWorkspaceContext = endpoints.some((endpoint) => getWorkspaceConditionNames(resolver, endpoint).length > 0);
+	const caslAbilityTupleImport = {
+		bindings: [...hasAdditionalAbilityImports ? [CASL_ABILITY_BINDING.forcedSubject, CASL_ABILITY_BINDING.subject] : []],
+		typeBindings: [CASL_ABILITY_BINDING.abilityTuple],
+		from: CASL_ABILITY_IMPORT.from
+	};
+	const workspaceContextImport = {
+		bindings: ["useWorkspaceContext"],
+		from: PACKAGE_IMPORT_PATH
+	};
+	const lines = [];
+	lines.push(renderImport$4(caslAbilityTupleImport));
+	if (hasWorkspaceContext) lines.push(renderImport$4(workspaceContextImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$4(modelsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: "acl",
+		tag,
+		options: resolver.options
+	})} {`);
+	for (const endpoint of endpoints) {
+		lines.push(renderAbilityFunction({
+			resolver,
+			endpoint
+		}));
+		lines.push("");
+	}
+	if (resolver.options.tsNamespaces) lines.push("}");
+	return lines.join("\n").trimEnd() + "\n";
+}
+function generateAppAcl({ resolver, data }) {
+	const nativeContent = resolver.getNativeRenderedShared?.("appAcl");
+	if (nativeContent) return nativeContent;
+	const { appAbilitiesType, hasAdditionalAbilityImports, modelsImports } = getAppAbilitiesType({
+		resolver,
+		data
+	});
+	const caslAbilityTupleImport = {
+		bindings: [],
+		typeBindings: [
+			CASL_ABILITY_BINDING.pureAbility,
+			CASL_ABILITY_BINDING.abilityTuple,
+			...!appAbilitiesType ? [CASL_ABILITY_BINDING.subjectType] : [],
+			...hasAdditionalAbilityImports ? [CASL_ABILITY_BINDING.forcedSubject] : []
+		],
+		from: CASL_ABILITY_IMPORT.from,
+		typeOnly: true
+	};
+	const lines = [];
+	lines.push(renderImport$4(caslAbilityTupleImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$4(modelsImport));
+	lines.push("");
+	if (appAbilitiesType) {
+		lines.push(`export type ${ACL_APP_ABILITIES} = `);
+		for (const [action, subjects] of Object.entries(appAbilitiesType)) lines.push(`| ${CASL_ABILITY_BINDING.abilityTuple}<"${action}", ${subjects.join(" | ")}>`);
+	} else lines.push(`export type ${ACL_APP_ABILITIES} = ${CASL_ABILITY_BINDING.abilityTuple}<string, ${CASL_ABILITY_BINDING.subjectType}>;`);
+	lines.push("");
+	lines.push(`export type AppAbility = PureAbility<${ACL_APP_ABILITIES}>;`);
+	return lines.join("\n");
+}
+function renderImport$4(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(", ");
+	return `import${importData.typeOnly ? " type" : ""} ${names} from "${importData.from}";`;
+}
+function getWorkspaceContextAllowList$1(workspaceContext) {
+	return new Set(workspaceContext);
+}
+function getWorkspaceConditionNames(resolver, endpoint) {
+	const allowList = getWorkspaceContextAllowList$1(resolver.options.workspaceContext);
+	return (getAbilityConditionsTypes(endpoint) ?? []).map((condition) => condition.name).filter((name) => allowList.has(name));
+}
+function renderWorkspaceAclHook({ resolver, endpoint }) {
+	const abilityConditionsTypes = getAbilityConditionsTypes(endpoint) ?? [];
+	const workspaceConditionNames = getWorkspaceConditionNames(resolver, endpoint);
+	if (workspaceConditionNames.length === 0) return;
+	const workspaceConditionNameSet = new Set(workspaceConditionNames);
+	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 ? "" : "?"}: ${renderConditionType(resolver, endpoint, propertyType)}, `;
+	}).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))} = (`);
+	lines.push(`  object${objectRequired ? "" : "?"}: { ${objectParams} } `);
+	lines.push(") => {");
+	lines.push(`  const { ${contextBindings} } = useWorkspaceContext<{ ${contextType} }>();`);
+	for (const conditionName of workspaceConditionNames) {
+		const resolvedName = `normalize${capitalize(conditionName)}`;
+		lines.push(`  const ${resolvedName} = object?.${conditionName} ?? ${conditionName}Workspace;`);
+		lines.push(`  if (!${resolvedName}) {`);
+		lines.push(`    throw Error(\`${capitalize(conditionName)} not provided\`);`);
+		lines.push("  }");
+	}
+	lines.push(`  return ${getAbilityFunctionName(endpoint)}({ ...object, ${workspaceConditionNames.map((conditionName) => `${conditionName}: normalize${capitalize(conditionName)}`).join(", ")} });`);
+	lines.push("};");
+	return lines.join("\n");
+}
+function renderAbilityFunction({ resolver, endpoint }) {
+	const abilityConditionsTypes = getAbilityConditionsTypes(endpoint) ?? [];
+	const hasConditions = hasAbilityConditions(endpoint);
+	const lines = [];
+	const abilityQuery = endpoint.method === "get" ? endpoint.mediaDownload ? `\`${getQueryName(endpoint)}\` query or \`${getQueryName(endpoint, true)}\` mutation` : `\`${getQueryName(endpoint)}\` query` : `\`${getQueryName(endpoint)}\` mutation`;
+	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 { ${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 ? "" : "?"}: ${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, resolver, getEndpointTag(endpoint, resolver.options)).join(" | ")}>;`);
+	const workspaceAclHook = renderWorkspaceAclHook({
+		resolver,
+		endpoint
+	});
+	if (workspaceAclHook) {
+		lines.push("");
+		lines.push(workspaceAclHook);
+	}
+	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
+const BUILD_CONFIG_SUFFIX = "config";
+//#endregion
+//#region src/generators/utils/generate/generate.configs.utils.ts
+function getBuilderConfigs({ data, tag, resolver }) {
+	const endpoints = data.get(tag)?.endpoints;
+	if (!endpoints || endpoints.length === 0) return {
+		configs: [],
+		hasZodImport: false,
+		modelsImports: [],
+		queriesImports: [],
+		aclImports: []
+	};
+	const extendedEndpoints = endpoints.map((endpoint) => ({
+		...endpoint,
+		pathSegments: getPathSegments(endpoint.path)
+	}));
+	const namedReadAllEndpoints = resolveBuilderConfigNames(extendedEndpoints.filter((endpoint) => isReadAllEndpoint(endpoint, resolver.options)));
+	let hasZodImport = false;
+	const importedZodSchemas = [];
+	const importedEndpoints = [];
+	const importedInfiniteEndpoints = [];
+	const configs = Object.entries(namedReadAllEndpoints).map(([name, readAllEndpoint]) => {
+		const columnsConfig = getColumnsConfig(resolver, readAllEndpoint);
+		if (!columnsConfig) return;
+		importedEndpoints.push(readAllEndpoint);
+		importedInfiniteEndpoints.push(readAllEndpoint);
+		if (columnsConfig.zodSchema) if (isNamedZodSchema(columnsConfig.zodSchema)) importedZodSchemas.push(columnsConfig.zodSchema);
+		else hasZodImport = true;
+		if (columnsConfig.sortableEnumSchemaName) importedZodSchemas.push(columnsConfig.sortableEnumSchemaName);
+		const filter = readAllEndpoint.parameters.find((param) => param.name === resolver.options.filterParamName);
+		if (filter) importedZodSchemas.push(filter.zodSchema);
+		const config = {
+			name,
+			title: capitalize(camelToSpaceSeparated(name.replace(/config$/i, ""))),
+			readAll: {
+				acl: getAclConfig(readAllEndpoint, resolver.options),
+				paginated: getImportedQueryName(readAllEndpoint, resolver.options),
+				infinite: resolver.options.infiniteQueries ? getImportedInfiniteQueryName(readAllEndpoint, resolver.options) : void 0,
+				filters: getInputsConfig(resolver, filter),
+				columns: columnsConfig.columns
+			}
+		};
+		const readEndpoint = extendedEndpoints.find((endpoint) => isReadEndpoint(endpoint, readAllEndpoint));
+		if (readEndpoint) {
+			importedEndpoints.push(readEndpoint);
+			let responseSchema = readEndpoint.response;
+			if (isNamedZodSchema(responseSchema)) {
+				importedZodSchemas.push(responseSchema);
+				responseSchema = getImportedZodSchemaName(resolver, responseSchema);
+			} else hasZodImport = true;
+			config.read = {
+				acl: getAclConfig(readEndpoint, resolver.options),
+				schema: responseSchema,
+				query: getImportedQueryName(readEndpoint, resolver.options)
+			};
+		}
+		const createEndpoint = extendedEndpoints.find((endpoint) => isCreateEndpoint(endpoint, readAllEndpoint));
+		if (createEndpoint) {
+			importedEndpoints.push(createEndpoint);
+			const body = getEndpointBody(createEndpoint);
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.create = {
+					acl: getAclConfig(createEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: createEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
+		}
+		const updateEndpoint = extendedEndpoints.find((endpoint) => isUpdateEndpoint(endpoint, readAllEndpoint));
+		if (updateEndpoint) {
+			importedEndpoints.push(updateEndpoint);
+			const body = getEndpointBody(updateEndpoint);
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.update = {
+					acl: getAclConfig(updateEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: updateEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
+		}
+		const deleteEndpoint = extendedEndpoints.find((endpoint) => isDeleteEndpoint(endpoint, readAllEndpoint));
+		if (deleteEndpoint) {
+			importedEndpoints.push(deleteEndpoint);
+			const body = getEndpointBody(deleteEndpoint);
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.delete = {
+					acl: getAclConfig(deleteEndpoint, resolver.options),
+					mutation: deleteEndpoint
+				};
+			}
+		}
+		const bulkDeleteEndpoint = extendedEndpoints.find((endpoint) => isBulkDeleteEndpoint(endpoint, readAllEndpoint));
+		if (bulkDeleteEndpoint) {
+			importedEndpoints.push(bulkDeleteEndpoint);
+			const body = getEndpointBody(bulkDeleteEndpoint);
+			if (body) {
+				importedZodSchemas.push(body.zodSchema);
+				config.bulkDelete = {
+					acl: getAclConfig(bulkDeleteEndpoint, resolver.options),
+					schema: getImportedZodSchemaName(resolver, body.zodSchema),
+					mutation: bulkDeleteEndpoint,
+					inputDefs: getInputsConfig(resolver, body)
+				};
+			}
+		}
+		return config;
+	});
+	const modelsImports = getModelsImports({
+		resolver,
+		tag,
+		zodSchemas: importedZodSchemas
+	});
+	const queriesImports = getQueriesImports({
+		tag,
+		endpoints: importedEndpoints,
+		options: resolver.options
+	});
+	const infiniteQueriesImports = resolver.options.infiniteQueries ? getInfiniteQueriesImports({
+		tag,
+		endpoints: importedInfiniteEndpoints,
+		options: resolver.options
+	}) : [];
+	const aclImports = getAclImports({
+		tag,
+		endpoints: importedEndpoints.filter((endpoint) => endpoint.acl),
+		options: resolver.options
+	});
+	return {
+		configs: configs.filter(Boolean),
+		hasZodImport,
+		modelsImports,
+		queriesImports: mergeImports(resolver.options, queriesImports, infiniteQueriesImports),
+		aclImports
+	};
+}
+function resolveBuilderConfigNames(endpoints) {
+	const sortedEndpoints = endpoints.map((endpoint) => ({
+		...endpoint,
+		namePathSegments: endpoint.pathSegments.filter((segment) => !isPathSegmentParam(segment))
+	})).toSorted((a, b) => a.namePathSegments.length - b.namePathSegments.length);
+	const namedEndpoints = {};
+	for (const endpoint of sortedEndpoints) {
+		const namePathSegments = endpoint.namePathSegments;
+		let name = namePathSegments.length > 0 ? `${kebabToCamel(namePathSegments.pop())}${capitalize(BUILD_CONFIG_SUFFIX)}` : BUILD_CONFIG_SUFFIX;
+		while (namedEndpoints[name]) {
+			if (namePathSegments.length === 0) throw new Error(`Can't uniquely resolve builder config name: ${name}`);
+			name = `${kebabToCamel(namePathSegments.pop())}${capitalize(name)}`;
+		}
+		namedEndpoints[name] = endpoint;
+	}
+	return namedEndpoints;
+}
+function getAclConfig(endpoint, options) {
+	return options.acl && endpoint.acl ? getImportedAbilityFunctionName(endpoint, options) : void 0;
+}
+function getInputsConfig(resolver, endpointParameter) {
+	if (!endpointParameter) return;
+	let schema;
+	if (endpointParameter.type === "Body") schema = endpointParameter.bodyObject?.content?.[JSON_APPLICATION_FORMAT]?.schema;
+	else schema = endpointParameter.parameterObject?.schema;
+	if (!schema) return;
+	const schemaObj = resolver.resolveObject(schema);
+	const inputs = Object.keys(schemaObj?.properties ?? {}).reduce((acc, key) => ({
+		...acc,
+		[key]: true
+	}), {});
+	return {
+		schema: getImportedZodSchemaName(resolver, endpointParameter.zodSchema),
+		options: { inputs }
+	};
+}
+function resolveReadAllItemZodSchema(resolver, endpoint, itemSchema, itemsPropertyKey) {
+	if (isReferenceObject(itemSchema)) return resolver.getZodSchemaNameByRef(itemSchema.$ref);
+	if (isNamedZodSchema(endpoint.response)) return `${getImportedZodSchemaName(resolver, endpoint.response)}.shape.${itemsPropertyKey}.element`;
+	return ANY_SCHEMA;
+}
+function getColumnsConfig(resolver, endpoint) {
+	const endpointResponse = endpoint.responseObject;
+	if (!endpointResponse) return;
+	const schema = endpointResponse.content?.[JSON_APPLICATION_FORMAT]?.schema;
+	if (!schema) return;
+	const properties = getSchemaProperties(resolver, schema);
+	const arrayPropertyKeys = Object.keys(properties).filter((key) => resolver.resolveObject(properties[key]).type === "array");
+	arrayPropertyKeys.sort((a, b) => {
+		const aIndex = resolver.options.dataResponseParamNames.indexOf(a);
+		const bIndex = resolver.options.dataResponseParamNames.indexOf(b);
+		if (aIndex !== -1 && bIndex !== -1) return aIndex - bIndex;
+		if (aIndex !== -1) return -1;
+		if (bIndex !== -1) return 1;
+		return a.localeCompare(b);
+	});
+	const propertyKey = arrayPropertyKeys[0];
+	if (!propertyKey) return;
+	const dataSchemaObj = resolver.resolveObject(properties[propertyKey]);
+	if (!dataSchemaObj || dataSchemaObj.type !== "array") return;
+	const itemSchema = dataSchemaObj.items;
+	const itemSchemaObj = resolver.resolveObject(itemSchema);
+	if (!itemSchemaObj) return;
+	const zodSchema = resolveReadAllItemZodSchema(resolver, endpoint, itemSchema, propertyKey);
+	const columns = Object.keys(itemSchemaObj?.properties ?? {}).reduce((acc, key) => ({
+		...acc,
+		[key]: true
+	}), {});
+	const sortableEnumSchemaName = endpoint.parameters.find((param) => param.parameterSortingEnumSchemaName)?.parameterSortingEnumSchemaName;
+	return {
+		columns: {
+			schema: getImportedZodSchemaName(resolver, zodSchema),
+			options: {
+				columns,
+				sortable: sortableEnumSchemaName ? getImportedZodSchemaName(resolver, sortableEnumSchemaName) : void 0
+			}
+		},
+		zodSchema,
+		sortableEnumSchemaName
+	};
+}
+function getSchemaProperties(resolver, schema) {
+	const schemaObj = resolver.resolveObject(schema);
+	if (schemaObj.properties) return schemaObj.properties;
+	else if ("allOf" in schemaObj && schemaObj.allOf) return schemaObj.allOf.reduce((acc, cur) => ({
+		...acc,
+		...getSchemaProperties(resolver, cur)
+	}), {});
+	return {};
+}
+//#endregion
+//#region src/generators/const/queries.const.ts
+const QUERY_HOOKS = {
+	query: "useQuery",
+	infiniteQuery: "useInfiniteQuery",
+	mutation: "useMutation"
+};
+const QUERY_IMPORT = {
+	bindings: [
+		QUERY_HOOKS.query,
+		QUERY_HOOKS.infiniteQuery,
+		QUERY_HOOKS.mutation
+	],
+	from: "@tanstack/react-query"
+};
+const QUERIES_MODULE_NAME = "moduleName";
+//#endregion
+//#region src/generators/generate/generateConfigs.ts
+function generateConfigs(generateTypeParams) {
+	const { configs, hasZodImport, modelsImports, queriesImports, aclImports } = getBuilderConfigs(generateTypeParams);
+	if (configs.length === 0) return;
+	const { resolver, tag } = generateTypeParams;
+	const endpoints = configs.flatMap((config) => [
+		config.create?.mutation,
+		config.update?.mutation,
+		config.delete?.mutation,
+		config.bulkDelete?.mutation
+	]).filter((m) => typeof m !== "string" && m !== void 0);
+	const hasMutation = endpoints.length > 0;
+	const hasAclCheck = resolver.options.checkAcl && endpoints.some((e) => e.acl);
+	const hasMutationEffects = resolver.options.mutationEffects && hasMutation;
+	const hasMutationDefaultOnError = resolver.options.mutationDefaultOnError && hasMutation;
+	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,
+		options: resolver.options
+	});
+	const queryImport = {
+		bindings: [QUERY_HOOKS.mutation],
+		from: "@tanstack/react-query"
+	};
+	const queryTypesImport = {
+		bindings: [...hasMutationDefaultOnError ? ["OpenApiQueryConfig"] : []],
+		typeBindings: [QUERY_OPTIONS_TYPES.mutation],
+		from: getQueryTypesImportPath(resolver.options)
+	};
+	const mutationEffectsImport = {
+		bindings: [MUTATION_EFFECTS.hookName],
+		typeBindings: [MUTATION_EFFECTS.optionsType],
+		from: resolver.options.mutationEffectsImportPath
+	};
+	const queryModulesImport = {
+		bindings: [QUERY_MODULE_ENUM],
+		from: getQueryModulesImportPath(resolver.options)
+	};
+	const aclCheckImport = {
+		bindings: [ACL_CHECK_HOOK],
+		from: resolver.options.aclCheckImportPath
+	};
+	const hasDynamicInputsImport = configs.some((config) => config.readAll.filters || config.create?.inputDefs || config.update?.inputDefs);
+	const dynamicInputsImport = {
+		bindings: [BUILDERS_UTILS.dynamicInputs],
+		from: resolver.options.dynamicInputsImportPath
+	};
+	const hasDynamicColumnsImport = configs.some((config) => config.readAll.columns);
+	const dynamicColumnsImport = {
+		bindings: [BUILDERS_UTILS.dynamicColumns],
+		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));
+		lines.push(renderImport$3(queryTypesImport));
+		if (hasMutationEffects) {
+			lines.push(renderImport$3(queryModulesImport));
+			lines.push(renderImport$3(mutationEffectsImport));
+		}
+		if (hasAclCheck) lines.push(renderImport$3(aclCheckImport));
+	}
+	for (const aclImport of aclImports) lines.push(renderImport$3(aclImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: "configs",
+		tag,
+		options: resolver.options
+	})} {`);
+	for (const config of configs) {
+		lines.push(renderBuilderConfig(config, generateTypeParams));
+		lines.push("");
+	}
+	if (resolver.options.tsNamespaces) lines.push("}");
+	return lines.join("\n").trimEnd() + "\n";
+}
+function renderImport$3(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(", ");
+	return `import${importData.typeOnly ? " type" : ""} ${names} from "${importData.from}";`;
+}
+function renderInputsConfig(inputsConfig) {
+	const lines = [];
+	lines.push("{");
+	lines.push(`  schema: ${inputsConfig.schema},`);
+	lines.push("  options: {");
+	lines.push("    inputs: {");
+	for (const key of Object.keys(inputsConfig.options.inputs)) lines.push(`      ${key}: true,`);
+	lines.push("    },");
+	lines.push("  },");
+	lines.push("}");
+	return lines.join("\n");
+}
+function renderColumnsConfig(columnsConfig) {
+	const lines = [];
+	lines.push("{");
+	lines.push(`  schema: ${columnsConfig.schema},`);
+	lines.push("  options: {");
+	lines.push("    columns: {");
+	for (const key of Object.keys(columnsConfig.options.columns)) lines.push(`      ${key}: true,`);
+	lines.push("    },");
+	if (columnsConfig.options.sortable) lines.push(`    sortable: ${columnsConfig.options.sortable},`);
+	lines.push("  },");
+	lines.push("}");
+	return lines.join("\n");
+}
+function renderMutationContent(resolver, endpoint, tag) {
+	const hasAclCheck = resolver.options.checkAcl && endpoint.acl;
+	const hasMutationEffects = resolver.options.mutationEffects;
+	const hasMutationDefaultOnError = resolver.options.mutationDefaultOnError;
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const endpointTag = getEndpointTag(endpoint, resolver.options);
+	const endpointParams = mapEndpointParamsToFunctionParams(resolver, endpoint, {
+		includeFileParam: true,
+		modelNamespaceTag: endpointTag
+	});
+	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}>${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<${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: ${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 (resData, variables, onMutateResult, context) => {");
+		lines.push("      await runMutationEffects(resData, variables, options);");
+		lines.push("      options?.onSuccess?.(resData, variables, onMutateResult, context);");
+		lines.push("    },");
+	}
+	lines.push("  });");
+	lines.push("}");
+	return lines.map((line) => "        " + line).join("\n").trimStart();
+}
+function renderBuilderConfig(config, params) {
+	const { resolver, tag } = params;
+	const lines = [];
+	lines.push(`export const ${config.name} = {`);
+	lines.push("    meta: {");
+	lines.push(`        title: "${config.title}",`);
+	lines.push("    },");
+	lines.push("    readAll: {");
+	if (config.readAll.acl) lines.push(`        acl: ${config.readAll.acl},`);
+	lines.push(`        schema: ${config.readAll.columns.schema},`);
+	lines.push(`        paginated: ${config.readAll.paginated},`);
+	if (config.readAll.infinite) lines.push(`        infinite: ${config.readAll.infinite},`);
+	if (config.readAll.filters) {
+		lines.push("        filters: {");
+		lines.push(`            schema: ${config.readAll.filters.schema},`);
+		lines.push(`            filterDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.readAll.filters)})`);
+		lines.push("        },");
+	}
+	lines.push(`        columns: ${BUILDERS_UTILS.dynamicColumns}(${renderColumnsConfig(config.readAll.columns)}),`);
+	lines.push("    },");
+	if (config.read) {
+		lines.push("    read: {");
+		if (config.read.acl) lines.push(`        acl: ${config.read.acl},`);
+		lines.push(`        schema: ${config.read.schema},`);
+		lines.push(`        query: ${config.read.query},`);
+		lines.push("    },");
+	}
+	if (config.create) {
+		lines.push("    create: {");
+		if (config.create.acl) lines.push(`        acl: ${config.create.acl},`);
+		if (config.create.schema) lines.push(`        schema: ${config.create.schema},`);
+		lines.push(`        mutation: ${typeof config.create.mutation === "string" ? config.create.mutation : renderMutationContent(resolver, config.create.mutation, tag)},`);
+		if (config.create.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.create.inputDefs)})`);
+		lines.push("    },");
+	}
+	if (config.update) {
+		lines.push("    update: {");
+		if (config.update.acl) lines.push(`        acl: ${config.update.acl},`);
+		if (config.update.schema) lines.push(`        schema: ${config.update.schema},`);
+		lines.push(`        mutation: ${typeof config.update.mutation === "string" ? config.update.mutation : renderMutationContent(resolver, config.update.mutation, tag)},`);
+		if (config.update.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.update.inputDefs)})`);
+		lines.push("    },");
+	}
+	if (config.delete) {
+		lines.push("    delete: {");
+		if (config.delete.acl) lines.push(`        acl: ${config.delete.acl},`);
+		lines.push(`        mutation: ${typeof config.delete.mutation === "string" ? config.delete.mutation : renderMutationContent(resolver, config.delete.mutation, tag)},`);
+		lines.push("    },");
+	}
+	if (config.bulkDelete) {
+		lines.push("    bulkDelete: {");
+		if (config.bulkDelete.acl) lines.push(`        acl: ${config.bulkDelete.acl},`);
+		if (config.bulkDelete.schema) lines.push(`        schema: ${config.bulkDelete.schema},`);
+		lines.push(`        mutation: ${typeof config.bulkDelete.mutation === "string" ? config.bulkDelete.mutation : renderMutationContent(resolver, config.bulkDelete.mutation, tag)},`);
+		if (config.bulkDelete.inputDefs) lines.push(`        inputDefs: ${BUILDERS_UTILS.dynamicInputs}(${renderInputsConfig(config.bulkDelete.inputDefs)})`);
+		lines.push("    },");
+	}
+	lines.push("};");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/generators/generate/generateEndpoints.ts
+function generateEndpoints({ resolver, data, tag }) {
+	const nativeContent = resolver.getNativeRenderedEndpoints?.(tag);
+	if (nativeContent) return nativeContent;
+	if (shouldInlineEndpointsForTag(tag, resolver.options)) return;
+	const endpoints = data.get(tag)?.endpoints;
+	if (!endpoints || endpoints.length === 0) return;
+	const appRestClientImport = {
+		bindings: [APP_REST_CLIENT_NAME],
+		from: getAppRestClientImportPath(resolver.options)
+	};
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const hasGetEndpoints = endpoints.some((endpoint) => endpoint.method === "get");
+	const hasAxiosImport = hasAxiosRequestConfig || hasGetEndpoints;
+	const axiosImport = {
+		bindings: [],
+		typeBindings: hasAxiosImport ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
+		from: AXIOS_IMPORT.from
+	};
+	const generateParse = resolver.options.parseRequestParams;
+	const endpointParams = endpoints.flatMap((endpoint) => endpoint.parameters);
+	const endpointParamsParseSchemas = endpointParams.filter((param) => !["Path", "Header"].includes(param.type)).map((param) => param.parameterSortingEnumSchemaName ?? param.zodSchema);
+	const endpointResponseSchemas = endpoints.map((endpoint) => endpoint.response);
+	const zodSchemas = getUniqueArray([...endpointResponseSchemas, ...generateParse ? endpointParamsParseSchemas : []]);
+	const hasZodImport = zodSchemas.some((schema) => !isNamedZodSchema(schema));
+	const hasZodExtendedImport = resolver.options.parseRequestParams && endpointParamsParseSchemas.length > 0;
+	const zodExtendedImport = {
+		bindings: [ZOD_EXTENDED.namespace],
+		from: resolver.options.zodImportPath
+	};
+	const modelsImports = getModelsImports({
+		resolver,
+		tag,
+		zodSchemas: zodSchemas.filter(isNamedZodSchema),
+		zodSchemasAsTypes: getUniqueArray(endpointParams.map((param) => param.zodSchema).filter(isNamedZodSchema))
+	});
+	const lines = [];
+	lines.push(renderImport$2(appRestClientImport));
+	if (hasAxiosImport) lines.push(renderImport$2(axiosImport));
+	if (hasZodImport) lines.push(renderImport$2(ZOD_IMPORT));
+	if (hasZodExtendedImport) lines.push(renderImport$2(zodExtendedImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$2(modelsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: "endpoints",
+		tag,
+		options: resolver.options
+	})} {`);
+	for (const endpoint of endpoints) {
+		const endpointParamOptions = { modelNamespaceTag: tag };
+		const endpointParams = renderEndpointParams$1(resolver, endpoint, endpointParamOptions);
+		renderEndpointArgs$1(resolver, endpoint, endpointParamOptions);
+		const endpointBody = getEndpointBody(endpoint);
+		const hasUndefinedEndpointBody = requiresBody(endpoint) && !endpointBody && hasEndpointConfig(endpoint, resolver);
+		const endpointConfig = renderEndpointConfig(resolver, endpoint, tag);
+		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(`        ${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,");
+		lines.push(`        ${endpointConfig}`);
+		lines.push("    )");
+		lines.push("};");
+	}
+	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(", ");
+	return `import${importData.typeOnly ? " type" : ""} ${names} from "${importData.from}";`;
+}
+function renderEndpointParams$1(resolver, endpoint, options) {
+	return mapEndpointParamsToFunctionParams(resolver, endpoint, options).map((param) => `${param.name}${param.required ? "" : "?"}: ${param.type}, `).join("");
+}
+function renderEndpointArgs$1(resolver, endpoint, options) {
+	return mapEndpointParamsToFunctionParams(resolver, endpoint, options).map((param) => param.name).join(", ");
+}
+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)})${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 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 (hasRequestConfigParam) lines.push(`    ...${AXIOS_REQUEST_CONFIG_NAME},`);
+	if (endpointConfig.params) {
+		lines.push("    params: {");
+		for (const param of endpointConfig.params) {
+			const value = resolver.options.parseRequestParams ? renderEndpointParamParse(resolver, param, param.value, modelNamespaceTag) : param.value;
+			lines.push(`        ${param.name}: ${value},`);
+		}
+		lines.push("    },");
+	}
+	if (endpointConfig.headers) {
+		lines.push("    headers: {");
+		for (const [key, value] of Object.entries(endpointConfig.headers)) lines.push(`        '${key}': ${value},`);
+		lines.push("    },");
+	}
+	if (endpoint.response === "z.instanceof(Blob)") lines.push("    responseType: \"blob\",");
+	if (endpoint.mediaDownload) lines.push("    rawResponse: true,");
+	lines.push("}");
+	return lines.join("\n        ");
+}
+//#endregion
+//#region src/generators/generate/generateModels.ts
+function generateModels({ resolver, data, tag }) {
+	const nativeContent = resolver.getNativeRenderedModels?.(tag);
+	if (nativeContent) return nativeContent;
+	if (resolver.options.modelsInCommon && resolver.options.splitByTags && tag !== resolver.options.defaultTag) return renderModelsProxy({
+		resolver,
+		data,
+		tag
+	});
+	const zodSchemas = data.get(tag)?.zodSchemas;
+	if (!zodSchemas || Object.keys(zodSchemas).length === 0) return;
+	const refZodSchemas = [];
+	for (const zodSchema of Object.keys(zodSchemas)) {
+		const refs = getZodSchemaRefs(resolver, zodSchema);
+		for (const ref of refs) if (!zodSchemas[ref]) refZodSchemas.push(ref);
+	}
+	const modelsImports = getModelsImports({
+		resolver,
+		tag,
+		zodSchemas: refZodSchemas
+	});
+	const zodSchemasData = {};
+	for (const [key, code] of Object.entries(zodSchemas)) {
+		const schemaRef = resolver.getRefByZodSchemaName(key);
+		zodSchemasData[key] = {
+			code,
+			isCiruclar: schemaRef ? resolver.isSchemaCircular(schemaRef) : false,
+			isEnum: isEnumZodSchema(code),
+			schemaObj: resolver.getZodSchemaObj(key)
+		};
+	}
+	const lines = [];
+	lines.push(renderImport$1(ZOD_IMPORT));
+	for (const modelsImport of modelsImports) lines.push(renderImport$1(modelsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: "models",
+		tag,
+		options: resolver.options
+	})} {`);
+	for (const [name, zodSchema] of Object.entries(zodSchemasData)) {
+		lines.push(renderModelJsDocs({
+			name,
+			zodSchema,
+			tag,
+			resolver
+		}));
+		lines.push(`export const ${name} = ${zodSchema.code};`);
+		lines.push(`export type ${getZodSchemaInferedTypeName(name, resolver.options)} = z.infer<typeof ${name}>;`);
+		if (zodSchema.isEnum) lines.push(`export const ${getZodSchemaInferedTypeName(name, resolver.options)} = ${name}.enum;`);
+		lines.push("");
+	}
+	if (resolver.options.tsNamespaces) lines.push("}");
+	return lines.join("\n").trimEnd() + "\n";
+}
+function renderModelsProxy({ resolver, data, tag }) {
+	const commonZodSchemas = data.get(resolver.options.defaultTag)?.zodSchemas ?? {};
+	const schemaNames = getUsedSchemaNames({
+		resolver,
+		endpoints: data.get(tag)?.endpoints ?? []
+	}).filter((schemaName) => Boolean(commonZodSchemas[schemaName]));
+	if (schemaNames.length === 0) return;
+	const modelsNamespace = getNamespaceName({
+		type: "models",
+		tag,
+		options: resolver.options
+	});
+	const commonNamespace = getNamespaceName({
+		type: "models",
+		tag: resolver.options.defaultTag,
+		options: resolver.options
+	});
+	const commonModelsPath = `${getImportPath(resolver.options)}${getTagImportPath({
+		type: "models",
+		tag: resolver.options.defaultTag,
+		includeTagDir: true,
+		options: resolver.options
+	})}`;
+	const inferredTypeNames = schemaNames.map((schemaName) => getZodSchemaInferedTypeName(schemaName, resolver.options));
+	const enumInferredTypeNames = schemaNames.filter((schemaName) => isEnumZodSchema(commonZodSchemas[schemaName] ?? "")).map((schemaName) => getZodSchemaInferedTypeName(schemaName, resolver.options));
+	if (resolver.options.tsNamespaces) {
+		const lines = [];
+		lines.push(`import { ${commonNamespace} } from "${commonModelsPath}";`);
+		lines.push("");
+		lines.push(`export namespace ${modelsNamespace} {`);
+		for (const schemaName of schemaNames) lines.push(`  export const ${schemaName} = ${commonNamespace}.${schemaName};`);
+		for (const typeName of inferredTypeNames) lines.push(`  export type ${typeName} = ${commonNamespace}.${typeName};`);
+		for (const enumName of enumInferredTypeNames) lines.push(`  export const ${enumName} = ${commonNamespace}.${enumName};`);
+		lines.push("}");
+		lines.push("");
+		return lines.join("\n");
+	}
+	const valueExports = getUniqueArray([...schemaNames, ...enumInferredTypeNames]);
+	const lines = [];
+	if (valueExports.length > 0) lines.push(`export { ${valueExports.join(", ")} } from "${commonModelsPath}";`);
+	if (inferredTypeNames.length > 0) lines.push(`export type { ${inferredTypeNames.join(", ")} } from "${commonModelsPath}";`);
+	return lines.join("\n") + "\n";
+}
+function getUsedSchemaNames({ resolver, endpoints }) {
+	const usedSchemaNames = /* @__PURE__ */ new Set();
+	const queue = [];
+	const enqueue = (schemaName) => {
+		if (!schemaName || !isNamedZodSchema(schemaName) || usedSchemaNames.has(schemaName)) return;
+		usedSchemaNames.add(schemaName);
+		queue.push(schemaName);
+	};
+	for (const endpoint of endpoints) {
+		enqueue(endpoint.response);
+		for (const error of endpoint.errors) enqueue(error.zodSchema);
+		for (const param of endpoint.parameters) {
+			enqueue(param.zodSchema);
+			enqueue(param.parameterSortingEnumSchemaName);
+		}
+	}
+	let queueIndex = 0;
+	while (queueIndex < queue.length) {
+		const schemaName = queue[queueIndex++];
+		if (!schemaName) continue;
+		const refs = getZodSchemaRefs(resolver, schemaName);
+		for (const ref of refs) enqueue(ref);
+	}
+	return Array.from(usedSchemaNames);
+}
+function renderImport$1(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(", ");
+	return `import${importData.typeOnly ? " type" : ""} ${names} from "${importData.from}";`;
+}
+function renderModelJsDocs({ name, zodSchema, tag, resolver }) {
+	const lines = [
+		`/** `,
+		` * ${name} `,
+		` * @type { ${getZodSchemaType(zodSchema)} }`
+	];
+	const description = getZodSchemaDescription(zodSchema);
+	if (description) lines.push(` * @description ${description.replace(/\n/g, "\n *")}`);
+	const propertyDescriptions = getZodSchemaPropertyDescriptions(resolver, zodSchema, tag);
+	if (propertyDescriptions) for (const [property, info] of Object.entries(propertyDescriptions)) lines.push(` * @property { ${info.type} } ${property} ${info.description.replace(/\n/g, "\n *")} `);
+	lines.push(" */");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/generators/generate/generateQueries.ts
+const endpointParamMappingCache = /* @__PURE__ */ new WeakMap();
+const workspaceParamNamesCache = /* @__PURE__ */ new WeakMap();
+const endpointParamDescriptionCache = /* @__PURE__ */ new WeakMap();
+function generateQueries(params) {
+	const { resolver, data, tag } = params;
+	const nativeContent = resolver.getNativeRenderedQueries?.(tag);
+	if (nativeContent) return nativeContent;
+	const mutationScopeOption = resolver.options.mutationScope;
+	if (mutationScopeOption && typeof mutationScopeOption === "object") {
+		if ("include" in mutationScopeOption && "exclude" in mutationScopeOption) throw new Error("mutationScope cannot specify both 'include' and 'exclude'");
+	}
+	const inlineEndpoints = shouldInlineEndpointsForTag(tag, resolver.options);
+	const endpoints = data.get(tag)?.endpoints;
+	if (!endpoints || endpoints.length === 0) return;
+	const endpointGroups = groupEndpoints(endpoints, resolver);
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const hasAxiosDefaultImport = endpoints.some(({ mediaUpload }) => mediaUpload);
+	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: hasAxiosImport ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
+		from: AXIOS_IMPORT.from
+	};
+	const { queryEndpoints, infiniteQueryEndpoints, mutationEndpoints, aclEndpoints } = endpointGroups;
+	const hasMutationDefaultOnError = resolver.options.mutationDefaultOnError && mutationEndpoints.length > 0;
+	const queryImport = {
+		bindings: [
+			...resolver.options.prefetchQueries && queryEndpoints.length > 0 ? ["QueryClient"] : [],
+			...queryEndpoints.length > 0 ? [QUERY_HOOKS.query] : [],
+			...resolver.options.infiniteQueries && infiniteQueryEndpoints.length > 0 ? [QUERY_HOOKS.infiniteQuery] : [],
+			...mutationEndpoints.length > 0 ? [QUERY_HOOKS.mutation] : []
+		],
+		from: QUERY_IMPORT.from
+	};
+	const hasMutationEffects = resolver.options.mutationEffects;
+	const queryModulesImport = {
+		bindings: [QUERY_MODULE_ENUM],
+		from: getQueryModulesImportPath(resolver.options)
+	};
+	const hasMutationEffectsImport = hasMutationEffects && mutationEndpoints.length > 0;
+	const mutationEffectsImport = {
+		bindings: [...mutationEndpoints.length > 0 ? [MUTATION_EFFECTS.hookName] : []],
+		typeBindings: [...mutationEndpoints.length > 0 ? [MUTATION_EFFECTS.optionsType] : []],
+		from: resolver.options.mutationEffectsImportPath
+	};
+	const hasAclCheck = resolver.options.checkAcl && aclEndpoints.length > 0;
+	const aclCheckImport = {
+		bindings: [ACL_CHECK_HOOK],
+		from: resolver.options.aclCheckImportPath
+	};
+	const queryTypesImport = {
+		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] : [],
+			...mutationEndpoints.length > 0 ? [QUERY_OPTIONS_TYPES.mutation] : []
+		],
+		from: getQueryTypesImportPath(resolver.options)
+	};
+	const hasWorkspaceContext = resolver.options.workspaceContext && endpoints.some((endpoint) => getWorkspaceParamNames(resolver, endpoint).length > 0);
+	const workspaceContextImport = {
+		bindings: ["useWorkspaceContext"],
+		from: PACKAGE_IMPORT_PATH
+	};
+	const endpointParams = endpoints.flatMap((endpoint) => endpoint.parameters);
+	const endpointParamsParseSchemas = endpointParams.filter((param) => !["Path", "Header"].includes(param.type)).map((param) => param.parameterSortingEnumSchemaName ?? param.zodSchema);
+	const endpointResponseSchemas = endpoints.map((endpoint) => endpoint.response);
+	const endpointRuntimeSchemas = getUniqueArray([...endpointResponseSchemas, ...resolver.options.parseRequestParams ? endpointParamsParseSchemas : []]);
+	const hasZodImport = inlineEndpoints && endpointRuntimeSchemas.some((schema) => !isNamedZodSchema(schema));
+	const hasZodExtendedImport = inlineEndpoints && resolver.options.parseRequestParams && endpointParamsParseSchemas.length > 0;
+	const appRestClientImport = {
+		bindings: [APP_REST_CLIENT_NAME],
+		from: getAppRestClientImportPath(resolver.options)
+	};
+	const zodExtendedImport = {
+		bindings: [ZOD_EXTENDED.namespace],
+		from: resolver.options.zodImportPath
+	};
+	const modelsImports = getModelsImports({
+		resolver,
+		tag,
+		zodSchemas: inlineEndpoints ? endpointRuntimeSchemas.filter(isNamedZodSchema) : [],
+		zodSchemasAsTypes: getUniqueArray(endpointParams.map((param) => param.zodSchema).filter(isNamedZodSchema))
+	});
+	const endpointsImports = inlineEndpoints ? [] : getEndpointsImports({
+		tag,
+		endpoints,
+		options: resolver.options
+	});
+	const aclImports = getAclImports({
+		tag,
+		endpoints: aclEndpoints,
+		options: resolver.options
+	});
+	const namespace = getNamespaceName({
+		type: "queries",
+		tag,
+		options: resolver.options
+	});
+	const lines = [];
+	if (hasAxiosImport) lines.push(renderImport(axiosImport));
+	if (inlineEndpoints) {
+		lines.push(renderImport(appRestClientImport));
+		if (hasZodImport) lines.push(renderImport(ZOD_IMPORT));
+		if (hasZodExtendedImport) lines.push(renderImport(zodExtendedImport));
+	}
+	lines.push(renderImport(queryImport));
+	if (hasMutationEffects) lines.push(renderImport(queryModulesImport));
+	if (hasMutationEffectsImport) lines.push(renderImport(mutationEffectsImport));
+	if (hasAclCheck) {
+		lines.push(renderImport(aclCheckImport));
+		for (const aclImport of aclImports) lines.push(renderImport(aclImport));
+	}
+	lines.push(renderImport(queryTypesImport));
+	if (hasWorkspaceContext) lines.push(renderImport(workspaceContextImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport(modelsImport));
+	for (const endpointsImport of endpointsImports) lines.push(renderImport(endpointsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${namespace} {`);
+	if (inlineEndpoints) {
+		lines.push(...renderInlineEndpoints({
+			resolver,
+			endpoints,
+			tag
+		}));
+		lines.push("");
+	}
+	lines.push(`export const ${QUERIES_MODULE_NAME} = ${hasMutationEffects ? `${QUERY_MODULE_ENUM}.${tag}` : `"${namespace}"`};`);
+	lines.push("");
+	lines.push(renderQueryKeys({
+		resolver,
+		queryEndpoints,
+		tag
+	}));
+	lines.push("");
+	for (const endpoint of endpoints) {
+		const endpointInfo = endpointGroups.infoByEndpoint.get(endpoint);
+		if (endpointInfo?.query) {
+			lines.push(renderQueryOptions({
+				resolver,
+				endpoint,
+				inlineEndpoints
+			}));
+			lines.push("");
+			lines.push(renderQuery({
+				resolver,
+				endpoint,
+				inlineEndpoints
+			}));
+			lines.push("");
+			if (resolver.options.prefetchQueries) {
+				lines.push(renderPrefetchQuery({
+					resolver,
+					endpoint
+				}));
+				lines.push("");
+			}
+		}
+		if (endpointInfo?.mutation) {
+			lines.push(renderMutation({
+				resolver,
+				endpoint,
+				inlineEndpoints,
+				precomputed: endpointGroups.mutationDataByEndpoint.get(endpoint)
+			}));
+			lines.push("");
+		}
+		if (endpointInfo?.infiniteQuery) {
+			lines.push(renderInfiniteQueryOptions({
+				resolver,
+				endpoint,
+				inlineEndpoints
+			}));
+			lines.push("");
+			lines.push(renderInfiniteQuery({
+				resolver,
+				endpoint,
+				inlineEndpoints
+			}));
+			lines.push("");
+			if (resolver.options.prefetchQueries) {
+				lines.push(renderPrefetchInfiniteQuery({
+					resolver,
+					endpoint
+				}));
+				lines.push("");
+			}
+		}
+	}
+	if (resolver.options.tsNamespaces) lines.push("}");
+	return lines.join("\n").trimEnd() + "\n";
+}
+function getEndpointParamMapping(resolver, endpoint, options) {
+	let resolverCache = endpointParamMappingCache.get(resolver);
+	if (!resolverCache) {
+		resolverCache = /* @__PURE__ */ new WeakMap();
+		endpointParamMappingCache.set(resolver, resolverCache);
+	}
+	let endpointCache = resolverCache.get(endpoint);
+	if (!endpointCache) {
+		endpointCache = /* @__PURE__ */ new Map();
+		resolverCache.set(endpoint, endpointCache);
+	}
+	const key = JSON.stringify([
+		options?.excludeBodyParam,
+		options?.excludePageParam,
+		options?.replacePageParam,
+		options?.includeFileParam,
+		options?.includeOnlyRequiredParams,
+		options?.pathParamsRequiredOnly,
+		options?.optionalPathParams,
+		options?.modelNamespaceTag,
+		options?.excludePathParams
+	]);
+	const cached = endpointCache.get(key);
+	if (cached) return cached;
+	const computed = mapEndpointParamsToFunctionParams(resolver, endpoint, options);
+	endpointCache.set(key, computed);
+	return computed;
+}
+function getWorkspaceContextAllowList(workspaceContext) {
+	return new Set(workspaceContext);
+}
+function renderImport(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(", ");
+	return `import${importData.typeOnly ? " type" : ""} ${names} from "${importData.from}";`;
+}
+function renderEndpointParams(resolver, endpoint, options) {
+	return getEndpointParamMapping(resolver, endpoint, options).map((param) => `${param.name}${param.required ? "" : "?"}: ${param.type}`).join(", ");
+}
+function renderEndpointArgs(resolver, endpoint, options, replacements) {
+	return getEndpointParamMapping(resolver, endpoint, options).map((param) => replacements?.[param.name] ?? param.name).join(", ");
+}
+function renderEndpointObjectArgs(resolver, endpoint, options, replacements) {
+	return getEndpointParamMapping(resolver, endpoint, options).map((param) => {
+		const replacement = replacements?.[param.name];
+		return replacement && replacement !== param.name ? `${param.name}: ${replacement}` : param.name;
+	}).join(", ");
+}
+function renderEndpointParamDescription(endpointParam) {
+	const cached = endpointParamDescriptionCache.get(endpointParam);
+	if (cached !== void 0) return cached;
+	const strs = [`${endpointParam.paramType} parameter`];
+	const description = endpointParam.parameterObject?.description || endpointParam.bodyObject?.description;
+	if (description) strs.push(description);
+	let schema = void 0;
+	let mediaTypeObject = void 0;
+	if (endpointParam.parameterObject?.schema && isSchemaObject(endpointParam.parameterObject.schema)) schema = endpointParam.parameterObject?.schema;
+	if (endpointParam.bodyObject?.content) {
+		const matchingMediaType = Object.keys(endpointParam.bodyObject.content ?? {}).find(isParamMediaTypeAllowed);
+		if (matchingMediaType) {
+			mediaTypeObject = endpointParam.bodyObject.content[matchingMediaType];
+			if (mediaTypeObject.schema && isSchemaObject(mediaTypeObject.schema)) schema = mediaTypeObject.schema;
+		}
+	}
+	if (schema) strs.push(...getSchemaDescriptions(schema));
+	if (mediaTypeObject?.example) strs.push(`Example: \`${mediaTypeObject.example}\``);
+	const renderedDescription = strs.join(". ");
+	endpointParamDescriptionCache.set(endpointParam, renderedDescription);
+	return renderedDescription;
+}
+function getWorkspaceParamNames(resolver, endpoint) {
+	let resolverCache = workspaceParamNamesCache.get(resolver);
+	if (!resolverCache) {
+		resolverCache = /* @__PURE__ */ new WeakMap();
+		workspaceParamNamesCache.set(resolver, resolverCache);
+	}
+	const cached = resolverCache.get(endpoint);
+	if (cached) return cached;
+	const allowList = getWorkspaceContextAllowList(resolver.options.workspaceContext);
+	const endpointParams = getEndpointParamMapping(resolver, endpoint, {});
+	const endpointParamNames = new Set(endpointParams.map((param) => param.name));
+	const workspaceParamNames = endpointParams.filter((param) => param.paramType === "Path").map((param) => param.name);
+	const aclParamNames = (getAbilityConditionsTypes(endpoint) ?? []).map((condition) => invalidVariableNameCharactersToCamel(condition.name)).filter((name) => endpointParamNames.has(name));
+	const names = getUniqueArray([...workspaceParamNames, ...aclParamNames]).filter((name) => allowList.has(name));
+	resolverCache.set(endpoint, names);
+	return names;
+}
+function getWorkspaceParamReplacements(resolver, endpoint) {
+	return Object.fromEntries(getWorkspaceParamNames(resolver, endpoint).map((name) => [name, `normalize${capitalize(name)}`]));
+}
+function getWorkspaceParamTypes(resolver, endpoint, modelNamespaceTag) {
+	const workspaceParamNames = new Set(getWorkspaceParamNames(resolver, endpoint));
+	return Object.fromEntries(getEndpointParamMapping(resolver, endpoint, { modelNamespaceTag }).filter((param) => workspaceParamNames.has(param.name)).map((param) => [param.name, param.type]));
+}
+function renderWorkspaceContextDestructure({ replacements, paramTypes, indent }) {
+	const workspaceParamNames = Object.keys(replacements);
+	if (workspaceParamNames.length === 0) return [];
+	const workspaceParamBindings = workspaceParamNames.map((paramName) => `${paramName}: ${paramName}Workspace`);
+	const workspaceContextType = workspaceParamNames.map((paramName) => `${paramName}?: ${paramTypes[paramName] ?? "unknown"}`).join("; ");
+	return [`${indent}const { ${workspaceParamBindings.join(", ")} } = useWorkspaceContext<{ ${workspaceContextType} }>();`];
+}
+function renderWorkspaceParamCoalescing({ replacements, indent }) {
+	const workspaceParamNames = Object.keys(replacements);
+	const lines = [];
+	for (const paramName of workspaceParamNames) {
+		lines.push(`${indent}const ${replacements[paramName]} = ${paramName} ?? ${paramName}Workspace;`);
+		lines.push(`${indent}if (!${replacements[paramName]}) {`);
+		lines.push(`${indent}  throw Error(\`${capitalize(paramName)} not provided\`);`);
+		lines.push(`${indent}}`);
+	}
+	return lines;
+}
+function renderWorkspaceParamResolutions({ replacements, paramTypes, indent }) {
+	return [...renderWorkspaceContextDestructure({
+		replacements,
+		paramTypes,
+		indent
+	}), ...renderWorkspaceParamCoalescing({
+		replacements,
+		indent
+	})];
+}
+function addAsteriskAfterNewLine(str) {
+	return str.replace(/\n/g, "\n *");
+}
+function renderQueryJsDocs({ resolver, endpoint, mode, tag }) {
+	const lines = ["/** "];
+	if (mode === "infiniteQuery") lines.push(` * Infinite query \`${getInfiniteQueryName(endpoint)}${endpoint.summary ? "" : ""}`);
+	else if (mode === "query") lines.push(` * Query \`${getQueryName(endpoint)}\`${endpoint.summary && endpoint.mediaDownload ? " - recommended when file should be cached" : ""}`);
+	else lines.push(` * Mutation \`${getQueryName(endpoint, true)}\`${endpoint.summary && endpoint.mediaDownload ? " - recommended when file should not be cached" : ""}`);
+	if (endpoint.summary) lines.push(` * @summary ${addAsteriskAfterNewLine(endpoint.summary)}`);
+	if (endpoint.description) lines.push(` * @description ${addAsteriskAfterNewLine(endpoint.description)}`);
+	if (endpoint.acl) lines.push(` * @permission Requires \`${getAbilityFunctionName(endpoint)}\` ability `);
+	const params = getEndpointParamMapping(resolver, endpoint, {
+		...mode !== "infiniteQuery" ? { includeFileParam: true } : {},
+		modelNamespaceTag: tag
+	});
+	for (const endpointParam of params) lines.push(` * @param { ${endpointParam.type} } ${endpointParam.name} ${renderEndpointParamDescription(endpointParam)}`);
+	if (mode === "query") lines.push(" * @param { AppQueryOptions } options Query options");
+	else if (mode === "mutation") lines.push(` * @param { AppMutationOptions${resolver.options.mutationEffects ? ` & ${MUTATION_EFFECTS.optionsType}` : ""} } options Mutation options`);
+	else lines.push(" * @param { AppInfiniteQueryOptions } options Infinite query options");
+	const withAxiosResponse = endpoint.mediaDownload && mode !== "infiniteQuery";
+	const resultType = `${withAxiosResponse ? "AxiosResponse<" : ""}${getImportedZodSchemaInferedTypeName(resolver, endpoint.response, void 0, tag)}${withAxiosResponse ? ">" : ""}`;
+	if (mode === "query") lines.push(` * @returns { UseQueryResult<${resultType}> } ${endpoint.responseDescription ?? ""}`);
+	else if (mode === "mutation") lines.push(` * @returns { UseMutationResult<${resultType}> } ${endpoint.responseDescription ?? ""}`);
+	else lines.push(` * @returns { UseInfiniteQueryResult<${resultType}> } ${endpoint.responseDescription ?? ""}`);
+	lines.push(` * @statusCodes [${endpoint.responseStatusCodes.join(", ")}]`);
+	lines.push(" */");
+	return lines.join("\n");
+}
+function renderQueryKeys({ resolver, queryEndpoints, tag }) {
+	if (queryEndpoints.length === 0) return "";
+	const lines = [];
+	lines.push("export const keys = {");
+	lines.push(`    all: [${QUERIES_MODULE_NAME}] as const,`);
+	for (const endpoint of queryEndpoints) {
+		lines.push(`    ${getEndpointName(endpoint)}: (${renderEndpointParams(resolver, endpoint, {
+			pathParamsRequiredOnly: true,
+			modelNamespaceTag: tag
+		})}) => [...keys.all, "${endpoint.path}", ${renderEndpointArgs(resolver, endpoint, {})}] as const,`);
+		if (resolver.options.infiniteQueries && isInfiniteQuery(endpoint, resolver.options)) lines.push(`    ${getEndpointName(endpoint)}Infinite: (${renderEndpointParams(resolver, endpoint, {
+			excludePageParam: true,
+			pathParamsRequiredOnly: true,
+			modelNamespaceTag: tag
+		})}) => [...keys.all, "${endpoint.path}", "infinite", ${renderEndpointArgs(resolver, endpoint, { excludePageParam: true })}] as const,`);
+	}
+	lines.push("};");
+	return lines.join("\n");
+}
+function renderInlineEndpoints({ resolver, endpoints, tag }) {
+	const lines = [];
+	for (const endpoint of endpoints) {
+		const endpointParams = renderEndpointParams(resolver, endpoint, { modelNamespaceTag: tag });
+		const endpointBody = getEndpointBody(endpoint);
+		const hasUndefinedEndpointBody = requiresBody(endpoint) && !endpointBody && hasEndpointConfig(endpoint, resolver);
+		const endpointConfig = renderInlineEndpointConfig(resolver, endpoint, tag);
+		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(`    ${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,");
+		lines.push(`    ${endpointConfig}`);
+		lines.push("  );");
+		lines.push("};");
+		lines.push("");
+	}
+	return lines;
+}
+function renderInlineRequestInfo(resolver, endpoint, tag) {
+	return `{ resSchema: ${getImportedZodSchemaName(resolver, endpoint.response, tag)} }`;
+}
+function getRequestConfigType() {
+	return `${AXIOS_REQUEST_CONFIG_TYPE} & { allowInvalidResponseData?: boolean }`;
+}
+function renderRequestConfigWithSignal(hasRequestConfigParam) {
+	return `{ ${hasRequestConfigParam ? `...${AXIOS_REQUEST_CONFIG_NAME}, ` : ""}signal }`;
+}
+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)})${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 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 (hasRequestConfigParam) lines.push(`      ...${AXIOS_REQUEST_CONFIG_NAME},`);
+	if (endpointConfig.params) {
+		lines.push("      params: {");
+		for (const param of endpointConfig.params) {
+			const value = resolver.options.parseRequestParams ? renderInlineEndpointParamParse(resolver, param, param.value, modelNamespaceTag) : param.value;
+			lines.push(`        ${param.name}: ${value},`);
+		}
+		lines.push("      },");
+	}
+	if (endpointConfig.headers) {
+		lines.push("      headers: {");
+		for (const [key, value] of Object.entries(endpointConfig.headers)) lines.push(`        '${key}': ${value},`);
+		lines.push("      },");
+	}
+	if (endpoint.response === "z.instanceof(Blob)") lines.push("      responseType: \"blob\",");
+	if (endpoint.mediaDownload) lines.push("      rawResponse: true,");
+	lines.push("    }");
+	return lines.join("\n");
+}
+function renderQueryOptions({ resolver, endpoint, inlineEndpoints }) {
+	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} }` : ""}${hasRequestConfigParam ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}?: ${getRequestConfigType()}` : ""}) => ({`);
+	lines.push(`  queryKey: keys.${getEndpointName(endpoint)}(${endpointArgs}),`);
+	const requestConfigWithSignal = renderRequestConfigWithSignal(hasRequestConfigParam);
+	lines.push(`  queryFn: ({ signal }: { signal: AbortSignal }) => ${endpointFunction}(${endpointArgs}${hasRequestConfigParam ? `${endpointArgs ? ", " : ""}${requestConfigWithSignal}` : ""}),`);
+	lines.push("});");
+	return lines.join("\n");
+}
+function renderInfiniteQueryOptions({ resolver, endpoint, inlineEndpoints }) {
+	const hasRequestConfigParam = resolver.options.axiosRequestConfig || endpoint.method === "get";
+	const endpointParams = renderEndpointParams(resolver, endpoint, {
+		excludePageParam: true,
+		modelNamespaceTag: getEndpointTag(endpoint, resolver.options)
+	});
+	const endpointArgsWithoutPage = renderEndpointArgs(resolver, endpoint, { excludePageParam: true });
+	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} }` : ""}${hasRequestConfigParam ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}?: ${getRequestConfigType()}` : ""}) => ({`);
+	lines.push(`  queryKey: keys.${getEndpointName(endpoint)}Infinite(${endpointArgsWithoutPage}),`);
+	const requestConfigWithSignal = renderRequestConfigWithSignal(hasRequestConfigParam);
+	lines.push(`  queryFn: ({ pageParam, signal }: { pageParam: number; signal: AbortSignal }) => ${endpointFunction}(${endpointArgsWithPage}${hasRequestConfigParam ? `, ${requestConfigWithSignal}` : ""}),`);
+	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} ?? 0) ? pageParam + 1 : null;`);
+	lines.push("  },");
+	lines.push("});");
+	return lines.join("\n");
+}
+function renderPrefetchQuery({ resolver, endpoint }) {
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const endpointParams = renderEndpointParams(resolver, endpoint, { modelNamespaceTag: getEndpointTag(endpoint, resolver.options) });
+	const endpointArgs = renderEndpointArgs(resolver, endpoint, {});
+	const lines = [];
+	lines.push(`export const ${getPrefetchQueryName(endpoint)} = (queryClient: QueryClient, ${endpointParams ? `{ ${endpointArgs} }: { ${endpointParams} }, ` : ""}${hasAxiosRequestConfig ? `${AXIOS_REQUEST_CONFIG_NAME}: ${AXIOS_REQUEST_CONFIG_TYPE}, ` : ""}options?: Omit<Parameters<QueryClient["prefetchQuery"]>[0], "queryKey" | "queryFn">) => {`);
+	lines.push(`  return queryClient.prefetchQuery({ ...${getQueryOptionsName(endpoint)}(${endpointParams ? `{ ${endpointArgs} }` : ""}${hasAxiosRequestConfig ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""}), ...options });`);
+	lines.push("};");
+	return lines.join("\n");
+}
+function renderPrefetchInfiniteQuery({ resolver, endpoint }) {
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const endpointParams = renderEndpointParams(resolver, endpoint, {
+		excludePageParam: true,
+		modelNamespaceTag: getEndpointTag(endpoint, resolver.options)
+	});
+	const endpointArgs = renderEndpointArgs(resolver, endpoint, { excludePageParam: true });
+	const optionsArgs = `${endpointParams ? `{ ${endpointArgs} }` : ""}${hasAxiosRequestConfig ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""}`;
+	const lines = [];
+	lines.push(`export const ${getPrefetchInfiniteQueryName(endpoint)} = (queryClient: QueryClient, ${endpointParams ? `{ ${endpointArgs} }: { ${endpointParams} }, ` : ""}${hasAxiosRequestConfig ? `${AXIOS_REQUEST_CONFIG_NAME}: ${AXIOS_REQUEST_CONFIG_TYPE}, ` : ""}options?: Omit<Parameters<QueryClient["prefetchInfiniteQuery"]>[0], "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">) => {`);
+	lines.push(`  return queryClient.prefetchInfiniteQuery({ ...${getInfiniteQueryOptionsName(endpoint)}(${optionsArgs}), ...(options as {}) });`);
+	lines.push("};");
+	return lines.join("\n");
+}
+function renderQuery({ resolver, endpoint, inlineEndpoints }) {
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const hasAclCheck = resolver.options.checkAcl && endpoint.acl;
+	const tag = getEndpointTag(endpoint, resolver.options);
+	const workspaceParamReplacements = resolver.options.workspaceContext ? getWorkspaceParamReplacements(resolver, endpoint) : {};
+	const workspaceParamTypes = getWorkspaceParamTypes(resolver, endpoint, tag);
+	const endpointArgs = renderEndpointArgs(resolver, endpoint, {});
+	const resolvedEndpointArgs = renderEndpointObjectArgs(resolver, endpoint, {}, workspaceParamReplacements);
+	const endpointParams = renderEndpointParams(resolver, endpoint, {
+		optionalPathParams: resolver.options.workspaceContext,
+		modelNamespaceTag: tag
+	});
+	const queryOptionsName = getQueryOptionsName(endpoint);
+	const hasQueryFnOverride = hasAclCheck;
+	const requestConfig = `{ ${hasAxiosRequestConfig ? `...${AXIOS_REQUEST_CONFIG_NAME}, ` : ""}allowInvalidResponseData: queryConfig.allowInvalidResponseData }`;
+	const queryOptionsArgs = `${resolvedEndpointArgs ? `{ ${resolvedEndpointArgs} }, ` : ""}${requestConfig}`;
+	const lines = [];
+	lines.push(renderQueryJsDocs({
+		resolver,
+		endpoint,
+		mode: "query",
+		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,
+		paramTypes: workspaceParamTypes,
+		indent: "  "
+	}));
+	lines.push("  ");
+	lines.push(`  return ${QUERY_HOOKS.query}({`);
+	lines.push(`    ...${queryOptionsName}(${queryOptionsArgs}),`);
+	if (hasQueryFnOverride) {
+		lines.push("    queryFn: async ({ signal }: { signal: AbortSignal }) => {");
+		if (hasAclCheck) lines.push(renderAclCheckCall(resolver, endpoint, workspaceParamReplacements, "    "));
+		lines.push(`      return ${queryOptionsName}(${queryOptionsArgs}).queryFn({ signal });`);
+		lines.push("    },");
+	}
+	lines.push("    ...options,");
+	lines.push("  });");
+	lines.push("};");
+	return lines.join("\n");
+}
+function renderMutation({ resolver, endpoint, inlineEndpoints, precomputed }) {
+	const hasAclCheck = resolver.options.checkAcl && endpoint.acl;
+	const hasMutationEffects = resolver.options.mutationEffects;
+	const hasMutationDefaultOnError = resolver.options.mutationDefaultOnError;
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const tag = getEndpointTag(endpoint, resolver.options);
+	const workspaceParamReplacements = resolver.options.workspaceContext ? getWorkspaceParamReplacements(resolver, endpoint) : {};
+	const workspaceParamTypes = getWorkspaceParamTypes(resolver, endpoint, tag);
+	const endpointParams = renderEndpointParams(resolver, endpoint, {
+		includeFileParam: true,
+		optionalPathParams: resolver.options.workspaceContext,
+		modelNamespaceTag: tag
+	});
+	const resolvedEndpointArgs = renderEndpointArgs(resolver, endpoint, {}, workspaceParamReplacements);
+	const destructuredMutationArgs = renderEndpointArgs(resolver, endpoint, { includeFileParam: true });
+	const endpointFunction = inlineEndpoints ? getEndpointName(endpoint) : getImportedEndpointName(endpoint, resolver.options);
+	const updateQueryEndpoints = precomputed?.updateQueryEndpoints ?? [];
+	const destructuredVariables = precomputed?.destructuredVariables ?? getDestructuredVariables(resolver, endpoint, updateQueryEndpoints);
+	const hasMutationFnBody = endpoint.mediaUpload || hasAclCheck || Object.keys(workspaceParamReplacements).length > 0;
+	const mutationVariablesType = endpoint.mediaUpload ? `${endpointParams}${endpointParams ? "; " : ""}abortController?: AbortController; onUploadProgress?: (progress: { loaded: number; total: number }) => void` : endpointParams;
+	const isPost = endpoint.method === "post";
+	const mutationScopeOption = resolver.options.mutationScope;
+	const operationId = getEndpointName(endpoint);
+	const scopeMatchKey = `${tag}/${operationId}`;
+	let scopeEnabled = false;
+	if (!isPost && mutationScopeOption) {
+		if (mutationScopeOption === true) scopeEnabled = true;
+		else if (typeof mutationScopeOption === "object" && "include" in mutationScopeOption) scopeEnabled = mutationScopeOption.include.some((id) => id === operationId || id === scopeMatchKey);
+		else if (typeof mutationScopeOption === "object" && "exclude" in mutationScopeOption) scopeEnabled = !mutationScopeOption.exclude.some((id) => id === operationId || id === scopeMatchKey);
+	}
+	const scopePathParams = scopeEnabled ? getEndpointParamMapping(resolver, endpoint, {}).filter((p) => p.paramType === "Path") : [];
+	const isScoped = scopePathParams.length > 0;
+	const nonPathEndpointParams = isScoped ? renderEndpointParams(resolver, endpoint, {
+		includeFileParam: true,
+		optionalPathParams: resolver.options.workspaceContext,
+		modelNamespaceTag: tag,
+		excludePathParams: true
+	}) : endpointParams;
+	const nonPathMutationVariablesType = isScoped ? endpoint.mediaUpload ? `${nonPathEndpointParams}${nonPathEndpointParams ? "; " : ""}abortController?: AbortController; onUploadProgress?: (progress: { loaded: number; total: number }) => void` : nonPathEndpointParams : mutationVariablesType;
+	const pathParamFirstArg = isScoped ? `{ ${scopePathParams.map((p) => p.name).join(", ")} }: { ${scopePathParams.map((p) => `${p.name}: ${p.type}`).join("; ")} }, ` : "";
+	const mutationOptionsTypeArg = isScoped ? nonPathMutationVariablesType ? `, { ${nonPathMutationVariablesType} }` : "" : `, { ${mutationVariablesType} }`;
+	const lines = [];
+	lines.push(renderQueryJsDocs({
+		resolver,
+		endpoint,
+		mode: "mutation",
+		tag
+	}));
+	lines.push(`export const ${getQueryName(endpoint, true)} = (${pathParamFirstArg}options?: AppMutationOptions<typeof ${endpointFunction}${mutationOptionsTypeArg}>${hasMutationEffects ? ` & ${MUTATION_EFFECTS.optionsType}` : ""}${hasAxiosRequestConfig ? `, ${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
+	if (hasMutationDefaultOnError) lines.push("  const queryConfig = OpenApiQueryConfig.useConfig();");
+	if (hasAclCheck) lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
+	lines.push(...renderWorkspaceContextDestructure({
+		replacements: workspaceParamReplacements,
+		paramTypes: workspaceParamTypes,
+		indent: "  "
+	}));
+	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects<${QUERY_MODULE_ENUM}.${tag}>({ currentModule: ${QUERIES_MODULE_NAME} });`);
+	lines.push("");
+	lines.push(`  return ${QUERY_HOOKS.mutation}({`);
+	const nonPathDestructuredArgs = isScoped ? renderEndpointArgs(resolver, endpoint, {
+		includeFileParam: true,
+		excludePathParams: true
+	}) : destructuredMutationArgs;
+	const effectiveParams = isScoped ? nonPathEndpointParams : endpointParams;
+	const effectiveArgs = isScoped ? nonPathDestructuredArgs : destructuredMutationArgs;
+	const mutationFnArg = effectiveParams || endpoint.mediaUpload ? `{ ${effectiveArgs}${endpoint.mediaUpload ? `${effectiveArgs ? ", " : ""}abortController, onUploadProgress` : ""} }` : "";
+	lines.push(`    mutationFn: ${endpoint.mediaUpload ? "async " : ""}(${mutationFnArg}) => ${hasMutationFnBody ? "{ " : ""}`);
+	lines.push(...renderWorkspaceParamCoalescing({
+		replacements: workspaceParamReplacements,
+		indent: "      "
+	}));
+	if (hasAclCheck) lines.push(renderAclCheckCall(resolver, endpoint, workspaceParamReplacements, "      "));
+	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) {
+		const scopePathParamInterpolations = scopePathParams.map((p) => `:\${${p.name}}`).join("");
+		lines.push(`    scope: { id: \`${getEndpointName(endpoint)}${scopePathParamInterpolations}\` },`);
+	}
+	lines.push("    ...options,");
+	if (hasMutationDefaultOnError) lines.push("    onError: options?.onError ?? queryConfig.onError,");
+	if (hasMutationEffects) {
+		lines.push("    onSuccess: async (resData, variables, onMutateResult, context) => {");
+		if (updateQueryEndpoints.length > 0) {
+			const scopedPathParamNames = new Set(scopePathParams.map((p) => p.name));
+			const variablesDestructure = destructuredVariables.filter((v) => !scopedPathParamNames.has(v));
+			if (variablesDestructure.length > 0) lines.push(`      const { ${variablesDestructure.join(", ")} } = variables;`);
+			lines.push(...renderWorkspaceParamCoalescing({
+				replacements: workspaceParamReplacements,
+				indent: "      "
+			}));
+			lines.push(`      const updateKeys = [${updateQueryEndpoints.map((e) => `keys.${getEndpointName(e)}(${renderEndpointArgs(resolver, e, { includeOnlyRequiredParams: true }, workspaceParamReplacements)})`).join(", ")}];`);
+			lines.push(`      await runMutationEffects(resData, variables, options, updateKeys);`);
+		} else lines.push("      await runMutationEffects(resData, variables, options);");
+		lines.push("      options?.onSuccess?.(resData, variables, onMutateResult, context);");
+		lines.push("    },");
+	}
+	lines.push("  });");
+	lines.push("};");
+	return lines.join("\n");
+}
+function groupEndpoints(endpoints, resolver) {
+	const queryEndpoints = [];
+	const mutationEndpoints = [];
+	const infiniteQueryEndpoints = [];
+	const aclEndpoints = [];
+	const infoByEndpoint = /* @__PURE__ */ new Map();
+	const mutationDataByEndpoint = /* @__PURE__ */ new Map();
+	for (const endpoint of endpoints) {
+		const query = isQuery(endpoint);
+		const mutation = isMutation(endpoint);
+		const infiniteQuery = Boolean(resolver.options.infiniteQueries && query && isInfiniteQuery(endpoint, resolver.options));
+		if (query) queryEndpoints.push(endpoint);
+		if (mutation) mutationEndpoints.push(endpoint);
+		if (infiniteQuery) infiniteQueryEndpoints.push(endpoint);
+		if (endpoint.acl) aclEndpoints.push(endpoint);
+		infoByEndpoint.set(endpoint, {
+			query,
+			mutation,
+			infiniteQuery
+		});
+	}
+	for (const endpoint of mutationEndpoints) {
+		const updateQueryEndpoints = queryEndpoints.filter((queryEndpoint) => queryEndpoint.parameters.filter((param) => param.parameterObject?.required).every((pathParam) => endpoint.parameters.some((param) => param.name === pathParam.name)) && queryEndpoint.response === endpoint.response);
+		mutationDataByEndpoint.set(endpoint, {
+			updateQueryEndpoints,
+			destructuredVariables: getDestructuredVariables(resolver, endpoint, updateQueryEndpoints)
+		});
+	}
+	return {
+		queryEndpoints,
+		mutationEndpoints,
+		infiniteQueryEndpoints,
+		aclEndpoints,
+		infoByEndpoint,
+		mutationDataByEndpoint
+	};
+}
+function renderInfiniteQuery({ resolver, endpoint, inlineEndpoints }) {
+	const hasAclCheck = resolver.options.checkAcl && endpoint.acl;
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const tag = getEndpointTag(endpoint, resolver.options);
+	const workspaceParamReplacements = resolver.options.workspaceContext ? getWorkspaceParamReplacements(resolver, endpoint) : {};
+	const workspaceParamTypes = getWorkspaceParamTypes(resolver, endpoint, tag);
+	const endpointParams = renderEndpointParams(resolver, endpoint, {
+		excludePageParam: true,
+		optionalPathParams: resolver.options.workspaceContext,
+		modelNamespaceTag: tag
+	});
+	const endpointArgsWithoutPage = renderEndpointArgs(resolver, endpoint, { excludePageParam: true });
+	const resolvedEndpointArgsWithoutPage = renderEndpointObjectArgs(resolver, endpoint, { excludePageParam: true }, workspaceParamReplacements);
+	const queryOptionsName = getInfiniteQueryOptionsName(endpoint);
+	const requestConfig = `{ ${hasAxiosRequestConfig ? `...${AXIOS_REQUEST_CONFIG_NAME}, ` : ""}allowInvalidResponseData: queryConfig.allowInvalidResponseData }`;
+	const queryOptionsArgs = `${resolvedEndpointArgsWithoutPage ? `{ ${resolvedEndpointArgsWithoutPage} }, ` : ""}${requestConfig}`;
+	const hasQueryFnOverride = hasAclCheck;
+	const lines = [];
+	lines.push(renderQueryJsDocs({
+		resolver,
+		endpoint,
+		mode: "infiniteQuery",
+		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,
+		paramTypes: workspaceParamTypes,
+		indent: "  "
+	}));
+	lines.push("");
+	lines.push(`  return ${QUERY_HOOKS.infiniteQuery}({`);
+	lines.push(`    ...${queryOptionsName}(${queryOptionsArgs}),`);
+	if (hasQueryFnOverride) {
+		lines.push("    queryFn: async ({ pageParam, signal }: { pageParam: number; signal: AbortSignal }) => {");
+		lines.push(renderAclCheckCall(resolver, endpoint, workspaceParamReplacements, "      "));
+		lines.push(`      return ${queryOptionsName}(${queryOptionsArgs}).queryFn({ pageParam, signal });`);
+		lines.push("    },");
+	}
+	lines.push("    ...options,");
+	lines.push("  });");
+	lines.push("};");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/generators/generate/generateAppRestClient.ts
+function generateAppRestClient(resolver) {
+	return `import { RestClient } from "${PACKAGE_IMPORT_PATH}";
+
+export const ${APP_REST_CLIENT_NAME} = new RestClient({
+  config: {
+    baseURL: "${resolver.getBaseUrl()}"
+  },
+});
+`;
+}
+//#endregion
+//#region src/generators/generate/generateDomainErrors.ts
+function domainToPascalCase(domain) {
+	return domain.split(/[-_]/).map(capitalize).join("");
+}
+const VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function generateDomainErrors({ resolver, data }) {
+	const nativeContent = resolver.getNativeRenderedShared?.("domainErrors");
+	if (nativeContent) return nativeContent;
+	const byDomain = /* @__PURE__ */ new Map();
+	for (const { endpoints } of data.values()) for (const endpoint of endpoints) for (const error of endpoint.errors) {
+		if (!error.domainError) continue;
+		const { domain, code } = error.domainError;
+		if (!byDomain.has(domain)) byDomain.set(domain, /* @__PURE__ */ new Map());
+		const domainMap = byDomain.get(domain);
+		if (!domainMap.has(code)) domainMap.set(code, {
+			code,
+			name: error.domainError.name,
+			description: error.description
+		});
+	}
+	if (byDomain.size === 0) return void 0;
+	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) => {
+			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];`);
+	}
+	return blocks.join("\n\n") + "\n";
+}
+//#endregion
+//#region src/generators/generate/generateQueryModules.ts
+function generateQueryModules({ resolver, data }) {
+	const nativeContent = resolver.getNativeRenderedShared?.("queryModules");
+	if (nativeContent) return nativeContent;
+	const modules = [];
+	data.forEach((_, tag) => {
+		const endpoints = data.get(tag)?.endpoints;
+		if (!endpoints || endpoints.length === 0) return;
+		modules.push({
+			tag,
+			namespace: getNamespaceName({
+				type: "queries",
+				tag,
+				options: resolver.options
+			})
+		});
+	});
+	const lines = [];
+	lines.push("export const enum QueryModule {");
+	for (const module of modules) lines.push(`   ${module.tag} = "${module.namespace}",`);
+	lines.push("}");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/generators/utils/generate-files.utils.ts
+function getAclFiles(data, resolver) {
+	if (!resolver.options.acl) return [];
+	return [{
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName: getFileNameWithExtension(ACL_APP_ABILITY_FILE)
+		}),
+		content: generateAppAcl({
+			resolver,
+			data
+		})
+	}];
+}
+function getMutationEffectsFiles(data, resolver) {
+	if (!resolver.options.mutationEffects) return [];
+	return [{
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName: getFileNameWithExtension(QUERY_MODULES_FILE)
+		}),
+		content: generateQueryModules({
+			resolver,
+			data
+		})
+	}];
+}
+function getZodExtendedFiles(_data, _resolver) {
+	return [];
+}
+function getDomainErrorsFiles(data, resolver) {
+	const content = generateDomainErrors({
+		resolver,
+		data
+	});
+	if (!content) return [];
+	return [{
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName: getFileNameWithExtension(DOMAIN_ERRORS_FILE)
+		}),
+		content
+	}];
+}
+function getAppRestClientFiles(resolver) {
+	if (resolver.options.restClientImportPath !== DEFAULT_GENERATE_OPTIONS.restClientImportPath) return [];
+	return [{
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName: getFileNameWithExtension(APP_REST_CLIENT_FILE)
+		}),
+		content: generateAppRestClient(resolver)
+	}];
+}
+//#endregion
+//#region src/native/getDataFromNativeOpenAPIDoc.ts
+var NativeSchemaResolver = class {
+	nativeData;
+	options;
+	openApiDoc;
+	dependencyGraph;
+	refByName;
+	nameByRef;
+	circularSchemas;
+	referencedNames = /* @__PURE__ */ new Map();
+	enumObjectsByCode;
+	constructor(openApiDoc, options, nativeData) {
+		this.nativeData = nativeData;
+		this.openApiDoc = openApiDoc;
+		this.options = options;
+		this.refByName = new Map(Object.entries(nativeData.schemaRefs));
+		for (const name of Object.keys(nativeData.generatedObjects)) if (!this.refByName.has(name)) this.refByName.set(name, `#/x-native-schemas/${encodeURIComponent(name)}`);
+		this.nameByRef = new Map([...this.refByName].map(([name, ref]) => [ref, name]));
+		this.circularSchemas = new Set(nativeData.circularSchemas);
+		const refsDependencyGraph = Object.fromEntries(Object.entries(nativeData.dependencies).map(([ref, dependencies]) => [ref, new Set(dependencies)]));
+		this.dependencyGraph = {
+			refsDependencyGraph,
+			deepDependencyGraph: {}
+		};
+		for (const name of Object.keys(nativeData.generatedObjects)) {
+			const ref = this.refByName.get(name);
+			const dependencies = /* @__PURE__ */ new Set();
+			const addDependency = (dependency) => {
+				if (dependency === ref || dependencies.has(dependency)) return;
+				dependencies.add(dependency);
+				for (const child of this.dependencyGraph.refsDependencyGraph[dependency] ?? []) addDependency(child);
+			};
+			for (const dependencyName of nativeData.generatedDependencies[name] ?? []) {
+				const dependency = this.refByName.get(dependencyName);
+				if (dependency) addDependency(dependency);
+			}
+			this.dependencyGraph.refsDependencyGraph[ref] = dependencies;
+		}
+	}
+	getCodeByZodSchemaName(name) {
+		return this.nativeData.schemas[name];
+	}
+	getNativeRenderedModels(tag) {
+		return this.nativeData.renderedModels[tag];
+	}
+	getNativeRenderedEndpoints(tag) {
+		return this.nativeData.renderedEndpoints[tag];
+	}
+	getNativeRenderedQueries(tag) {
+		return this.nativeData.renderedQueries[tag];
+	}
+	getNativeRenderedAcl(tag) {
+		return this.nativeData.renderedAcl[tag];
+	}
+	getNativeRenderedShared(name) {
+		return this.nativeData.renderedShared[name];
+	}
+	getRefByZodSchemaName(name) {
+		return this.refByName.get(name);
+	}
+	getZodSchemaNameByRef(ref) {
+		return this.nameByRef.get(normalizeRef(ref));
+	}
+	getTagByZodSchemaName(name) {
+		return this.options.modelsInCommon ? this.options.defaultTag : this.nativeData.schemaOwners[name];
+	}
+	isSchemaCircular(ref) {
+		const name = this.nameByRef.get(normalizeRef(ref));
+		return Boolean(name && this.circularSchemas.has(name));
+	}
+	getZodSchemaObj(name) {
+		if (this.nativeData.generatedObjects[name]) return this.nativeData.generatedObjects[name];
+		const ref = this.refByName.get(name);
+		if (ref) return this.resolveRef(ref);
+		const code = this.nativeData.schemas[name];
+		if (!code?.startsWith("z.enum(")) return void 0;
+		this.enumObjectsByCode ??= collectEnumObjects(this.openApiDoc);
+		return this.enumObjectsByCode.get(code);
+	}
+	getExtractedEnumZodSchemaNamesReferencedBySchemaRef(ref) {
+		const normalizedRef = normalizeRef(ref);
+		const cached = this.referencedNames.get(normalizedRef);
+		if (cached) return cached;
+		const name = this.nameByRef.get(normalizedRef);
+		const code = name ? this.nativeData.schemas[name] : void 0;
+		const directNames = new Set([...this.dependencyGraph.refsDependencyGraph[normalizedRef] ?? []].map((dependency) => this.nameByRef.get(dependency)).filter((value) => Boolean(value)));
+		const references = [...code ? [...code.matchAll(/\b[A-Za-z_$][\w$]*Schema\b/g)].map(([match]) => match).filter((match, index, values) => match !== name && values.indexOf(match) === index && match in this.nativeData.schemas && !directNames.has(match)) : []].filter((value, index, values) => values.indexOf(value) === index);
+		this.referencedNames.set(normalizedRef, references);
+		return references;
+	}
+	getCompositeZodSchemaByZodSchemaName() {}
+	resolveObject(value) {
+		if (value && typeof value === "object" && "$ref" in value) return this.resolveRef(value.$ref);
+		return value;
+	}
+	getBaseUrl() {
+		return this.nativeData.baseUrl;
+	}
+	resolveRef(ref) {
+		const segments = normalizeRef(ref).slice(2).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+		let value = this.openApiDoc;
+		for (const segment of segments) value = value?.[segment];
+		return value;
+	}
+};
+function collectEnumObjects(document) {
+	const enums = /* @__PURE__ */ new Map();
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			value.forEach(visit);
+			return;
+		}
+		const object = value;
+		if (Array.isArray(object.enum)) {
+			const code = `z.enum(${JSON.stringify(object.enum)})`.replaceAll(",", ", ");
+			Object.assign(enums.get(code) ?? {}, object);
+			enums.set(code, {
+				...enums.get(code) ?? {},
+				...object
+			});
+		}
+		Object.values(object).forEach(visit);
+	};
+	visit(document.components?.schemas ?? {});
+	return enums;
+}
+function normalizeRef(ref) {
+	if (ref.startsWith("#/")) return ref;
+	if (ref.startsWith("#")) return `#/${ref.slice(1).replace(/^\//, "")}`;
+	return ref;
+}
+function getTagElement(tag, data) {
+	let value = data.get(tag);
+	if (!value) {
+		value = {
+			endpoints: [],
+			zodSchemas: {}
+		};
+		data.set(tag, value);
+	}
+	return value;
+}
+function getDataFromNativeOpenAPIDoc(openApiDoc, options, nativeSource) {
+	const started = performance.now();
+	const source = nativeSource?.source ?? JSON.stringify(openApiDoc);
+	const afterLoad = performance.now();
+	const nativeResult = compileNativeData(source, nativeSource?.yaml ?? false, JSON.stringify({
+		...options,
+		nativeCompact: true
+	}));
+	const afterNative = performance.now();
+	const nativeData = nativeResult.data;
+	const afterParse = performance.now();
+	const resolver = new NativeSchemaResolver(nativeData.document ?? openApiDoc, options, nativeData);
+	const afterResolver = performance.now();
+	const data = /* @__PURE__ */ new Map();
+	if (nativeData.renderedComplete) {
+		for (const tag of nativeData.renderedTags) data.set(tag, {
+			endpoints: [],
+			zodSchemas: {}
+		});
+		if (process.env.OPENAPI_NATIVE_PROFILE === "1") console.error(`native bridge load=${(afterLoad - started).toFixed(1)}ms call=${(afterNative - afterLoad).toFixed(1)}ms parse=${(afterParse - afterNative).toFixed(1)}ms facade=${(performance.now() - afterParse).toFixed(1)}ms compact=true`);
+		return {
+			resolver,
+			data
+		};
+	}
+	if (!options.splitByTags) {
+		data.set(options.defaultTag, {
+			endpoints: nativeData.endpoints,
+			zodSchemas: nativeData.schemas
+		});
+		return {
+			resolver,
+			data
+		};
+	}
+	for (const endpoint of nativeData.endpoints) getTagElement(getEndpointTag(endpoint, options), data).endpoints.push(endpoint);
+	for (const [name, code] of Object.entries(nativeData.schemas)) {
+		const tag = options.modelsInCommon ? options.defaultTag : nativeData.schemaOwners[name];
+		if (tag) getTagElement(tag, data).zodSchemas[name] = code;
+	}
+	if (process.env.OPENAPI_NATIVE_PROFILE === "1") console.error(`native bridge load=${(afterLoad - started).toFixed(1)}ms call=${(afterNative - afterLoad).toFixed(1)}ms parse=${(afterParse - afterNative).toFixed(1)}ms facade=${(afterResolver - afterParse).toFixed(1)}ms split=${(performance.now() - afterResolver).toFixed(1)}ms`);
+	return {
+		resolver,
+		data
+	};
+}
+//#endregion
+//#region src/generators/generateCodeFromOpenAPIDoc.ts
+var generateCodeFromOpenAPIDoc_exports = /* @__PURE__ */ __exportAll({ generateCodeFromOpenAPIDoc: () => generateCodeFromOpenAPIDoc });
+function generateCodeFromOpenAPIDoc(openApiDoc, options, profiler, nativeSource) {
+	const p = profiler ?? new Profiler(false);
+	const importPath = options.standalone && options.importPath === "ts" ? "relative" : options.importPath;
+	const resolvedOptions = {
+		...options,
+		importPath
+	};
+	const { resolver, data } = p.runSync("data.extract", () => nativeSource && shouldUseNativeCodegen() ? getDataFromNativeOpenAPIDoc(openApiDoc, resolvedOptions, nativeSource) : getDataFromOpenAPIDoc(openApiDoc, resolvedOptions, p));
+	const generateFilesData = [];
+	const appAclTags = [];
+	const modelsOnly = Boolean(resolver.options.modelsOnly);
+	const shouldGenerateEndpoints = !modelsOnly && Array.from(data.keys()).some((tag) => !shouldInlineEndpointsForTag(tag, resolver.options));
+	const generateTypes = modelsOnly ? ["models"] : [
+		"models",
+		...shouldGenerateEndpoints ? ["endpoints"] : [],
+		"queries",
+		...resolver.options.acl ? ["acl"] : [],
+		...resolver.options.builderConfigs ? ["configs"] : []
+	];
+	const generateFunctions = {
+		["models"]: generateModels,
+		["endpoints"]: generateEndpoints,
+		["queries"]: generateQueries,
+		["acl"]: generateAcl,
+		["configs"]: generateConfigs
+	};
+	data.forEach((_, tag) => {
+		generateTypes.forEach((type) => {
+			const content = p.runSync(`render.${type}`, () => generateFunctions[type]({
+				resolver,
+				data,
+				tag
+			}));
+			if (content) {
+				const fileName = getOutputFileName({
+					output: options.output,
+					fileName: getTagFileName({
+						tag,
+						type,
+						options
+					})
+				});
+				generateFilesData.push({
+					fileName,
+					content
+				});
+				if (type === "acl") appAclTags.push(tag);
+			}
+		});
+	});
+	if (!modelsOnly) generateFilesData.push(...p.runSync("render.AclShared", () => getAclFiles(data, resolver)), ...p.runSync("render.MutationEffects", () => getMutationEffectsFiles(data, resolver)), ...p.runSync("render.ZodExtended", () => getZodExtendedFiles(data, resolver)), ...p.runSync("render.Standalone", () => getAppRestClientFiles(resolver)), ...p.runSync("render.DomainErrors", () => getDomainErrorsFiles(data, resolver)));
+	return generateFilesData;
+}
+//#endregion
+export { generateCodeFromOpenAPIDoc_exports as n, generateCodeFromOpenAPIDoc as t };