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

package/README.md

@@ -92,7 +92,10 @@ yarn openapi-codegen generate --config my-config.ts
   --axiosRequestConfig                Include Axios request config parameters in query hooks (default: false)
   --infiniteQueries                   Generate infinite queries for paginated API endpoints (default: false)
   --mutationEffects                   Add mutation effects options to mutation hooks (default: true)
-  --mutationScope                     Serialize mutations for the same path-param resource via TanStack scope.id (default: false)
+  --mutationScope                     Serialize mutations for the same path-param resource via TanStack scope.id (default: false).
+                                      In config files also accepts { include: string[] } or { exclude: string[] } to opt specific
+                                      operations in/out of scoping. Use "Tag/operationId" format for precision (e.g. "EmployeeSettings/update")
+                                      or just "operationId" to match across all tags. Cannot specify both include and exclude.
   --mutationDefaultOnError            Use OpenApiQueryConfig.onError as the default onError for mutation hooks (default: false)
   --workspaceContext                  Comma-separated list of path/ACL params that generated hooks may resolve from OpenApiWorkspaceContext
   --inlineEndpoints                   Inline endpoint implementations into generated query files (default: false)

package/dist/acl.d.mts

@@ -1,4 +1,4 @@
-import { r as ErrorHandler } from "./error-handling-CvW_FecB.mjs";
+import { a as ErrorHandler } from "./error-handling-B4aYKmyL.mjs";
 import * as react from "react";
 import { PropsWithChildren } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";

package/dist/acl.mjs

@@ -1,4 +1,4 @@
-import { r as SharedErrorHandler } from "./error-handling-DkPY7Asf.mjs";
+import { i as SharedErrorHandler } from "./error-handling-nneQaE1_.mjs";
 import { n as OpenApiRouter, t as AuthContext } from "./auth.context-Bu5KW2sI.mjs";
 import { createContext, useCallback, useEffect, useState } from "react";
 import { jsx } from "react/jsx-runtime";

package/dist/{config-CKmoJbQB.d.mts → config-C1ME3Ay4.d.mts}

@@ -1,4 +1,4 @@
-import { t as GenerateOptions } from "./options-C6CNQ6tq.mjs";
+import { t as GenerateOptions } from "./options-BPAjzilp.mjs";
 
 //#region src/generators/types/config.d.ts
 type OpenAPICodegenConfig = Partial<GenerateOptions>;

package/dist/{error-handling-CvW_FecB.d.mts → error-handling-B4aYKmyL.d.mts}

@@ -12,13 +12,28 @@ interface ErrorEntry<CodeT> {
   condition?: (error: unknown) => boolean;
   getMessage: (t: TFunction<string, undefined>, error: unknown) => string;
 }
-interface ErrorHandlerOptions<CodeT extends string> {
+interface DomainErrorEntry {
+  code: string | number;
+  condition?: (error: unknown) => boolean;
+  getMessage: (t: TFunction<string, undefined>, error: unknown) => string;
+}
+declare class DomainErrorRegistry {
+  private static readonly entries;
+  static register(entry: DomainErrorEntry): void;
+  static register(entries: DomainErrorEntry[]): void;
+  static unregister(code: string | number): void;
+  static clear(): void;
+  static getEntry(code: string | number): DomainErrorEntry | undefined;
+}
+interface ErrorHandlerOptions<CodeT extends string | number> {
   entries: ErrorEntry<CodeT>[];
   t?: TFunction<string, undefined>;
   onRethrowError?: (error: unknown, exception: ApplicationException<CodeT | GeneralErrorCodes>) => void;
 }
-declare class ErrorHandler<CodeT extends string> {
+declare class ErrorHandler<CodeT extends string | number> {
   entries: ErrorEntry<CodeT | GeneralErrorCodes>[];
+  private readonly userEntries;
+  private readonly generalEntries;
   private t;
   private onRethrowError?;
   constructor({
@@ -35,4 +50,4 @@ declare class ErrorHandler<CodeT extends string> {
 }
 declare const SharedErrorHandler: ErrorHandler<never>;
 //#endregion
-export { GeneralErrorCodes as a, ErrorHandlerOptions as i, ErrorEntry as n, SharedErrorHandler as o, ErrorHandler as r, ApplicationException as t };
+export { ErrorHandler as a, SharedErrorHandler as c, ErrorEntry as i, DomainErrorEntry as n, ErrorHandlerOptions as o, DomainErrorRegistry as r, GeneralErrorCodes as s, ApplicationException as t };

package/dist/{error-handling-DkPY7Asf.mjs → error-handling-nneQaE1_.mjs}

@@ -53,6 +53,7 @@ let RestUtils;
 		if (!e.response) return null;
 		const data = e.response.data;
 		if (typeof data?.code === "string") return data.code;
+		if (typeof data?.code === "number") return data.code;
 		return null;
 	};
 	_RestUtils.doesServerErrorMessageContain = (e, text) => {
@@ -85,8 +86,26 @@ var ApplicationException = class extends Error {
 		this.serverMessage = serverMessage;
 	}
 };
+var DomainErrorRegistry = class {
+	static entries = /* @__PURE__ */ new Map();
+	static register(entryOrEntries) {
+		const items = Array.isArray(entryOrEntries) ? entryOrEntries : [entryOrEntries];
+		for (const item of items) this.entries.set(item.code, item);
+	}
+	static unregister(code) {
+		this.entries.delete(code);
+	}
+	static clear() {
+		this.entries.clear();
+	}
+	static getEntry(code) {
+		return this.entries.get(code);
+	}
+};
 var ErrorHandler = class {
 	entries = [];
+	userEntries;
+	generalEntries;
 	t;
 	onRethrowError;
 	constructor({ entries, t = defaultT, onRethrowError }) {
@@ -138,14 +157,15 @@ var ErrorHandler = class {
 				return this.t("openapi.sharedErrors.unknownError");
 			}
 		};
-		this.entries = [
-			...entries,
+		this.userEntries = [...entries];
+		this.generalEntries = [
 			dataValidationError,
 			internalError,
 			networkError,
 			canceledError,
 			unknownError
 		];
+		this.entries = [...this.userEntries, ...this.generalEntries];
 	}
 	matchesEntry(error, entry, code) {
 		if (entry.condition) return entry.condition(error);
@@ -156,9 +176,23 @@ var ErrorHandler = class {
 	}
 	rethrowError(error) {
 		const code = RestUtils.extractServerResponseCode(error);
-		const errorEntry = this.entries.find((entry) => this.matchesEntry(error, entry, code));
 		const serverMessage = RestUtils.extractServerErrorMessage(error);
-		const exception = new ApplicationException(errorEntry.getMessage(this.t, error), errorEntry.code, serverMessage);
+		const userEntry = this.userEntries.find((entry) => this.matchesEntry(error, entry, code));
+		if (userEntry) {
+			const exception = new ApplicationException(userEntry.getMessage(this.t, error), userEntry.code, serverMessage);
+			this.onRethrowError?.(error, exception);
+			throw exception;
+		}
+		if (code !== null) {
+			const registryEntry = DomainErrorRegistry.getEntry(code);
+			if (registryEntry && (!registryEntry.condition || registryEntry.condition(error))) {
+				const exception = new ApplicationException(registryEntry.getMessage(this.t, error), registryEntry.code, serverMessage);
+				this.onRethrowError?.(error, exception);
+				throw exception;
+			}
+		}
+		const generalEntry = this.generalEntries.find((entry) => this.matchesEntry(error, entry, code));
+		const exception = new ApplicationException(generalEntry.getMessage(this.t, error), generalEntry.code, serverMessage);
 		this.onRethrowError?.(error, exception);
 		throw exception;
 	}
@@ -184,4 +218,4 @@ var ErrorHandler = class {
 const SharedErrorHandler = new ErrorHandler({ entries: [] });
 
 //#endregion
-export { ns as a, RestUtils as i, ErrorHandler as n, resources as o, SharedErrorHandler as r, ApplicationException as t };
+export { RestUtils as a, SharedErrorHandler as i, DomainErrorRegistry as n, ns as o, ErrorHandler as r, resources as s, ApplicationException as t };

package/dist/{generate.runner-B0iop_CE.mjs → generate.runner-CeXyATq2.mjs}

@@ -1,4 +1,4 @@
-import { S as Profiler, h as deepMerge, i as writeGenerateFileData, p as DEFAULT_GENERATE_OPTIONS, r as removeStaleGeneratedFiles, t as generateCodeFromOpenAPIDoc } from "./generateCodeFromOpenAPIDoc-BKIXvJIW.mjs";
+import { S as Profiler, h as deepMerge, i as writeGenerateFileData, p as DEFAULT_GENERATE_OPTIONS, r as removeStaleGeneratedFiles, t as generateCodeFromOpenAPIDoc } from "./generateCodeFromOpenAPIDoc-mALUMd3q.mjs";
 import path from "path";
 import SwaggerParser from "@apidevtools/swagger-parser";
 

package/dist/{generateCodeFromOpenAPIDoc-BKIXvJIW.mjs → generateCodeFromOpenAPIDoc-mALUMd3q.mjs}

@@ -386,12 +386,23 @@ function replaceHyphenatedPath(path) {
 	});
 	return path;
 }
-const isSortingParameterObject = (param) => {
-	const enumNames = param["x-enumNames"];
-	const hasEnumNames = Array.isArray(enumNames) && enumNames.length > 0;
-	const isStringSchema = !!param.schema && isSchemaObject(param.schema) && param.schema.type === "string";
-	return hasEnumNames && isStringSchema;
+const isSortingParameterObject = (param, schema = param.schema, resolver) => {
+	const enumNames = getParameterEnumNames(param, schema);
+	return Array.isArray(enumNames) && enumNames.length > 0 && isStringLikeParameterSchema(schema, resolver);
 };
+function getParameterEnumNames(param, schema = param.schema) {
+	return param["x-enumNames"] ?? (schema && isSchemaObject(schema) ? schema["x-enumNames"] : void 0);
+}
+function isStringLikeParameterSchema(schema, resolver) {
+	if (!schema) return false;
+	if (isReferenceObject(schema)) return resolver ? isStringLikeParameterSchema(resolver.resolveObject(schema), resolver) : true;
+	if (schema.type === "string" || Array.isArray(schema.type) && schema.type.includes("string")) return true;
+	return [
+		...schema.allOf ?? [],
+		...schema.oneOf ?? [],
+		...schema.anyOf ?? []
+	].some((compositeSchema) => isStringLikeParameterSchema(compositeSchema, resolver));
+}
 const isPathExcluded = (path, options) => {
 	if (!options.excludePathRegex) return false;
 	return new RegExp(options.excludePathRegex).test(path);
@@ -915,6 +926,10 @@ const APP_REST_CLIENT_FILE = {
 	fileName: "app-rest-client",
 	extension: "ts"
 };
+const DOMAIN_ERRORS_FILE = {
+	fileName: "domain-errors",
+	extension: "ts"
+};
 const QUERY_OPTIONS_TYPES = {
 	query: "AppQueryOptions",
 	infiniteQuery: "AppInfiniteQueryOptions",
@@ -1393,96 +1408,6 @@ const DEFAULT_GENERATE_OPTIONS = {
 //#region src/generators/utils/array.utils.ts
 const getUniqueArray = (...arrs) => [...new Set(arrs.flat())];
 
-//#endregion
-//#region src/generators/utils/generate/generate.acl.utils.ts
-const getAbilityFunctionName = (endpoint) => `canUse${capitalize(snakeToCamel(endpoint.operationName))}`;
-const getImportedAbilityFunctionName = (endpoint, options) => {
-	return `${options.tsNamespaces ? `${getNamespaceName({
-		type: GenerateType.Acl,
-		tag: getEndpointTag(endpoint, options),
-		options
-	})}.` : ""}${getAbilityFunctionName(endpoint)}`;
-};
-const getAbilityAction = (endpoint) => endpoint.acl?.[0].action;
-const getAbilitySubject = (endpoint) => endpoint.acl?.[0].subject;
-const hasAbilityConditions = (endpoint) => !!getAbilityConditionsTypes(endpoint)?.length;
-const getAbilityConditionsTypes = (endpoint) => endpoint.acl?.[0].conditionsTypes?.sort((a, b) => a.name.localeCompare(b.name));
-const getAbilityDescription = (endpoint) => endpoint.acl?.[0]?.description;
-const getAbilitySubjectTypes = (endpoint) => {
-	const abilitySubject = getAbilitySubject(endpoint);
-	const types = [`"${abilitySubject ?? ""}"`];
-	if (hasAbilityConditions(endpoint)) types.push(`ForcedSubject<"${abilitySubject}"> & { ${getAbilityConditionsTypes(endpoint)?.map((conditionType) => `${conditionType.name}${conditionType.required ? "" : "?"}: ${conditionType.type ?? ""}${conditionType.zodSchemaName ?? ""},`).join(" ")} }`);
-	return types;
-};
-function getAclData({ resolver, data, tag }) {
-	const endpoints = data.get(tag)?.endpoints.filter(({ acl }) => acl && acl.length > 0);
-	if (!endpoints || endpoints.length === 0) return;
-	return {
-		endpoints,
-		hasAdditionalAbilityImports: endpoints.some(({ acl }) => acl?.[0].conditions && Object.keys(acl[0].conditions).length > 0),
-		modelsImports: getModelsImports({
-			resolver,
-			tag,
-			zodSchemasAsTypes: getUniqueArray(endpoints.reduce((acc, endpoint) => {
-				const zodSchemas = endpoint.acl?.[0].conditionsTypes?.reduce((acc, propertyType) => [...acc, ...propertyType?.zodSchemaName ? [propertyType.zodSchemaName] : []], []);
-				return [...acc, ...zodSchemas ?? []];
-			}, []))
-		})
-	};
-}
-const getAppAbilitiesType = ({ resolver, data }) => {
-	const appAbilitiesTypeMap = /* @__PURE__ */ new Map();
-	const modelsImportsArr = [];
-	let hasAdditionalAbilityImports = false;
-	data.forEach((_, tag) => {
-		const aclData = getAclData({
-			resolver,
-			data,
-			tag
-		});
-		if (!aclData) return;
-		const { modelsImports: tagModelsImports, hasAdditionalAbilityImports: tagHasAdditionalAbilityImports, endpoints } = aclData;
-		modelsImportsArr.push(tagModelsImports);
-		hasAdditionalAbilityImports = hasAdditionalAbilityImports || tagHasAdditionalAbilityImports;
-		endpoints.forEach((endpoint) => {
-			const abilityAction = getAbilityAction(endpoint);
-			if (abilityAction) appAbilitiesTypeMap.set(abilityAction, new Set([...appAbilitiesTypeMap.get(abilityAction) ?? [], ...getAbilitySubjectTypes(endpoint)]));
-		});
-	});
-	const modelsImports = mergeImports(resolver.options, ...modelsImportsArr);
-	return {
-		appAbilitiesType: appAbilitiesTypeMap.size > 0 ? Object.fromEntries(Array.from(appAbilitiesTypeMap.entries()).map(([key, valueSet]) => [key, Array.from(valueSet)])) : void 0,
-		modelsImports,
-		hasAdditionalAbilityImports
-	};
-};
-
-//#endregion
-//#region src/generators/utils/generate/generate.query.utils.ts
-const getQueryName = (endpoint, mutation) => {
-	const addMutationSuffix = isQuery(endpoint) && isMutation(endpoint) && mutation;
-	return `use${capitalize(snakeToCamel(endpoint.operationName))}${addMutationSuffix ? "Mutation" : ""}`;
-};
-const getInfiniteQueryName = (endpoint) => `use${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
-const getQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}QueryOptions`;
-const getInfiniteQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}InfiniteQueryOptions`;
-const getPrefetchQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}`;
-const getPrefetchInfiniteQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
-const getImportedQueryName = (endpoint, options) => {
-	return `${options.tsNamespaces ? `${getNamespaceName({
-		type: GenerateType.Queries,
-		tag: getEndpointTag(endpoint, options),
-		options
-	})}.` : ""}${getQueryName(endpoint)}`;
-};
-const getImportedInfiniteQueryName = (endpoint, options) => {
-	return `${options.tsNamespaces ? `${getNamespaceName({
-		type: GenerateType.Queries,
-		tag: getEndpointTag(endpoint, options),
-		options
-	})}.` : ""}${getInfiniteQueryName(endpoint)}`;
-};
-
 //#endregion
 //#region src/generators/core/openapi/iterateSchema.ts
 function iterateSchema(schema, options) {
@@ -1651,6 +1576,101 @@ function getZodSchemaPropertyDescriptions(resolver, data, tag) {
 	return properties;
 }
 
+//#endregion
+//#region src/generators/utils/generate/generate.acl.utils.ts
+const getAbilityFunctionName = (endpoint) => `canUse${capitalize(snakeToCamel(endpoint.operationName))}`;
+const getImportedAbilityFunctionName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Acl,
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getAbilityFunctionName(endpoint)}`;
+};
+const getAbilityAction = (endpoint) => endpoint.acl?.[0].action;
+const getAbilitySubject = (endpoint) => endpoint.acl?.[0].subject;
+const hasAbilityConditions = (endpoint) => !!getAbilityConditionsTypes(endpoint)?.length;
+const getAbilityConditionsTypes = (endpoint) => endpoint.acl?.[0].conditionsTypes?.sort((a, b) => a.name.localeCompare(b.name));
+const getAbilityDescription = (endpoint) => endpoint.acl?.[0]?.description;
+const getAbilitySubjectTypes = (endpoint, resolver, tag) => {
+	const abilitySubject = getAbilitySubject(endpoint);
+	const types = [`"${abilitySubject ?? ""}"`];
+	if (hasAbilityConditions(endpoint)) types.push(`ForcedSubject<"${abilitySubject}"> & { ${getAbilityConditionsTypes(endpoint)?.map((conditionType) => `${conditionType.name}${conditionType.required ? "" : "?"}: ${getAbilityConditionType(conditionType, resolver, tag)},`).join(" ")} }`);
+	return types;
+};
+function getAbilityConditionType(conditionType, resolver, tag) {
+	if (!conditionType.zodSchemaName) return conditionType.type ?? "";
+	if (!resolver) return `${conditionType.type ?? ""}${conditionType.zodSchemaName}`;
+	return getImportedZodSchemaInferedTypeName(resolver, conditionType.zodSchemaName, tag, tag);
+}
+function getAclData({ resolver, data, tag }) {
+	const endpoints = data.get(tag)?.endpoints.filter(({ acl }) => acl && acl.length > 0);
+	if (!endpoints || endpoints.length === 0) return;
+	return {
+		endpoints,
+		hasAdditionalAbilityImports: endpoints.some(({ acl }) => acl?.[0].conditions && Object.keys(acl[0].conditions).length > 0),
+		modelsImports: getModelsImports({
+			resolver,
+			tag,
+			zodSchemasAsTypes: getUniqueArray(endpoints.reduce((acc, endpoint) => {
+				const zodSchemas = endpoint.acl?.[0].conditionsTypes?.reduce((acc, propertyType) => [...acc, ...propertyType?.zodSchemaName ? [propertyType.zodSchemaName] : []], []);
+				return [...acc, ...zodSchemas ?? []];
+			}, []))
+		})
+	};
+}
+const getAppAbilitiesType = ({ resolver, data }) => {
+	const appAbilitiesTypeMap = /* @__PURE__ */ new Map();
+	const modelsImportsArr = [];
+	let hasAdditionalAbilityImports = false;
+	data.forEach((_, tag) => {
+		const aclData = getAclData({
+			resolver,
+			data,
+			tag
+		});
+		if (!aclData) return;
+		const { modelsImports: tagModelsImports, hasAdditionalAbilityImports: tagHasAdditionalAbilityImports, endpoints } = aclData;
+		modelsImportsArr.push(tagModelsImports);
+		hasAdditionalAbilityImports = hasAdditionalAbilityImports || tagHasAdditionalAbilityImports;
+		endpoints.forEach((endpoint) => {
+			const abilityAction = getAbilityAction(endpoint);
+			if (abilityAction) appAbilitiesTypeMap.set(abilityAction, new Set([...appAbilitiesTypeMap.get(abilityAction) ?? [], ...getAbilitySubjectTypes(endpoint, resolver, tag)]));
+		});
+	});
+	const modelsImports = mergeImports(resolver.options, ...modelsImportsArr);
+	return {
+		appAbilitiesType: appAbilitiesTypeMap.size > 0 ? Object.fromEntries(Array.from(appAbilitiesTypeMap.entries()).map(([key, valueSet]) => [key, Array.from(valueSet)])) : void 0,
+		modelsImports,
+		hasAdditionalAbilityImports
+	};
+};
+
+//#endregion
+//#region src/generators/utils/generate/generate.query.utils.ts
+const getQueryName = (endpoint, mutation) => {
+	const addMutationSuffix = isQuery(endpoint) && isMutation(endpoint) && mutation;
+	return `use${capitalize(snakeToCamel(endpoint.operationName))}${addMutationSuffix ? "Mutation" : ""}`;
+};
+const getInfiniteQueryName = (endpoint) => `use${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
+const getQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}QueryOptions`;
+const getInfiniteQueryOptionsName = (endpoint) => `${snakeToCamel(endpoint.operationName)}InfiniteQueryOptions`;
+const getPrefetchQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}`;
+const getPrefetchInfiniteQueryName = (endpoint) => `prefetch${capitalize(snakeToCamel(endpoint.operationName))}Infinite`;
+const getImportedQueryName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Queries,
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getQueryName(endpoint)}`;
+};
+const getImportedInfiniteQueryName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Queries,
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getInfiniteQueryName(endpoint)}`;
+};
+
 //#endregion
 //#region src/generators/utils/generate/generate.imports.utils.ts
 function getModelsImports({ resolver, tag, zodSchemas = [], zodSchemasAsTypes = [] }) {
@@ -2092,7 +2112,9 @@ function getEndpointAclConditionPropertyType({ resolver, endpoint, acl, name })
 		const matchingMediaType = Object.keys(bodyParameter?.bodyObject?.content ?? {}).find(isParamMediaTypeAllowed);
 		if (matchingMediaType) {
 			schema = bodyParameter?.bodyObject?.content?.[matchingMediaType]?.schema;
+			required = bodyParameter?.bodyObject?.required;
 			info = `${isQuery(endpoint) ? "query" : "mutation"} data`;
+			if (pathSplits[index]?.startsWith("$")) index++;
 		}
 	}
 	while (schema && index < pathSplits.length) {
@@ -2167,13 +2189,16 @@ function resolveEndpointZodSchema({ resolver, schema, meta, tag, fallbackName, c
 		fallbackName,
 		resolver,
 		tag
-	}) : `${resolveZodSchemaName({
-		schema: schemaObject,
-		zodSchema,
-		fallbackName,
-		resolver,
-		tag
-	})}${zodChain}`;
+	}) : (() => {
+		const name = resolveZodSchemaName({
+			schema: schemaObject,
+			zodSchema,
+			fallbackName,
+			resolver,
+			tag
+		});
+		return isNamedZodSchema(name) ? name : name + zodChain;
+	})();
 	entries.set(metaKey, resolved);
 	return resolved;
 }
@@ -2224,9 +2249,9 @@ function getEndpointParameter({ resolver, param, operationName, isUniqueOperatio
 	if (resolver.options.withDescription && schema) schema.description = (paramObj.description ?? "").trim();
 	const fallbackName = getParamZodSchemaName(getZodSchemaOperationName(operationName, isUniqueOperationName, tag), paramObj.name);
 	let parameterSortingEnumSchemaName = void 0;
-	if (isSortingParameterObject(paramObj)) {
+	if (isSortingParameterObject(paramObj, schema, resolver)) {
 		const enumZodSchemaName = getEnumZodSchemaName(fallbackName, resolver.options.enumSuffix, resolver.options.schemaSuffix);
-		const code = getEnumZodSchemaCodeFromEnumNames(paramObj["x-enumNames"]);
+		const code = getEnumZodSchemaCodeFromEnumNames(getParameterEnumNames(paramObj, schema) ?? []);
 		resolver.setZodSchema(enumZodSchemaName, code, tag);
 		parameterSortingEnumSchemaName = enumZodSchemaName;
 	}
@@ -2379,11 +2404,23 @@ function getEndpointsFromOpenAPIDoc(resolver) {
 						endpoint.response = responseZodSchema;
 						endpoint.responseObject = responseObj;
 						endpoint.responseDescription = responseObj?.description;
-					} else if (statusCode !== "default" && !Number.isNaN(status) && isErrorStatus(status)) endpoint.errors.push({
-						zodSchema: responseZodSchema,
-						status,
-						description: responseObj?.description
-					});
+					} else if (statusCode !== "default" && !Number.isNaN(status) && isErrorStatus(status)) {
+						const rawSchema = schemaObject;
+						const domainStr = rawSchema["x-domain-error-domain"];
+						const domainName = rawSchema["x-domain-error-name"];
+						const codeEnumArr = ((rawSchema?.properties)?.code)?.enum;
+						const domainCode = Array.isArray(codeEnumArr) && codeEnumArr.length === 1 && typeof codeEnumArr[0] === "number" ? codeEnumArr[0] : void 0;
+						endpoint.errors.push({
+							zodSchema: responseZodSchema,
+							status,
+							description: responseObj?.description,
+							...typeof domainStr === "string" && domainCode !== void 0 ? { domainError: {
+								domain: domainStr,
+								code: domainCode,
+								...typeof domainName === "string" ? { name: domainName } : {}
+							} } : {}
+						});
+					}
 				} else {
 					const status = Number(statusCode);
 					const responseZodSchema = VOID_SCHEMA;
@@ -2579,6 +2616,7 @@ function resolveExtractedEnumZodSchemaTags(resolver) {
 //#endregion
 //#region src/generators/core/zod/enumExtraction/updateExtractedEnumZodSchemaData.ts
 function updateExtractedEnumZodSchemaData({ schema, nameSegments = [], includeSelf, ...params }) {
+	if (!isReferenceObject(schema) && schema?.["x-domain-error-domain"]) return;
 	if (includeSelf) handleExtractedEnumZodSchemaDataUpdate({
 		schema,
 		nameSegments,
@@ -3048,7 +3086,7 @@ function sortZodSchemasByTopology(resolver, zodSchemas) {
 function getDataFromOpenAPIDoc(openApiDoc, options, profiler) {
 	const p = profiler ?? new Profiler(false);
 	const resolver = p.runSync("data.resolver.init", () => new SchemaResolver(openApiDoc, options, p));
-	const endpoints = p.runSync("data.endpoints.extract", () => getEndpointsFromOpenAPIDoc(resolver, p));
+	const endpoints = p.runSync("data.endpoints.extract", () => getEndpointsFromOpenAPIDoc(resolver));
 	const zodSchemasFromDocSchemas = p.runSync("data.zod.extract", () => getZodSchemasFromOpenAPIDoc(resolver, p));
 	let zodSchemas = {
 		...zodSchemasFromDocSchemas.zodSchemas,
@@ -3261,9 +3299,9 @@ function renderWorkspaceAclHook({ resolver, endpoint }) {
 	const objectRequired = abilityConditionsTypes.some((propertyType) => propertyType.required && !workspaceConditionNameSet.has(propertyType.name));
 	const objectParams = abilityConditionsTypes.map((propertyType) => {
 		const isWorkspaceCondition = workspaceConditionNameSet.has(propertyType.name);
-		return `${propertyType.name}${propertyType.required && !isWorkspaceCondition ? "" : "?"}: ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")}, `;
+		return `${propertyType.name}${propertyType.required && !isWorkspaceCondition ? "" : "?"}: ${renderConditionType(resolver, endpoint, propertyType)}, `;
 	}).join("");
-	const contextType = abilityConditionsTypes.filter((propertyType) => workspaceConditionNameSet.has(propertyType.name)).map((propertyType) => `${propertyType.name}?: ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")}`).join("; ");
+	const contextType = abilityConditionsTypes.filter((propertyType) => workspaceConditionNameSet.has(propertyType.name)).map((propertyType) => `${propertyType.name}?: ${renderConditionType(resolver, endpoint, propertyType)}`).join("; ");
 	const contextBindings = workspaceConditionNames.map((name) => `${name}: ${name}Workspace`).join(", ");
 	const lines = [];
 	lines.push(`export const use${capitalize(getAbilityFunctionName(endpoint))} = (`);
@@ -3289,15 +3327,15 @@ function renderAbilityFunction({ resolver, endpoint }) {
 	lines.push("/**");
 	lines.push(` * Use for ${abilityQuery} ability. ${hasConditions ? "For global ability, omit the object parameter." : ""}${getAbilityDescription(endpoint) ? "" : ""}`);
 	if (getAbilityDescription(endpoint)) lines.push(` * @description ${getAbilityDescription(endpoint)}`);
-	if (hasConditions) for (const propertyType of abilityConditionsTypes) lines.push(` * @param { ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")} } object.${propertyType.name} ${propertyType.name} from ${propertyType.info}`);
+	if (hasConditions) for (const propertyType of abilityConditionsTypes) lines.push(` * @param { ${renderConditionType(resolver, endpoint, propertyType)} } object.${propertyType.name} ${propertyType.name} from ${propertyType.info}`);
 	lines.push(` * @returns { AbilityTuple } An ability tuple indicating the user's ability to use ${abilityQuery}`);
 	lines.push(" */");
 	lines.push(`export const ${getAbilityFunctionName(endpoint)} = (`);
-	if (hasConditions) lines.push(`  object?: { ${abilityConditionsTypes.map((propertyType) => `${propertyType.name}${propertyType.required ? "" : "?"}: ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")}, `).join("")} } `);
+	if (hasConditions) lines.push(`  object?: { ${abilityConditionsTypes.map((propertyType) => `${propertyType.name}${propertyType.required ? "" : "?"}: ${renderConditionType(resolver, endpoint, propertyType)}, `).join("")} } `);
 	lines.push(") => [");
 	lines.push(`  "${getAbilityAction(endpoint)}",`);
 	lines.push(`  ${hasConditions ? `object ? subject("${getAbilitySubject(endpoint)}", object) : "${getAbilitySubject(endpoint)}"` : `"${getAbilitySubject(endpoint)}"`}`);
-	lines.push(`] as ${CASL_ABILITY_BINDING.abilityTuple}<"${getAbilityAction(endpoint)}", ${getAbilitySubjectTypes(endpoint).join(" | ")}>;`);
+	lines.push(`] as ${CASL_ABILITY_BINDING.abilityTuple}<"${getAbilityAction(endpoint)}", ${getAbilitySubjectTypes(endpoint, resolver, getEndpointTag(endpoint, resolver.options)).join(" | ")}>;`);
 	const workspaceAclHook = renderWorkspaceAclHook({
 		resolver,
 		endpoint
@@ -3308,6 +3346,9 @@ function renderAbilityFunction({ resolver, endpoint }) {
 	}
 	return lines.join("\n");
 }
+function renderConditionType(resolver, endpoint, propertyType) {
+	return getAbilityConditionType(propertyType, resolver, getEndpointTag(endpoint, resolver.options));
+}
 
 //#endregion
 //#region src/generators/const/buildConfigs.const.ts
@@ -3520,7 +3561,7 @@ function getColumnsConfig(resolver, endpoint) {
 		...acc,
 		[key]: true
 	}), {});
-	const sortableEnumSchemaName = endpoint.parameters.find((param) => param.parameterObject && isSortingParameterObject(param.parameterObject))?.parameterSortingEnumSchemaName;
+	const sortableEnumSchemaName = endpoint.parameters.find((param) => param.parameterSortingEnumSchemaName)?.parameterSortingEnumSchemaName;
 	return {
 		columns: {
 			schema: getImportedZodSchemaName(resolver, zodSchema),
@@ -3835,7 +3876,7 @@ function generateEndpoints({ resolver, data, tag }) {
 		const endpointConfig = renderEndpointConfig(resolver, endpoint, tag);
 		lines.push(`export const ${getEndpointName(endpoint)} = (${endpointParams}${hasAxiosRequestConfig ? `${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
 		lines.push(`    return ${APP_REST_CLIENT_NAME}.${endpoint.method}(`);
-		lines.push(`        { resSchema: ${getImportedZodSchemaName(resolver, endpoint.response, tag)} },`);
+		lines.push(`        { resSchema: ${getImportedZodSchemaName(resolver, endpoint.response, resolver.options.modelsInCommon && resolver.options.splitByTags ? tag : void 0)} },`);
 		lines.push(`        \`${getEndpointPath(endpoint)}\`,`);
 		if (endpointBody) lines.push(`        ${generateParse ? renderEndpointParamParse(resolver, endpointBody, endpointBody.name, tag) : endpointBody.name},`);
 		else if (hasUndefinedEndpointBody) lines.push("        undefined,");
@@ -3859,10 +3900,16 @@ function renderEndpointArgs$1(resolver, endpoint, options) {
 }
 function renderEndpointParamParse(resolver, param, paramName, modelNamespaceTag) {
 	const addOptional = !(param.parameterObject ?? param.bodyObject)?.required && (Boolean(param.parameterSortingEnumSchemaName) || isNamedZodSchema(param.zodSchema));
-	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${addOptional ? ".optional()" : ""}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
+	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${getSortingPresenceChain$1(resolver, param)}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
 	const queryArgs = param.type === "Query" ? `, { type: "query", name: "${paramName}" }` : "";
 	return `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.parse}(${schemaValue}, ${paramName}${queryArgs})`;
 }
+function getSortingPresenceChain$1(resolver, param) {
+	const zodSchemaCode = resolver.getCodeByZodSchemaName(param.zodSchema) ?? param.zodSchema;
+	if (zodSchemaCode.includes(".nullish()")) return ".nullish()";
+	if (zodSchemaCode.includes(".nullable()")) return ".nullable()";
+	return !(param.parameterObject ?? param.bodyObject)?.required ? ".optional()" : "";
+}
 function renderEndpointConfig(resolver, endpoint, modelNamespaceTag) {
 	const endpointConfig = getEndpointConfig(endpoint);
 	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
@@ -4034,6 +4081,10 @@ function renderModelJsDocs({ name, zodSchema, tag, resolver }) {
 const endpointParamMappingCache = /* @__PURE__ */ new WeakMap();
 function generateQueries(params) {
 	const { resolver, data, tag } = params;
+	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;
@@ -4393,10 +4444,16 @@ function renderInlineEndpoints({ resolver, endpoints, tag }) {
 }
 function renderInlineEndpointParamParse(resolver, param, paramName, modelNamespaceTag) {
 	const addOptional = !(param.parameterObject ?? param.bodyObject)?.required && (Boolean(param.parameterSortingEnumSchemaName) || isNamedZodSchema(param.zodSchema));
-	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${addOptional ? ".optional()" : ""}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
+	const schemaValue = param.parameterSortingEnumSchemaName ? `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.sortExp}(${getImportedZodSchemaName(resolver, param.parameterSortingEnumSchemaName, modelNamespaceTag)})${getSortingPresenceChain(resolver, param)}` : `${getImportedZodSchemaName(resolver, param.zodSchema, modelNamespaceTag)}${addOptional ? ".optional()" : ""}`;
 	const queryArgs = param.type === "Query" ? `, { type: "query", name: "${paramName}" }` : "";
 	return `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.parse}(${schemaValue}, ${paramName}${queryArgs})`;
 }
+function getSortingPresenceChain(resolver, param) {
+	const zodSchemaCode = resolver.getCodeByZodSchemaName(param.zodSchema) ?? param.zodSchema;
+	if (zodSchemaCode.includes(".nullish()")) return ".nullish()";
+	if (zodSchemaCode.includes(".nullable()")) return ".nullable()";
+	return !(param.parameterObject ?? param.bodyObject)?.required ? ".optional()" : "";
+}
 function renderInlineEndpointConfig(resolver, endpoint, modelNamespaceTag) {
 	const endpointConfig = getEndpointConfig(endpoint);
 	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
@@ -4448,7 +4505,7 @@ function renderInfiniteQueryOptions({ resolver, endpoint, inlineEndpoints }) {
 	lines.push(`  queryKey: keys.${getEndpointName(endpoint)}Infinite(${endpointArgsWithoutPage}),`);
 	lines.push(`  queryFn: ({ pageParam }: { pageParam: number }) => ${endpointFunction}(${endpointArgsWithPage}${hasAxiosRequestConfig ? `, ${AXIOS_REQUEST_CONFIG_NAME}` : ""}),`);
 	lines.push("  initialPageParam: 1,");
-	lines.push(`  getNextPageParam: ({ ${resolver.options.infiniteQueryResponseParamNames.page}, ${resolver.options.infiniteQueryResponseParamNames.totalItems}, ${resolver.options.infiniteQueryResponseParamNames.limit}: limitParam }) => {`);
+	lines.push(`  getNextPageParam: ({ ${resolver.options.infiniteQueryResponseParamNames.page}, ${resolver.options.infiniteQueryResponseParamNames.totalItems}, ${resolver.options.infiniteQueryResponseParamNames.limit}: limitParam }: Awaited<ReturnType<typeof ${endpointFunction}>>) => {`);
 	lines.push(`    const pageParam = ${resolver.options.infiniteQueryResponseParamNames.page} ?? 1;`);
 	lines.push(`    return pageParam * limitParam < ${resolver.options.infiniteQueryResponseParamNames.totalItems} ? pageParam + 1 : null;`);
 	lines.push("  },");
@@ -4472,9 +4529,10 @@ function renderPrefetchInfiniteQuery({ resolver, endpoint }) {
 		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">): void => {`);
-	lines.push(`  void queryClient.prefetchInfiniteQuery({ ...${getInfiniteQueryOptionsName(endpoint)}(${endpointParams ? `{ ${endpointArgs} }` : ""}${hasAxiosRequestConfig ? `${endpointParams ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""}), ...options });`);
+	lines.push(`  void queryClient.prefetchInfiniteQuery({ ...${getInfiniteQueryOptionsName(endpoint)}(${optionsArgs}), ...(options as {}) });`);
 	lines.push("};");
 	return lines.join("\n");
 }
@@ -4541,6 +4599,27 @@ function renderMutation({ resolver, endpoint, inlineEndpoints, precomputed }) {
 	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 ? mapEndpointParamsToFunctionParams(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,
@@ -4548,7 +4627,7 @@ function renderMutation({ resolver, endpoint, inlineEndpoints, precomputed }) {
 		mode: "mutation",
 		tag
 	}));
-	lines.push(`export const ${getQueryName(endpoint, true)} = (options?: AppMutationOptions<typeof ${endpointFunction}, { ${mutationVariablesType} }>${hasMutationEffects ? ` & ${MUTATION_EFFECTS.optionsType}` : ""}${hasAxiosRequestConfig ? `, ${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
+	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({
@@ -4556,10 +4635,16 @@ function renderMutation({ resolver, endpoint, inlineEndpoints, precomputed }) {
 		paramTypes: workspaceParamTypes,
 		indent: "  "
 	}));
-	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects<typeof ${QUERY_MODULE_ENUM}.${tag}>({ currentModule: ${QUERIES_MODULE_NAME} });`);
+	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects<${QUERY_MODULE_ENUM}.${tag}>({ currentModule: ${QUERIES_MODULE_NAME} });`);
 	lines.push("");
 	lines.push(`  return ${QUERY_HOOKS.mutation}({`);
-	const mutationFnArg = endpointParams ? `{ ${destructuredMutationArgs}${endpoint.mediaUpload ? `${destructuredMutationArgs ? ", " : ""}abortController, onUploadProgress` : ""} }` : "";
+	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,
@@ -4596,12 +4681,18 @@ function renderMutation({ resolver, endpoint, inlineEndpoints, precomputed }) {
 	} 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) {
-			if (destructuredVariables.length > 0) lines.push(`      const { ${destructuredVariables.join(", ")} } = variables;`);
+			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: "      "
@@ -4711,6 +4802,37 @@ export const ${APP_REST_CLIENT_NAME} = new RestClient({
 `;
 }
 
+//#endregion
+//#region src/generators/generate/generateDomainErrors.ts
+function domainToPascalCase(domain) {
+	return domain.split(/[-_]/).map(capitalize).join("");
+}
+function generateDomainErrors({ data }) {
+	const byDomain = /* @__PURE__ */ new Map();
+	for (const { endpoints } of data.values()) for (const endpoint of endpoints) for (const error of endpoint.errors) {
+		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) => a.code - b.code).map(({ code, name, description }) => {
+			return `${description ? `  /** ${description} */\n  ` : "  "}${name ?? `ERROR_${code}`}: ${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 }) {
@@ -4765,6 +4887,20 @@ function getMutationEffectsFiles(data, resolver) {
 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 [{
@@ -4827,7 +4963,7 @@ function generateCodeFromOpenAPIDoc(openApiDoc, options, profiler) {
 			}
 		});
 	});
-	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)));
+	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;
 }
 

package/dist/generator.d.mts

@@ -1,4 +1,4 @@
-import { n as GenerateFileData, t as GenerateOptions } from "./options-C6CNQ6tq.mjs";
+import { n as GenerateFileData, t as GenerateOptions } from "./options-BPAjzilp.mjs";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/generators/types/metadata.d.ts

package/dist/generator.mjs

@@ -1,4 +1,4 @@
-import { _ as getNamespaceName, a as getDataFromOpenAPIDoc, b as isParamMediaTypeAllowed, c as getSchemaTsMetaType, d as getTagImportPath, f as getQueryName, g as invalidVariableNameCharactersToCamel, l as getTsTypeBase, o as isMutation, p as DEFAULT_GENERATE_OPTIONS, s as isQuery, t as generateCodeFromOpenAPIDoc, v as GenerateType, x as formatTag, y as isMediaTypeAllowed } from "./generateCodeFromOpenAPIDoc-BKIXvJIW.mjs";
+import { _ as getNamespaceName, a as getDataFromOpenAPIDoc, b as isParamMediaTypeAllowed, c as getSchemaTsMetaType, d as getTagImportPath, f as getQueryName, g as invalidVariableNameCharactersToCamel, l as getTsTypeBase, o as isMutation, p as DEFAULT_GENERATE_OPTIONS, s as isQuery, t as generateCodeFromOpenAPIDoc, v as GenerateType, x as formatTag, y as isMediaTypeAllowed } from "./generateCodeFromOpenAPIDoc-mALUMd3q.mjs";
 import SwaggerParser from "@apidevtools/swagger-parser";
 
 //#region src/generators/core/getMetadataFromOpenAPIDoc.ts

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { a as GeneralErrorCodes, i as ErrorHandlerOptions, n as ErrorEntry, o as SharedErrorHandler, r as ErrorHandler, t as ApplicationException } from "./error-handling-CvW_FecB.mjs";
-import "./options-C6CNQ6tq.mjs";
-import { t as OpenAPICodegenConfig } from "./config-CKmoJbQB.mjs";
+import { a as ErrorHandler, c as SharedErrorHandler, i as ErrorEntry, n as DomainErrorEntry, o as ErrorHandlerOptions, r as DomainErrorRegistry, s as GeneralErrorCodes, t as ApplicationException } from "./error-handling-B4aYKmyL.mjs";
+import "./options-BPAjzilp.mjs";
+import { t as OpenAPICodegenConfig } from "./config-C1ME3Ay4.mjs";
 import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosResponseHeaders, CreateAxiosDefaults } from "axios";
 import { z } from "zod";
 import "i18next";
@@ -65,7 +65,7 @@ declare class RestClient$1 implements RestClient {
 //#endregion
 //#region src/lib/rest/rest.utils.d.ts
 declare namespace RestUtils {
-  const extractServerResponseCode: (e: unknown) => string | null;
+  const extractServerResponseCode: (e: unknown) => string | number | null;
   const doesServerErrorMessageContain: (e: AxiosError, text: string) => boolean;
   const extractServerErrorMessage: (e: unknown) => string | null;
   const extractContentDispositionFilename: (headers: AxiosResponseHeaders) => string | undefined;
@@ -110,7 +110,7 @@ interface MutationEffectsOptions<TQueryModule extends QueryModule = QueryModule>
   invalidateCurrentModule?: boolean;
   crossTabInvalidation?: boolean;
   invalidationMap?: InvalidationMap<TQueryModule>;
-  invalidateModules?: TQueryModule[];
+  invalidateModules?: QueryModule[];
   invalidateKeys?: QueryKey[];
   preferUpdate?: boolean;
 }
@@ -228,4 +228,4 @@ declare const AuthGuard: ({
   children
 }: PropsWithChildren<AuthGuardProps>) => react.ReactNode;
 //#endregion
-export { type AppInfiniteQueryOptions, type AppMutationOptions, type AppQueryOptions, ApplicationException, AuthContext, AuthGuard, type AuthGuardProps, type ErrorEntry, ErrorHandler, type ErrorHandlerOptions, type GeneralErrorCodes, type RestClient as IRestClient, type InvalidationMap, type InvalidationMapFunc, type MutationEffectsOptions, OpenAPICodegenConfig, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, type QueryModule, type RequestConfig, type RequestInfo, type Response, RestClient$1 as RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources, useMutationEffects, useWorkspaceContext };
+export { type AppInfiniteQueryOptions, type AppMutationOptions, type AppQueryOptions, ApplicationException, AuthContext, AuthGuard, type AuthGuardProps, type DomainErrorEntry, DomainErrorRegistry, type ErrorEntry, ErrorHandler, type ErrorHandlerOptions, type GeneralErrorCodes, type RestClient as IRestClient, type InvalidationMap, type InvalidationMapFunc, type MutationEffectsOptions, OpenAPICodegenConfig, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, type QueryModule, type RequestConfig, type RequestInfo, type Response, RestClient$1 as RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources, useMutationEffects, useWorkspaceContext };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as ns, i as RestUtils, n as ErrorHandler, o as resources, r as SharedErrorHandler, t as ApplicationException } from "./error-handling-DkPY7Asf.mjs";
+import { a as RestUtils, i as SharedErrorHandler, n as DomainErrorRegistry, o as ns, r as ErrorHandler, s as resources, t as ApplicationException } from "./error-handling-nneQaE1_.mjs";
 import { n as OpenApiRouter, t as AuthContext } from "./auth.context-Bu5KW2sI.mjs";
 import axios from "axios";
 import { z } from "zod";
@@ -250,4 +250,4 @@ const AuthGuard = ({ type, redirectTo, children }) => {
 };
 
 //#endregion
-export { ApplicationException, AuthContext, AuthGuard, ErrorHandler, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources, useMutationEffects, useWorkspaceContext };
+export { ApplicationException, AuthContext, AuthGuard, DomainErrorRegistry, ErrorHandler, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources, useMutationEffects, useWorkspaceContext };

package/dist/{options-C6CNQ6tq.d.mts → options-BPAjzilp.d.mts}

@@ -42,7 +42,11 @@ interface QueriesGenerateOptions {
   mutationDefaultOnError?: boolean;
   workspaceContext?: string[];
   prefetchQueries?: boolean;
-  mutationScope?: boolean;
+  mutationScope?: boolean | {
+    include: string[];
+  } | {
+    exclude: string[];
+  };
 }
 interface InfiniteQueriesGenerateOptions {
   infiniteQueries?: boolean;

package/dist/sh.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { C as VALIDATION_ERROR_TYPE_TITLE, S as Profiler, a as getDataFromOpenAPIDoc, m as groupByType, n as getOutputFileName, u as getTagFileName, v as GenerateType } from "./generateCodeFromOpenAPIDoc-BKIXvJIW.mjs";
-import { n as resolveConfig, t as runGenerate } from "./generate.runner-B0iop_CE.mjs";
+import { C as VALIDATION_ERROR_TYPE_TITLE, S as Profiler, a as getDataFromOpenAPIDoc, m as groupByType, n as getOutputFileName, u as getTagFileName, v as GenerateType } from "./generateCodeFromOpenAPIDoc-mALUMd3q.mjs";
+import { n as resolveConfig, t as runGenerate } from "./generate.runner-CeXyATq2.mjs";
 import { createRequire } from "node:module";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -39,7 +39,7 @@ function logBanner(message) {
 * Fetch the version from package.json
 */
 function getVersion() {
-	return "3.0.0-rc.1";
+	return "3.0.0-rc.11";
 }
 
 //#endregion

package/dist/vite.d.mts

@@ -1,5 +1,5 @@
-import { r as GenerateFileFormatter } from "./options-C6CNQ6tq.mjs";
-import { t as OpenAPICodegenConfig } from "./config-CKmoJbQB.mjs";
+import { r as GenerateFileFormatter } from "./options-BPAjzilp.mjs";
+import { t as OpenAPICodegenConfig } from "./config-C1ME3Ay4.mjs";
 import { Plugin } from "vite";
 
 //#region src/vite/openapi-codegen.plugin.d.ts

package/dist/vite.mjs

@@ -1,5 +1,5 @@
-import { S as Profiler } from "./generateCodeFromOpenAPIDoc-BKIXvJIW.mjs";
-import { t as runGenerate } from "./generate.runner-B0iop_CE.mjs";
+import { S as Profiler } from "./generateCodeFromOpenAPIDoc-mALUMd3q.mjs";
+import { t as runGenerate } from "./generate.runner-CeXyATq2.mjs";
 import path from "path";
 
 //#region src/vite/openapi-codegen.plugin.ts

package/dist/zod.d.mts

@@ -1,4 +1,4 @@
-import { r as ErrorHandler } from "./error-handling-CvW_FecB.mjs";
+import { a as ErrorHandler } from "./error-handling-B4aYKmyL.mjs";
 import { z } from "zod";
 
 //#region src/zod.d.ts

package/dist/zod.mjs

@@ -1,4 +1,4 @@
-import { r as SharedErrorHandler } from "./error-handling-DkPY7Asf.mjs";
+import { i as SharedErrorHandler } from "./error-handling-nneQaE1_.mjs";
 import { z } from "zod";
 
 //#region src/zod.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@povio/openapi-codegen-cli",
-  "version": "3.0.0-rc.1",
+  "version": "3.0.0-rc.11",
   "keywords": [
     "codegen",
     "openapi",