@povio/openapi-codegen-cli 2.0.8-rc.5 → 2.0.8-rc.7

package/dist/generateCodeFromOpenAPIDoc-B5lnFNGB.mjs

@@ -0,0 +1,4522 @@
+import fs from "fs";
+import { match } from "ts-pattern";
+import { OpenAPIV3 } from "openapi-types";
+import path from "path";
+import { fileURLToPath } from "url";
+
+//#region src/generators/const/validation.const.ts
+const HTTP_STATUS_CODES = {
+	"100": "Continue",
+	"101": "Switching Protocols",
+	"102": "Processing",
+	"103": "Early Hints",
+	"200": "OK",
+	"201": "Created",
+	"202": "Accepted",
+	"203": "Non-Authoritative Information",
+	"204": "No Content",
+	"205": "Reset Content",
+	"206": "Partial Content",
+	"300": "Ambiguous",
+	"301": "Moved Permanently",
+	"302": "Found",
+	"303": "See Other",
+	"304": "Not Modified",
+	"307": "Temporary Redirect",
+	"308": "Permanent Redirect",
+	"400": "Bad Request",
+	"401": "Unauthorized",
+	"402": "Payment Required",
+	"403": "Forbidden",
+	"404": "Not Found",
+	"405": "Method Not Allowed",
+	"406": "Not Acceptable",
+	"407": "Proxy Authentication Required",
+	"408": "Request Timeout",
+	"409": "Conflict",
+	"410": "Gone",
+	"411": "Length Required",
+	"412": "Precondition Failed",
+	"413": "Payload Too Large",
+	"414": "URI Too Long",
+	"415": "Unsupported Media Type",
+	"416": "Requested Range Not Satisfiable",
+	"417": "Expectation Failed",
+	"418": "I Am a Teapot",
+	"421": "Misdirected Request",
+	"422": "Unprocessable Entity",
+	"424": "Failed Dependency",
+	"428": "Precondition Required",
+	"429": "Too Many Requests",
+	"500": "Internal Server Error",
+	"501": "Not Implemented",
+	"502": "Bad Gateway",
+	"503": "Service Unavailable",
+	"504": "Gateway Timeout",
+	"505": "HTTP Version Not Supported"
+};
+const VALIDATION_ERROR_TYPE_TITLE = {
+	"invalid-schema": "Invalid OpenAPI Schemas",
+	"invalid-operation-id": "Invalid Operation IDs",
+	"missing-path-parameter": "Missing Path Parameters",
+	"not-allowed-inline-enum": "Not Allowed Inline Enums",
+	"not-allowed-circular-schema": "Not Allowed Circular Schemas",
+	"missing-acl-condition-property": "Missing x-acl Condition Properties",
+	"missing-status-code": "Missing HTTP Status Codes",
+	"invalid-status-code": "Invalid HTTP Status Codes",
+	"multiple-success-status-codes": "Multiple Success HTTP Status Codes"
+};
+
+//#endregion
+//#region src/helpers/profile.helper.ts
+function nowMs() {
+	return Number(process.hrtime.bigint()) / 1e6;
+}
+var Profiler = class {
+	entries = /* @__PURE__ */ new Map();
+	constructor(enabled) {
+		this.enabled = enabled;
+	}
+	add(label, elapsedMs) {
+		if (!this.enabled) return;
+		const prev = this.entries.get(label);
+		if (prev) {
+			prev.totalMs += elapsedMs;
+			prev.count += 1;
+			return;
+		}
+		this.entries.set(label, {
+			totalMs: elapsedMs,
+			count: 1
+		});
+	}
+	runSync(label, fn) {
+		if (!this.enabled) return fn();
+		const startMs = nowMs();
+		try {
+			return fn();
+		} finally {
+			this.add(label, nowMs() - startMs);
+		}
+	}
+	async runAsync(label, fn) {
+		if (!this.enabled) return await fn();
+		const startMs = nowMs();
+		try {
+			return await fn();
+		} finally {
+			this.add(label, nowMs() - startMs);
+		}
+	}
+	formatLines() {
+		if (!this.enabled) return [];
+		return Array.from(this.entries.entries()).sort((a, b) => b[1].totalMs - a[1].totalMs).map(([label, entry]) => {
+			const avgMs = entry.totalMs / entry.count;
+			return `${label}: ${entry.totalMs.toFixed(1)}ms (count: ${entry.count}, avg: ${avgMs.toFixed(2)}ms)`;
+		});
+	}
+};
+
+//#endregion
+//#region src/generators/utils/string.utils.ts
+const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+const decapitalize = (str) => str.charAt(0).toLowerCase() + str.slice(1);
+const kebabToCamel = (str) => str.replace(/(-\w)/g, (group) => group[1].toUpperCase());
+const snakeToCamel = (str) => str.replace(/(_\w)/g, (group) => group[1].toUpperCase());
+const nonWordCharactersToCamel = (str) => str.replace(/[\W_]+(\w)?/g, (_, char) => char?.toUpperCase() ?? "");
+const suffixIfNeeded = (text, suffix = "") => text.endsWith(suffix) ? text : `${text}${suffix}`;
+const removeSuffix = (text, suffix) => text.replace(new RegExp(`${suffix}$`), "");
+const getLongestMostCommon = (strs) => {
+	const counter = strs.reduce((acc, str) => ({
+		...acc,
+		[str]: (acc[str] ?? 0) + 1
+	}), {});
+	return Object.entries(counter).toSorted((a, b) => {
+		if (a[1] === b[1]) return b[0].length - a[0].length;
+		return b[1] - a[1];
+	})[0]?.[0];
+};
+const getMostCommonAdjacentCombinationSplit = (strs) => {
+	return getLongestMostCommon(strs.flatMap((str) => getAdjacentStringCombinations(splitByUppercase(capitalize(str)))));
+};
+const splitByUppercase = (str) => {
+	return str.split(/(?<![A-Z])(?=[A-Z])/).filter(Boolean);
+};
+const camelToSpaceSeparated = (text) => splitByUppercase(text).join(" ");
+const getAdjacentStringCombinations = (strs, ignoreStrs = [
+	"dto",
+	"by",
+	"for",
+	"of",
+	"in",
+	"to",
+	"and",
+	"with"
+]) => {
+	const combinations = [];
+	for (let i = 0; i < strs.length; i++) {
+		if (ignoreStrs.includes(strs[i].toLowerCase())) continue;
+		for (let j = i + 1; j <= strs.length; j++) {
+			if (ignoreStrs.includes(strs[j - 1]?.toLowerCase())) continue;
+			combinations.push(strs.slice(i, j).join(""));
+		}
+	}
+	return combinations;
+};
+const removeWord = (source, wordToRemove) => {
+	const singularWordToRemove = wordToRemove.replace(/es$|s$/g, "");
+	const pattern = new RegExp(`(${decapitalize(singularWordToRemove)}|${capitalize(singularWordToRemove)})[a-z]*(?=$|[A-Z])`, "g");
+	return source.replace(pattern, "");
+};
+
+//#endregion
+//#region src/generators/utils/tag.utils.ts
+function formatTag(tag) {
+	return nonWordCharactersToCamel(tag);
+}
+function getOperationTag(operation, options) {
+	const tag = operation.tags?.[0];
+	return formatTag(tag ?? options.defaultTag);
+}
+function getEndpointTag(endpoint, options) {
+	return formatTag((options.splitByTags ? endpoint.tags?.[0] : options.defaultTag) ?? options.defaultTag);
+}
+function isTagExcluded(tag, options) {
+	return options.excludeTags.some((excludeTag) => excludeTag.toLowerCase() === tag.toLowerCase());
+}
+function shouldInlineEndpointsForTag(tag, options) {
+	if (!options.inlineEndpoints) return false;
+	return !(options.inlineEndpointsExcludeModules ?? []).some((moduleName) => formatTag(moduleName).toLowerCase() === tag.toLowerCase());
+}
+
+//#endregion
+//#region src/generators/const/endpoints.const.ts
+const JSON_APPLICATION_FORMAT = "application/json";
+const DEFAULT_HEADERS = {
+	"Content-Type": JSON_APPLICATION_FORMAT,
+	Accept: JSON_APPLICATION_FORMAT
+};
+const BODY_PARAMETER_NAME = "data";
+const AXIOS_DEFAULT_IMPORT_NAME = "axios";
+const AXIOS_REQUEST_CONFIG_NAME = "config";
+const AXIOS_REQUEST_CONFIG_TYPE = "AxiosRequestConfig";
+const AXIOS_IMPORT = {
+	defaultImport: AXIOS_DEFAULT_IMPORT_NAME,
+	bindings: [AXIOS_REQUEST_CONFIG_TYPE],
+	from: "axios"
+};
+
+//#endregion
+//#region src/generators/const/zod.const.ts
+const SCHEMA_SUFFIX = "Schema";
+const ENUM_SUFFIX = "Enum";
+const BODY_SCHEMA_SUFFIX = "Body";
+const PARAM_SCHEMA_SUFFIX = "Param";
+const RESPONSE_SCHEMA_SUFFIX = "Response";
+const ERROR_RESPONSE_SCHEMA_SUFFIX = "ErrorResponse";
+const VOID_SCHEMA = "z.void()";
+const ANY_SCHEMA = "z.any()";
+const BLOB_SCHEMA = "z.instanceof(Blob)";
+const ENUM_SCHEMA = "z.enum";
+const INT_SCHEMA = "z.int()";
+const NUMBER_SCHEMA = "z.number()";
+const STRING_SCHEMA = "z.string()";
+const EMAIL_SCHEMA = "z.email()";
+const URL_SCHEMA = "z.url()";
+const UUID_SCHEMA = "z.uuid()";
+const DATETIME_SCHEMA = "z.iso.datetime({ offset: true })";
+const ZOD_IMPORT = {
+	bindings: ["z"],
+	from: "zod"
+};
+
+//#endregion
+//#region src/generators/utils/js.utils.ts
+const isValidPropertyName = (str) => /^(?:[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+)$/.test(str);
+const invalidVariableNameCharactersToCamel = (str) => str.replace(/^[^a-zA-Z_$]*/g, "").replace(/[^a-zA-Z0-9_$]+(\w)?/g, (_, char) => char?.toUpperCase() ?? "");
+
+//#endregion
+//#region src/generators/utils/openapi-schema.utils.ts
+function isReferenceObject(obj) {
+	return obj != null && Object.prototype.hasOwnProperty.call(obj, "$ref");
+}
+function isSchemaObject(schema) {
+	return !isReferenceObject(schema);
+}
+function isArraySchemaObject(schema) {
+	return schema.type === "array";
+}
+function inferRequiredSchema(schema) {
+	if (!schema.allOf) throw new Error("Function inferRequiredSchema is specialized to handle item with required only in an allOf array.");
+	const [standaloneRequisites, noRequiredOnlyAllof] = schema.allOf.reduce((acc, cur) => {
+		if (isBrokenAllOfItem(cur)) {
+			const required = cur.required;
+			acc[0].push(...required ?? []);
+		} else acc[1].push(cur);
+		return acc;
+	}, [[], []]);
+	const composedRequiredSchema = {
+		properties: standaloneRequisites.reduce((acc, cur) => {
+			acc[cur] = {};
+			return acc;
+		}, {}),
+		type: "object",
+		required: standaloneRequisites
+	};
+	return {
+		noRequiredOnlyAllof,
+		composedRequiredSchema,
+		patchRequiredSchemaInLoop: (prop, getSchemaByRef) => {
+			if (isReferenceObject(prop)) {
+				const refType = getSchemaByRef(prop.$ref);
+				if (refType) composedRequiredSchema.required.forEach((required) => {
+					composedRequiredSchema.properties[required] = refType?.properties?.[required] ?? {};
+				});
+			} else {
+				const properties = prop["properties"] ?? {};
+				composedRequiredSchema.required.forEach((required) => {
+					if (properties[required]) composedRequiredSchema.properties[required] = properties[required] ?? {};
+				});
+			}
+		}
+	};
+}
+const isBrokenAllOfItem = (item) => {
+	return !isReferenceObject(item) && !!item.required && !item.type && !item.properties && !item?.allOf && !item?.anyOf && !item.oneOf;
+};
+
+//#endregion
+//#region src/generators/const/openapi.const.ts
+const COMPLEXITY_THRESHOLD = 2;
+const ALLOWED_PARAM_MEDIA_TYPES = [
+	"application/octet-stream",
+	"multipart/form-data",
+	"application/x-www-form-urlencoded",
+	"*/*"
+];
+const ALLOWED_PATH_IN = [
+	"query",
+	"header",
+	"path"
+];
+const ALLOWED_METHODS = [
+	OpenAPIV3.HttpMethods.GET,
+	OpenAPIV3.HttpMethods.PUT,
+	OpenAPIV3.HttpMethods.POST,
+	OpenAPIV3.HttpMethods.DELETE,
+	OpenAPIV3.HttpMethods.OPTIONS,
+	OpenAPIV3.HttpMethods.HEAD,
+	OpenAPIV3.HttpMethods.PATCH,
+	OpenAPIV3.HttpMethods.TRACE
+];
+const PRIMITIVE_TYPE_LIST = [
+	"string",
+	"number",
+	"integer",
+	"boolean"
+];
+const COMPOSITE_KEYWORDS = [
+	"allOf",
+	"anyOf",
+	"oneOf"
+];
+
+//#endregion
+//#region src/generators/utils/openapi.utils.ts
+const getSchemaRef = (schemaName) => `#/components/schemas/${schemaName}`;
+const autocorrectRef = (ref) => ref[1] === "/" ? ref : "#/" + ref.slice(1);
+const getSchemaNameByRef = (ref) => autocorrectRef(ref).split("/").at(-1);
+function normalizeString(text) {
+	return snakeToCamel(prefixStringStartingWithNumberIfNeeded(text).normalize("NFKD").trim().replace(/\s+/g, "_").replace(/--+/g, "-").replace(/-+/g, "_").replace(/[^\w-]+/g, "_"));
+}
+function wrapWithQuotesIfNeeded(str) {
+	if (/^[a-zA-Z]\w*$/.test(str)) return str;
+	return `"${str}"`;
+}
+function unwrapQuotesIfNeeded(value) {
+	if (typeof value === "string" && value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
+	return value;
+}
+function prefixStringStartingWithNumberIfNeeded(str) {
+	const firstAsNumber = Number(str[0]);
+	if (typeof firstAsNumber === "number" && !Number.isNaN(firstAsNumber)) return "_" + str;
+	return str;
+}
+function pathParamToVariableName(name) {
+	return snakeToCamel(name.replaceAll("_", "#").replaceAll("-", "_")).replaceAll("#", "_");
+}
+const isPrimitiveType = (type) => PRIMITIVE_TYPE_LIST.includes(type);
+function escapeControlCharacters(str) {
+	return str.replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/([\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\uFFFE\uFFFF])/g, (_m, p1) => {
+		const dec = p1.codePointAt();
+		const hex = dec.toString(16);
+		if (dec <= 255) return `\\x${`00${hex}`.slice(-2)}`;
+		return `\\u${`0000${hex}`.slice(-4)}`;
+	}).replace(/\//g, "\\/");
+}
+function isParamMediaTypeAllowed(mediaType) {
+	return mediaType.includes("application/") && mediaType.includes("json") || ALLOWED_PARAM_MEDIA_TYPES.includes(mediaType) || mediaType.includes("text/");
+}
+function isMainResponseStatus(status) {
+	return status >= 200 && status < 300;
+}
+function isErrorStatus(status) {
+	return !(status >= 200 && status < 300);
+}
+function isMediaTypeAllowed(mediaType) {
+	return mediaType.startsWith("application/");
+}
+const PATH_PARAM_WITH_BRACKETS_REGEX = /({\w+})/g;
+const WORD_PRECEDED_BY_NON_WORD_CHARACTER = /[^\w\-]+/g;
+/** @example turns `/media-objects/{id}` into `MediaObjectsById` */
+function pathToVariableName(path) {
+	path = capitalize(kebabToCamel(path.replaceAll("/", "-")).replaceAll("-", ""));
+	const pathParams = [...path.matchAll(PATH_PARAM_WITH_BRACKETS_REGEX)];
+	if (pathParams.length > 0) {
+		const lastPathParam = pathParams.toSorted((a, b) => a.index - b.index)[pathParams.length - 1][0];
+		path = `${path.replace(PATH_PARAM_WITH_BRACKETS_REGEX, "")}By${capitalize(lastPathParam.slice(1, -1))}`;
+	}
+	return path.replace(WORD_PRECEDED_BY_NON_WORD_CHARACTER, "_");
+}
+const MATCHER_REGEX = /{(\b\w+(?:-\w+)*\b)}/g;
+function replaceHyphenatedPath(path) {
+	const matches = path.match(MATCHER_REGEX);
+	if (matches === null) return path.replaceAll(MATCHER_REGEX, ":$1");
+	matches.forEach((match) => {
+		const replacement = pathParamToVariableName(match.replaceAll(MATCHER_REGEX, ":$1"));
+		path = path.replaceAll(match, replacement);
+	});
+	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 isPathExcluded = (path, options) => {
+	if (!options.excludePathRegex) return false;
+	return new RegExp(options.excludePathRegex).test(path);
+};
+
+//#endregion
+//#region src/generators/utils/validation.utils.ts
+function getInvalidSchemaError(message) {
+	return {
+		type: "invalid-schema",
+		message
+	};
+}
+function getInvalidOperationIdError(operationId) {
+	return {
+		type: "invalid-operation-id",
+		message: `Operation ${operationId}`
+	};
+}
+function getMissingPathParameterError(params, path) {
+	return {
+		type: "missing-path-parameter",
+		message: `Path ${path} is missing [${params.map(({ name }) => name).join(", ")}]`
+	};
+}
+function getNotAllowedInlineEnumError(enumProperty) {
+	return {
+		type: "not-allowed-inline-enum",
+		message: `${enumProperty} is missing @IsEnum() and @ApiProperty(enum:, enumName:)`
+	};
+}
+function getMissingAclConditionPropertyError(propertyName, operation, endpoint) {
+	return {
+		type: "missing-acl-condition-property",
+		message: `Condition property ${propertyName} is not found in parameters or body in operation ${getOperationDescriptor(operation, endpoint)}`
+	};
+}
+function getMissingStatusCodeError(statusCode, operation, endpoint) {
+	return {
+		type: "missing-status-code",
+		message: `Missing HTTP status code ${getStatusCodeDescription(statusCode)} in operation ${getOperationDescriptor(operation, endpoint)}`
+	};
+}
+function getInvalidStatusCodeError(statusCode, operation, endpoint) {
+	return {
+		type: "invalid-status-code",
+		message: `Operation ${getOperationDescriptor(operation, endpoint)} expected HTTP status code ${getStatusCodeDescription(statusCode.expected)} but received ${getStatusCodeDescription(statusCode.received)}`
+	};
+}
+function getMultipleSuccessStatusCodesError(statusCodes, operation, endpoint) {
+	return {
+		type: "multiple-success-status-codes",
+		message: `Operation ${getOperationDescriptor(operation, endpoint)} has multiple success HTTP status codes: ${statusCodes.map(getStatusCodeDescription).join(", ")}`
+	};
+}
+function getOperationDescriptor(operation, endpoint) {
+	return operation.operationId ?? `${endpoint.method} ${endpoint.path}`;
+}
+function getStatusCodeDescription(statusCode) {
+	return `${statusCode} (${HTTP_STATUS_CODES[statusCode]})`;
+}
+function groupByType(validationErrors) {
+	return validationErrors.reduce((acc, err) => ({
+		...acc,
+		[err.type]: [...acc[err.type] ?? [], err.message]
+	}), {});
+}
+
+//#endregion
+//#region src/generators/const/package.const.ts
+const PACKAGE_IMPORT_PATH = "@povio/openapi-codegen-cli";
+const ACL_PACKAGE_IMPORT_PATH = "@povio/openapi-codegen-cli/acl";
+
+//#endregion
+//#region src/generators/const/deps.const.ts
+const APP_REST_CLIENT_NAME = "AppRestClient";
+const APP_REST_CLIENT_FILE = {
+	fileName: "app-rest-client",
+	extension: "ts"
+};
+const QUERY_OPTIONS_TYPES = {
+	query: "AppQueryOptions",
+	infiniteQuery: "AppInfiniteQueryOptions",
+	mutation: "AppMutationOptions"
+};
+const TEMPLATE_DATA_FILE_PATH = "src/data";
+const ERROR_HANDLERS = {
+	ErrorHandler: "ErrorHandler",
+	SharedErrorHandler: "SharedErrorHandler"
+};
+const ERROR_HANDLING_IMPORT = {
+	bindings: [ERROR_HANDLERS.ErrorHandler, ERROR_HANDLERS.SharedErrorHandler],
+	from: PACKAGE_IMPORT_PATH
+};
+const ABILITY_CONTEXT = "AbilityContext";
+const ABILITY_CONTEXT_IMPORT = {
+	bindings: [ABILITY_CONTEXT],
+	from: ACL_PACKAGE_IMPORT_PATH
+};
+const BUILDERS_UTILS = {
+	dynamicInputs: "dynamicInputs",
+	dynamicColumns: "dynamicColumns"
+};
+const QUERY_MODULE_ENUM = "QueryModule";
+const QUERY_MODULES_FILE = {
+	fileName: "queryModules",
+	extension: "ts"
+};
+const MUTATION_EFFECTS = {
+	optionsType: "MutationEffectsOptions",
+	hookName: "useMutationEffects",
+	runFunctionName: "runMutationEffects"
+};
+const MUTATION_EFFECTS_FILE = {
+	fileName: "useMutationEffects",
+	extension: "ts"
+};
+const CROSS_TAB_QUERY_INVALIDATION_FILE = {
+	fileName: "useCrossTabQueryInvalidation",
+	extension: "ts"
+};
+const ZOD_EXTENDED = {
+	namespace: "ZodExtended",
+	exports: {
+		parse: "parse",
+		sortExp: "sortExp"
+	}
+};
+const ZOD_EXTENDED_FILE = {
+	fileName: "zod.extended",
+	extension: "ts"
+};
+
+//#endregion
+//#region src/generators/utils/zod-schema.utils.ts
+const getZodSchemaName = (name, schemaSuffix) => suffixIfNeeded(capitalize(normalizeString(name)), schemaSuffix);
+const getEnumZodSchemaName = (name, enumSuffix, schemaSuffix) => suffixIfNeeded(capitalize(normalizeString(name)), `${enumSuffix}${schemaSuffix}`);
+const isNamedZodSchema = (schema) => ["z.", `${ZOD_EXTENDED.namespace}.`].every((searchString) => !schema.startsWith(searchString));
+const isEnumZodSchema = (schema) => schema.startsWith(ENUM_SCHEMA);
+const getZodSchemaOperationName = (operationName, isUniqueOperationName, tag) => isUniqueOperationName ? operationName : `${tag}_${operationName}`;
+const getBodyZodSchemaName = (operationName) => snakeToCamel(`${operationName}_${BODY_SCHEMA_SUFFIX}`);
+const getParamZodSchemaName = (operationName, paramName) => snakeToCamel(`${operationName}_${paramName}${PARAM_SCHEMA_SUFFIX}`);
+const getMainResponseZodSchemaName = (operationName) => snakeToCamel(`${operationName}${RESPONSE_SCHEMA_SUFFIX}`);
+const getErrorResponseZodSchemaName = (operationName, statusCode) => snakeToCamel(`${operationName}_${statusCode}_${ERROR_RESPONSE_SCHEMA_SUFFIX}`);
+function getResponseZodSchemaName({ statusCode, operationName, isUniqueOperationName, tag }) {
+	const status = Number(statusCode);
+	const zodSchemaOperationName = getZodSchemaOperationName(operationName, isUniqueOperationName, tag);
+	if (!isMainResponseStatus(status) && statusCode !== "default" && isErrorStatus(status)) return getErrorResponseZodSchemaName(zodSchemaOperationName, statusCode);
+	return getMainResponseZodSchemaName(zodSchemaOperationName);
+}
+
+//#endregion
+//#region src/generators/utils/endpoint.utils.ts
+const isGetEndpoint = (endpoint) => endpoint.method === OpenAPIV3.HttpMethods.GET;
+const isPaginatedGetEndpoint = (endpoint, options) => isGetEndpoint(endpoint) && Object.values(options.infiniteQueryParamNames).every((infiniteQueryParam) => endpoint.parameters.some((param) => param.name === infiniteQueryParam && param.type === "Query"));
+const isReadAllEndpoint = (endpoint, options) => endpoint.method === OpenAPIV3.HttpMethods.GET && !isPathSegmentParam(endpoint.pathSegments.at(-1)) && isPaginatedGetEndpoint(endpoint, options);
+const isReadEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.GET && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isCreateEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.POST && hasMatchingPathWithoutTrailingParam(endpoint, readAllEndpoint);
+const isUpdateEndpoint = (endpoint, readAllEndpoint) => [OpenAPIV3.HttpMethods.PUT, OpenAPIV3.HttpMethods.PATCH].includes(endpoint.method) && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isDeleteEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.DELETE && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isBulkDeleteEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.DELETE && hasMatchingPathWithoutTrailingParam(endpoint, readAllEndpoint);
+const getPathSegments = (path) => path.split("/").filter(Boolean);
+const isPathSegmentParam = (pathSegment) => pathSegment?.startsWith(":");
+const hasMatchingPath = (endpoint, readAllEndpoint) => readAllEndpoint.pathSegments.every((segment, index) => isPathSegmentParam(segment) && isPathSegmentParam(endpoint.pathSegments[index]) || segment === endpoint.pathSegments[index]);
+const hasMatchingPathWithoutTrailingParam = (endpoint, readAllEndpoint) => endpoint.pathSegments.length === readAllEndpoint.pathSegments.length && hasMatchingPath(endpoint, readAllEndpoint);
+const hasMatchingPathWithTrailingParam = (endpoint, readAllEndpoint) => endpoint.pathSegments.length - 1 === readAllEndpoint.pathSegments.length && isPathSegmentParam(endpoint.pathSegments.at(-1)) && hasMatchingPath(endpoint, readAllEndpoint);
+
+//#endregion
+//#region src/generators/types/generate.ts
+let GenerateType = /* @__PURE__ */ function(GenerateType) {
+	GenerateType["Models"] = "models";
+	GenerateType["Endpoints"] = "endpoints";
+	GenerateType["Queries"] = "queries";
+	GenerateType["Acl"] = "acl";
+	GenerateType["Configs"] = "configs";
+	return GenerateType;
+}({});
+
+//#endregion
+//#region src/generators/utils/namespace.utils.ts
+const getNamespaceName = ({ type, tag, options }) => `${capitalize(tag)}${options.configs[type].namespaceSuffix}`;
+
+//#endregion
+//#region src/generators/const/acl.const.ts
+const ACL_APP_ABILITY_FILE = {
+	fileName: "acl/app.ability",
+	extension: "ts"
+};
+const ACL_APP_ABILITIES = "AppAbilities";
+const ACL_CHECK_FILE = {
+	fileName: "acl/useAclCheck",
+	extension: "ts"
+};
+const ACL_CHECK_HOOK = "useAclCheck";
+const CASL_ABILITY_BINDING = {
+	abilityTuple: "AbilityTuple",
+	pureAbility: "PureAbility",
+	forcedSubject: "ForcedSubject",
+	subjectType: "Subject",
+	subject: "subject"
+};
+const CASL_ABILITY_IMPORT = {
+	bindings: [
+		CASL_ABILITY_BINDING.abilityTuple,
+		CASL_ABILITY_BINDING.pureAbility,
+		CASL_ABILITY_BINDING.forcedSubject,
+		CASL_ABILITY_BINDING.subjectType,
+		CASL_ABILITY_BINDING.subject
+	],
+	from: "@casl/ability"
+};
+
+//#endregion
+//#region src/generators/const/options.const.ts
+const DEFAULT_GENERATE_OPTIONS = {
+	input: "http://localhost:4000/docs-json/",
+	output: "output",
+	incremental: true,
+	splitByTags: true,
+	defaultTag: "Common",
+	excludeTags: [],
+	excludePathRegex: "",
+	excludeRedundantZodSchemas: true,
+	tsNamespaces: true,
+	tsPath: "@/data",
+	importPath: "ts",
+	configs: {
+		[GenerateType.Models]: {
+			outputFileNameSuffix: "models",
+			namespaceSuffix: "Models"
+		},
+		[GenerateType.Endpoints]: {
+			outputFileNameSuffix: "api",
+			namespaceSuffix: "Api"
+		},
+		[GenerateType.Queries]: {
+			outputFileNameSuffix: "queries",
+			namespaceSuffix: "Queries"
+		},
+		[GenerateType.Acl]: {
+			outputFileNameSuffix: "acl",
+			namespaceSuffix: "Acl"
+		},
+		[GenerateType.Configs]: {
+			outputFileNameSuffix: "configs",
+			namespaceSuffix: "Configs"
+		}
+	},
+	baseUrl: "",
+	modelsOnly: false,
+	standalone: false,
+	schemaSuffix: SCHEMA_SUFFIX,
+	enumSuffix: ENUM_SUFFIX,
+	modelsInCommon: false,
+	withDefaultValues: true,
+	extractEnums: true,
+	replaceOptionalWithNullish: false,
+	restClientImportPath: "",
+	errorHandlingImportPath: "",
+	removeOperationPrefixEndingWith: "Controller_",
+	parseRequestParams: true,
+	inlineEndpoints: false,
+	inlineEndpointsExcludeModules: [],
+	queryTypesImportPath: PACKAGE_IMPORT_PATH,
+	axiosRequestConfig: false,
+	mutationEffects: true,
+	workspaceContext: false,
+	infiniteQueries: false,
+	infiniteQueryParamNames: { page: "page" },
+	infiniteQueryResponseParamNames: {
+		page: "page",
+		totalItems: "totalItems",
+		limit: "limit"
+	},
+	acl: true,
+	checkAcl: true,
+	abilityContextGenericAppAbilities: false,
+	abilityContextImportPath: "",
+	builderConfigs: false,
+	filterParamName: "filter",
+	dataResponseParamNames: ["data", "items"],
+	dynamicInputsImportPath: "@povio/ui",
+	dynamicColumnsImportPath: "@povio/ui"
+};
+
+//#endregion
+//#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 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) {
+	if (!schema) return;
+	const { data, onSchema } = options;
+	if (isReferenceObject(schema) && onSchema({
+		type: "reference",
+		schema,
+		data
+	}) === true) return;
+	const schemaObj = schema;
+	if (COMPOSITE_KEYWORDS.some((prop) => prop in schemaObj && schemaObj[prop])) {
+		const schemaObjs = schemaObj.allOf ?? schemaObj.anyOf ?? schemaObj.oneOf ?? [];
+		for (const compositeObj of schemaObjs) {
+			if (onSchema?.({
+				type: "composite",
+				parentSchema: schema,
+				schema: compositeObj,
+				data
+			}) === true) continue;
+			iterateSchema(compositeObj, {
+				data,
+				onSchema
+			});
+		}
+	}
+	if (schemaObj.properties) for (const [propertyName, propertyObj] of Object.entries(schemaObj.properties)) {
+		if (onSchema({
+			type: "property",
+			parentSchema: schema,
+			schema: propertyObj,
+			data,
+			propertyName
+		}) === true) continue;
+		iterateSchema(propertyObj, options);
+	}
+	if (schemaObj.additionalProperties && typeof schemaObj.additionalProperties === "object") {
+		if (onSchema({
+			type: "additionalProperties",
+			parentSchema: schema,
+			schema: schemaObj.additionalProperties,
+			data
+		}) === true) return;
+		iterateSchema(schemaObj.additionalProperties, options);
+	}
+	if (schemaObj.type === "array") {
+		const arrayObj = schema.items;
+		if (onSchema({
+			type: "array",
+			parentSchema: schema,
+			schema: arrayObj,
+			data
+		}) === true) return;
+		iterateSchema(arrayObj, options);
+	}
+}
+
+//#endregion
+//#region src/generators/utils/generate/generate.openapi.utils.ts
+const schemaDescriptionsCache = /* @__PURE__ */ new WeakMap();
+function getSchemaDescriptions(schemaObj) {
+	const cachedSchemaDescriptions = schemaDescriptionsCache.get(schemaObj);
+	if (cachedSchemaDescriptions) return cachedSchemaDescriptions;
+	const schemaDescriptions = [
+		"minimum",
+		"exclusiveMinimum",
+		"maximum",
+		"exclusiveMaximum",
+		"minItems",
+		"minLength",
+		"minProperties",
+		"maxItems",
+		"maxLength",
+		"maxProperties",
+		"default",
+		"example"
+	].filter((key) => schemaObj[key] !== void 0).reduce((acc, key) => [...acc, `${capitalize(camelToSpaceSeparated(key))}: \`${schemaObj[key]}\``], []);
+	schemaDescriptionsCache.set(schemaObj, schemaDescriptions);
+	return schemaDescriptions;
+}
+
+//#endregion
+//#region src/generators/utils/generate/generate.zod.utils.ts
+const getZodSchemaInferedTypeName = (zodSchemaName, options) => removeSuffix(zodSchemaName, options.schemaSuffix);
+const getImportedZodSchemaName = (resolver, zodSchemaName) => {
+	if (!isNamedZodSchema(zodSchemaName)) return zodSchemaName;
+	return `${resolver.options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Models,
+		tag: resolver.getTagByZodSchemaName(zodSchemaName),
+		options: resolver.options
+	})}.` : ""}${zodSchemaName}`;
+};
+const getImportedZodSchemaInferedTypeName = (resolver, zodSchemaName, currentTag) => {
+	if (!isNamedZodSchema(zodSchemaName)) return zodSchemaName === VOID_SCHEMA ? "void" : zodSchemaName;
+	const tag = resolver.getTagByZodSchemaName(zodSchemaName);
+	return `${resolver.options.tsNamespaces && tag !== currentTag ? `${getNamespaceName({
+		type: GenerateType.Models,
+		tag,
+		options: resolver.options
+	})}.` : ""}${getZodSchemaInferedTypeName(zodSchemaName, resolver.options)}`;
+};
+function getZodSchemaType(data) {
+	return data.isEnum ? "enum" : data.schemaObj?.type ?? "object";
+}
+function getZodSchemaDescription(data) {
+	if (!data.schemaObj) return;
+	return [data.schemaObj.description, ...getSchemaDescriptions(data.schemaObj)].filter(Boolean).join(". ");
+}
+function getType(resolver, schemaObj, tag) {
+	if (isReferenceObject(schemaObj)) {
+		const zodSchemaName = resolver.getZodSchemaNameByRef(schemaObj.$ref);
+		return zodSchemaName ? getImportedZodSchemaInferedTypeName(resolver, zodSchemaName, tag) : void 0;
+	}
+	if (isArraySchemaObject(schemaObj)) {
+		if (!isReferenceObject(schemaObj.items)) return `${schemaObj.items?.type ?? "unknown"}[]`;
+		const zodSchemaName = resolver.getZodSchemaNameByRef(schemaObj.items.$ref);
+		return zodSchemaName ? `${getImportedZodSchemaInferedTypeName(resolver, zodSchemaName, tag)}[]` : void 0;
+	}
+	if (COMPOSITE_KEYWORDS.some((prop) => prop in schemaObj && schemaObj[prop])) {
+		const schemaObjs = schemaObj.allOf ?? schemaObj.anyOf ?? schemaObj.oneOf ?? [];
+		if (schemaObjs.length > 0) return getType(resolver, schemaObjs[0], tag);
+	}
+	return schemaObj.type;
+}
+function getZodSchemaPropertyDescriptions(resolver, data, tag) {
+	if (!data.schemaObj) return [];
+	const ARRAY_INDEX = "[0]";
+	const ADDITIONAL_PROPERTIES_KEY = "[key]";
+	const properties = {};
+	const onSchema = (schemaData) => {
+		if (schemaData.type === "reference") return true;
+		if (schemaData.type === "composite") return;
+		const segments = [...schemaData.data?.pathSegments ?? []];
+		if (schemaData.type === "array") segments.push(ARRAY_INDEX);
+		else if (schemaData.type === "property") segments.push(schemaData.propertyName);
+		else if (schemaData.type === "additionalProperties") segments.push(ADDITIONAL_PROPERTIES_KEY);
+		if (schemaData.schema && segments[segments.length - 1] !== ARRAY_INDEX) {
+			const resolvedSchema = resolver.resolveObject(schemaData.schema);
+			const schemaDescriptions = [resolvedSchema?.description, ...getSchemaDescriptions(resolvedSchema)].filter(Boolean);
+			const propertyKey = segments.join(".");
+			if (!(properties[propertyKey] && "type" in schemaData.schema && schemaData.schema.type === "object")) {
+				delete properties[propertyKey];
+				properties[propertyKey] = {
+					type: getType(resolver, schemaData.schema, tag) ?? "unknown",
+					description: schemaDescriptions.join(". ")
+				};
+			}
+		}
+		iterateSchema(schemaData.schema, {
+			data: { pathSegments: [...segments] },
+			onSchema
+		});
+		return true;
+	};
+	if ("allOf" in data.schemaObj && data.schemaObj.allOf) data.schemaObj.allOf.forEach((schemaObj) => {
+		if (isReferenceObject(schemaObj)) iterateSchema(resolver.resolveObject(schemaObj), {
+			data: { pathSegments: [] },
+			onSchema
+		});
+	});
+	iterateSchema(data.schemaObj, {
+		data: { pathSegments: [] },
+		onSchema
+	});
+	return properties;
+}
+
+//#endregion
+//#region src/generators/utils/generate/generate.imports.utils.ts
+function getModelsImports({ resolver, tag, zodSchemas = [], zodSchemasAsTypes = [] }) {
+	const type = GenerateType.Models;
+	const getTag = (zodSchemaName) => resolver.getTagByZodSchemaName(zodSchemaName);
+	const zodSchemaImports = getImports({
+		type,
+		tag,
+		entities: zodSchemas,
+		getTag,
+		getEntityName: (zodSchema) => zodSchema,
+		options: resolver.options
+	});
+	const zodSchemaTypeImports = getImports({
+		type,
+		tag,
+		entities: zodSchemasAsTypes,
+		getTag,
+		getEntityName: (zodSchema) => getZodSchemaInferedTypeName(zodSchema, resolver.options),
+		options: resolver.options
+	});
+	return mergeImports(resolver.options, zodSchemaImports, zodSchemaTypeImports);
+}
+function getEndpointsImports({ tag, endpoints, options }) {
+	return getImports({
+		type: GenerateType.Endpoints,
+		tag,
+		entities: endpoints,
+		getTag: (endpoint) => getEndpointTag(endpoint, options),
+		getEntityName: getEndpointName,
+		options
+	});
+}
+function getQueriesImports({ tag, endpoints, options }) {
+	return getImports({
+		type: GenerateType.Queries,
+		tag,
+		entities: endpoints,
+		getTag: (endpoint) => getEndpointTag(endpoint, options),
+		getEntityName: getQueryName,
+		options
+	});
+}
+function getInfiniteQueriesImports({ tag, endpoints, options }) {
+	return getImports({
+		type: GenerateType.Queries,
+		tag,
+		entities: endpoints,
+		getTag: (endpoint) => getEndpointTag(endpoint, options),
+		getEntityName: getInfiniteQueryName,
+		options
+	});
+}
+function getAclImports({ tag, endpoints, options }) {
+	return getImports({
+		type: GenerateType.Acl,
+		tag,
+		entities: endpoints,
+		getTag: (endpoint) => getEndpointTag(endpoint, options),
+		getEntityName: getAbilityFunctionName,
+		options
+	});
+}
+function getImportPath(options, fromRoot = false) {
+	let importPath = options.tsPath;
+	if (options.importPath === "relative") importPath = fromRoot ? "./" : "../";
+	else if (options.importPath === "absolute") importPath = options.output;
+	else if (new RegExp(`${TEMPLATE_DATA_FILE_PATH}`, "g").test(options.output)) importPath = options.output.replace(new RegExp(`.*${TEMPLATE_DATA_FILE_PATH}`, "g"), options.tsPath);
+	return `${importPath}/`.replace(/\/\//g, "/");
+}
+function getImports({ type = GenerateType.Models, tag: currentTag, entities, getTag, getEntityName, options }) {
+	const imports = /* @__PURE__ */ new Map();
+	entities.forEach((entity) => {
+		const tag = type === GenerateType.Models && options.modelsInCommon && options.splitByTags ? currentTag : getTag(entity);
+		if (!imports.has(tag)) {
+			const sameTagDir = currentTag === tag;
+			imports.set(tag, {
+				bindings: [options.tsNamespaces ? getNamespaceName({
+					type,
+					tag,
+					options
+				}) : getEntityName(entity)],
+				from: `${sameTagDir ? "./" : getImportPath(options)}${getTagImportPath({
+					type,
+					tag,
+					includeTagDir: !sameTagDir,
+					options
+				})}`
+			});
+		} else if (!options.tsNamespaces) imports.get(tag).bindings.push(getEntityName(entity));
+	});
+	return Array.from(imports.values());
+}
+function mergeImports(options, ...importArrs) {
+	const merged = /* @__PURE__ */ new Map();
+	importArrs.forEach((imports) => {
+		imports.forEach((importItem) => {
+			if (!merged.has(importItem.from)) merged.set(importItem.from, importItem);
+			else if (!options.tsNamespaces) merged.get(importItem.from).bindings.push(...importItem.bindings);
+		});
+	});
+	return Array.from(merged.values()).map((importItem) => ({
+		...importItem,
+		bindings: getUniqueArray(importItem.bindings)
+	}));
+}
+
+//#endregion
+//#region src/generators/utils/generate/generate.utils.ts
+function getFileNameWithExtension({ fileName, extension }) {
+	return `${fileName}.${extension}`;
+}
+function getTagFileNameWithoutExtension({ type, tag, options, includeTagDir = true }) {
+	const outputFileNameSuffix = options.configs[type].outputFileNameSuffix;
+	if (!tag) return outputFileNameSuffix;
+	return `${includeTagDir ? `${decapitalize(tag)}/` : ""}${decapitalize(tag)}.${outputFileNameSuffix}`;
+}
+function getTagImportPath(...args) {
+	return getTagFileNameWithoutExtension(...args);
+}
+function getTagFileName(...args) {
+	return `${getTagFileNameWithoutExtension(...args)}.ts`;
+}
+function getAppRestClientImportPath(options) {
+	if (options.restClientImportPath === DEFAULT_GENERATE_OPTIONS.restClientImportPath) return `${getImportPath(options)}${APP_REST_CLIENT_FILE.fileName}`;
+	return options.restClientImportPath;
+}
+function getQueryModulesImportPath(options) {
+	return `${getImportPath(options)}${QUERY_MODULES_FILE.fileName}`;
+}
+function getQueryTypesImportPath(options) {
+	return options.queryTypesImportPath;
+}
+function getMutationEffectsImportPath(options) {
+	return `${getImportPath(options)}${MUTATION_EFFECTS_FILE.fileName}`;
+}
+function getAclCheckImportPath(options) {
+	return `${getImportPath(options)}${ACL_CHECK_FILE.fileName}`;
+}
+function getZodExtendedImportPath(options) {
+	return `${getImportPath(options)}${ZOD_EXTENDED_FILE.fileName}`;
+}
+function getAppAbilitiesImportPath(options) {
+	return `${getImportPath(options)}${ACL_APP_ABILITY_FILE.fileName}`;
+}
+
+//#endregion
+//#region src/generators/utils/ts.utils.ts
+function primitiveTypeToTsType(type) {
+	return match(type).with("string", () => "string").with("number", () => "number").with("integer", () => "number").with("boolean", () => "boolean").exhaustive();
+}
+function getTsTypeBase({ zodSchemaName, schema, resolver }) {
+	let type = "void";
+	let tag;
+	if (zodSchemaName && isNamedZodSchema(zodSchemaName)) {
+		type = getImportedZodSchemaInferedTypeName(resolver, zodSchemaName);
+		tag = resolver.getTagByZodSchemaName(zodSchemaName);
+	} else if (schema?.type && isPrimitiveType(schema?.type)) type = primitiveTypeToTsType(schema?.type);
+	const splitType = type.split(".");
+	return {
+		type: splitType[splitType.length - 1],
+		...splitType.length > 1 ? { namespace: splitType[0] } : {},
+		...tag ? { importPath: getTagImportPath({
+			type: GenerateType.Models,
+			tag,
+			includeTagDir: true,
+			options: resolver.options
+		}) } : {}
+	};
+}
+function getSchemaTsMetaType({ schema, isCircular, parentTypes, resolver }) {
+	if (!schema) return { metaType: "primitive" };
+	for (const compositeKeyword of COMPOSITE_KEYWORDS) {
+		const compositeObjs = schema[compositeKeyword];
+		if (!compositeObjs) continue;
+		if (compositeObjs.length > 1) {
+			const metaTypes = compositeObjs.map((compositeObj) => {
+				return getSchemaTsMetaType({
+					schema: resolver.resolveObject(compositeObj),
+					parentTypes,
+					resolver
+				});
+			});
+			if (metaTypes.every(({ metaType }) => metaType === "object")) return {
+				metaType: "object",
+				objectProperties: metaTypes.reduce((acc, { objectProperties }) => {
+					const objectPropertyNames = new Set(objectProperties.map(({ name }) => name));
+					return [...acc.filter(({ name }) => !objectPropertyNames.has(name)), ...objectProperties];
+				}, [])
+			};
+			else return {
+				metaType: "composite",
+				[compositeKeyword]: metaTypes
+			};
+		} else schema = resolver.resolveObject(compositeObjs[0]);
+	}
+	if (schema.type === "array") return {
+		metaType: "array",
+		arrayType: getArraySchemaTsType({
+			arraySchema: schema,
+			resolver,
+			parentTypes
+		})
+	};
+	else if ((schema.type === "object" || schema.properties) && isCircular) return {
+		metaType: "object",
+		objectProperties: [],
+		isCircular: true
+	};
+	else if (schema.type === "object" || schema.properties) return {
+		metaType: "object",
+		objectProperties: getSchemaTsProperties({
+			schema,
+			parentTypes,
+			resolver
+		})
+	};
+	return { metaType: "primitive" };
+}
+function getArraySchemaTsType({ arraySchema, parentTypes, resolver }) {
+	let zodSchemaName;
+	let schema;
+	if (isReferenceObject(arraySchema.items)) {
+		const ref = arraySchema.items.$ref;
+		zodSchemaName = resolver.getZodSchemaNameByRef(ref);
+		schema = resolver.getSchemaByRef(ref);
+	} else schema = arraySchema.items;
+	const tsType = getTsTypeBase({
+		zodSchemaName,
+		schema,
+		resolver
+	});
+	const isCircular = getIsCircular(tsType, parentTypes);
+	const tsMetaType = getSchemaTsMetaType({
+		schema,
+		isCircular,
+		parentTypes: [...parentTypes, tsType],
+		resolver
+	});
+	return {
+		...tsType,
+		...tsMetaType
+	};
+}
+function getSchemaTsProperties({ schema, parentTypes, resolver }) {
+	return Object.entries(schema?.properties ?? {}).map(([name, property]) => {
+		const isRequired = schema?.required?.includes(name) ?? false;
+		if (isReferenceObject(property)) {
+			const zodSchemaName = resolver.getZodSchemaNameByRef(property.$ref);
+			const schema = resolver.getSchemaByRef(property.$ref);
+			const tsType = getTsTypeBase({
+				zodSchemaName,
+				schema,
+				resolver
+			});
+			const tsMetaType = getSchemaTsMetaType({
+				schema,
+				isCircular: getIsCircular(tsType, parentTypes),
+				parentTypes: [...parentTypes, tsType],
+				resolver
+			});
+			return {
+				name,
+				isRequired,
+				...tsType,
+				...tsMetaType
+			};
+		} else if (property.type === "array") return {
+			name,
+			isRequired,
+			type: "array",
+			metaType: "array",
+			arrayType: getArraySchemaTsType({
+				arraySchema: property,
+				parentTypes,
+				resolver
+			})
+		};
+		else if (isPrimitiveType(property.type)) return {
+			name,
+			isRequired,
+			type: primitiveTypeToTsType(property.type),
+			metaType: "primitive"
+		};
+		return {
+			name,
+			isRequired,
+			type: "void",
+			metaType: "primitive"
+		};
+	});
+}
+function getIsCircular(tsType, parentTypes) {
+	return parentTypes.findIndex(({ type, namespace }) => type === tsType.type && namespace === tsType.namespace) > -1;
+}
+
+//#endregion
+//#region src/generators/utils/generate/generate.endpoints.utils.ts
+const getEndpointName = (endpoint) => decapitalize(snakeToCamel(endpoint.operationName));
+function getImportedEndpointName(endpoint, options) {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: GenerateType.Endpoints,
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getEndpointName(endpoint)}`;
+}
+const requiresBody = (endpoint) => endpoint.method !== OpenAPIV3.HttpMethods.GET;
+const getEndpointBody$1 = (endpoint) => endpoint.parameters.find((param) => param.type === "Body");
+const hasEndpointConfig = (endpoint, resolver) => {
+	const endpointConfig = getEndpointConfig(endpoint);
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	return Object.keys(endpointConfig).length > 0 || hasAxiosRequestConfig;
+};
+const getEndpointPath = (endpoint) => endpoint.path.replace(/:([a-zA-Z0-9_]+)/g, "${$1}");
+function mapEndpointParamsToFunctionParams(resolver, endpoint, options) {
+	const params = endpoint.parameters.map((param) => {
+		let type = "string";
+		if (isNamedZodSchema(param.zodSchema)) type = getImportedZodSchemaInferedTypeName(resolver, param.zodSchema);
+		else if (param.parameterObject?.schema && isSchemaObject(param.parameterObject.schema)) {
+			const openApiSchemaType = (param.parameterObject?.schema)?.type;
+			if (openApiSchemaType && isPrimitiveType(openApiSchemaType)) type = primitiveTypeToTsType(openApiSchemaType);
+		}
+		return {
+			name: invalidVariableNameCharactersToCamel(param.name),
+			type,
+			paramType: param.type,
+			required: param.parameterObject?.required ?? true,
+			parameterObject: param.parameterObject,
+			bodyObject: param.bodyObject
+		};
+	});
+	if (options?.includeFileParam && endpoint.mediaUpload) params.push({
+		name: "file",
+		type: "File",
+		paramType: "Body",
+		required: false,
+		parameterObject: void 0,
+		bodyObject: void 0
+	});
+	return params.toSorted((a, b) => {
+		if (a.required === b.required) {
+			const sortedParamTypes = [
+				"Path",
+				"Body",
+				"Query",
+				"Header"
+			];
+			return sortedParamTypes.indexOf(a.paramType) - sortedParamTypes.indexOf(b.paramType);
+		}
+		return a.required ? -1 : 1;
+	}).filter((param) => (!options?.excludeBodyParam || param.name !== BODY_PARAMETER_NAME) && (!options?.excludePageParam || param.name !== resolver.options.infiniteQueryParamNames.page) && (!options?.includeOnlyRequiredParams || param.required)).map((param) => ({
+		...param,
+		name: options?.replacePageParam && param.name === resolver.options.infiniteQueryParamNames.page ? "pageParam" : param.name,
+		required: options?.optionalPathParams && param.paramType === "Path" ? false : param.required && (param.paramType === "Path" || !options?.pathParamsRequiredOnly)
+	}));
+}
+function getEndpointConfig(endpoint) {
+	const params = endpoint.parameters.filter((param) => param.type === "Query").map((param) => {
+		const paramPropertyName = isValidPropertyName(param.name) ? param.name : `"${param.name}"`;
+		const paramVariableName = invalidVariableNameCharactersToCamel(param.name);
+		return {
+			...param,
+			name: paramPropertyName,
+			value: paramVariableName
+		};
+	});
+	const headers = {};
+	if (endpoint.requestFormat !== DEFAULT_HEADERS["Content-Type"]) headers["Content-Type"] = `'${endpoint.requestFormat}'`;
+	if (endpoint.responseFormat && endpoint.responseFormat !== DEFAULT_HEADERS.Accept) headers.Accept = `'${endpoint.responseFormat}'`;
+	endpoint.parameters.filter((param) => param.type === "Header").forEach((param) => {
+		headers[param.name] = invalidVariableNameCharactersToCamel(param.name);
+	});
+	return {
+		...params.length > 0 ? { params } : {},
+		...Object.keys(headers).length ? { headers } : {}
+	};
+}
+
+//#endregion
+//#region src/generators/utils/query.utils.ts
+const isQuery = (endpoint) => isGetEndpoint(endpoint);
+const isMutation = (endpoint) => !isGetEndpoint(endpoint) || !!endpoint.mediaDownload;
+const isInfiniteQuery = (endpoint, options) => isPaginatedGetEndpoint(endpoint, options);
+const getDestructuredVariables = (resolver, endpoint, updateQueryEndpoints) => {
+	const requiredUpdateQueryParams = updateQueryEndpoints.reduce((acc, updateEndpoint) => [...acc, ...mapEndpointParamsToFunctionParams(resolver, updateEndpoint, { includeOnlyRequiredParams: true }).map((param) => param.name)], []);
+	return mapEndpointParamsToFunctionParams(resolver, endpoint, {
+		includeOnlyRequiredParams: true,
+		excludeBodyParam: true
+	}).filter((param) => requiredUpdateQueryParams.includes(param.name)).map((param) => param.name);
+};
+
+//#endregion
+//#region src/generators/core/endpoints/getEndpointAcl.ts
+function getEndpointAcl({ resolver, endpoint, operation }) {
+	const acl = operation["x-acl"];
+	return acl?.map((item) => {
+		const conditionsTypes = Object.keys(item.conditions ?? {}).reduce((acc, name) => {
+			const propertyType = getEndpointAclConditionPropertyType({
+				resolver,
+				endpoint,
+				acl,
+				name
+			});
+			if (!propertyType) {
+				resolver.validationErrors.push(getMissingAclConditionPropertyError(name, operation, endpoint));
+				return acc;
+			}
+			return [...acc, propertyType];
+		}, []);
+		return {
+			...item,
+			conditionsTypes
+		};
+	});
+}
+function getEndpointAclConditionPropertyType({ resolver, endpoint, acl, name }) {
+	const conditionPropertyPath = acl[0]?.conditions?.[name];
+	if (!conditionPropertyPath) return;
+	const pathSplits = conditionPropertyPath.replace(/^\$[^.]*\./, "").split(".");
+	let schema = void 0;
+	let required = void 0;
+	let info = void 0;
+	let index = 0;
+	const parameter = endpoint.parameters.find(({ name }) => name === pathSplits[index]);
+	if (parameter) {
+		required = parameter.parameterObject?.required;
+		schema = parameter.parameterObject?.schema;
+		info = `${parameter.name} ${decapitalize(parameter.type)} parameter`;
+		index++;
+	} else {
+		const bodyParameter = endpoint.parameters.find(({ bodyObject }) => !!bodyObject);
+		const matchingMediaType = Object.keys(bodyParameter?.bodyObject?.content ?? {}).find(isParamMediaTypeAllowed);
+		if (matchingMediaType) {
+			schema = bodyParameter?.bodyObject?.content?.[matchingMediaType]?.schema;
+			info = `${isQuery(endpoint) ? "query" : "mutation"} data`;
+		}
+	}
+	while (schema && index < pathSplits.length) {
+		const resolvedSchema = resolver.resolveObject(schema);
+		schema = Object.entries(resolvedSchema.properties ?? {}).find(([key]) => key === pathSplits[index])?.[1];
+		required = resolvedSchema.required?.includes(pathSplits[index]) ?? false;
+		index++;
+	}
+	if (!schema) return;
+	return {
+		name,
+		type: isReferenceObject(schema) ? void 0 : schema.type,
+		zodSchemaName: isReferenceObject(schema) ? resolver.getZodSchemaNameByRef(schema.$ref) : void 0,
+		required,
+		info
+	};
+}
+
+//#endregion
+//#region src/generators/core/zod/getZodChain.ts
+function getZodChain({ schema, meta, options }) {
+	const chains = [];
+	match(schema.type).with("string", () => chains.push(getZodChainableStringValidations(schema))).with("number", "integer", () => chains.push(getZodChainableNumberValidations(schema))).with("array", () => chains.push(getZodChainableArrayValidations(schema))).otherwise(() => void 0);
+	if (typeof schema.description === "string" && schema.description !== "" && options.withDescription) chains.push(`describe(${JSON.stringify(schema.description)})`);
+	const output = chains.concat(getZodChainablePresence({
+		schema,
+		meta,
+		options
+	}), options.withDefaultValues !== false ? getZodChainableDefault(schema) : []).filter(Boolean).join(".");
+	return output ? `.${output}` : "";
+}
+function getZodChainablePresence({ schema, meta, options }) {
+	if (schema.nullable && !meta?.isRequired) return "nullish()";
+	if (schema.nullable || options.replaceOptionalWithNullish && meta?.isParentPartial) return "nullable()";
+	if (!meta?.isRequired) return options.replaceOptionalWithNullish ? "nullish()" : "optional()";
+	return "";
+}
+function getZodChainableDefault(schema) {
+	if (schema.default !== void 0) return `default(${match(schema.type).with("number", "integer", () => unwrapQuotesIfNeeded(schema.default)).otherwise(() => JSON.stringify(schema.default))})`;
+	return "";
+}
+function getZodChainableStringValidations(schema) {
+	const validations = [];
+	if (!schema.enum) {
+		if (schema.minLength !== void 0) validations.push(`min(${schema.minLength})`);
+		if (schema.maxLength !== void 0) validations.push(`max(${schema.maxLength})`);
+	}
+	if (schema.pattern) validations.push(`regex(${formatPatternIfNeeded(schema.pattern)})`);
+	return validations.join(".");
+}
+function formatPatternIfNeeded(pattern) {
+	if (pattern.startsWith("/") && pattern.endsWith("/")) pattern = pattern.slice(1, -1);
+	pattern = escapeControlCharacters(pattern);
+	return `/${pattern}/`;
+}
+function getZodChainableNumberValidations(schema) {
+	const validations = [];
+	if (schema.enum) return "";
+	if (schema.minimum !== void 0) if (schema.exclusiveMinimum === true) validations.push(`gt(${schema.minimum})`);
+	else validations.push(`gte(${schema.minimum})`);
+	else if (typeof schema.exclusiveMinimum === "number") validations.push(`gt(${schema.exclusiveMinimum})`);
+	if (schema.maximum !== void 0) if (schema.exclusiveMaximum === true) validations.push(`lt(${schema.maximum})`);
+	else validations.push(`lte(${schema.maximum})`);
+	else if (typeof schema.exclusiveMaximum === "number") validations.push(`lt(${schema.exclusiveMaximum})`);
+	if (schema.multipleOf) validations.push(`multipleOf(${schema.multipleOf})`);
+	return validations.join(".");
+}
+function getZodChainableArrayValidations(schema) {
+	const validations = [];
+	if (schema.minItems) validations.push(`min(${schema.minItems})`);
+	if (schema.maxItems) validations.push(`max(${schema.maxItems})`);
+	return validations.join(".");
+}
+
+//#endregion
+//#region src/generators/core/zod/getZodSchemaRefs.ts
+function getZodSchemaRefs(resolver, zodSchemaName) {
+	const schemaRef = resolver.getRefByZodSchemaName(zodSchemaName);
+	if (schemaRef) {
+		const refs = Array.from(resolver.dependencyGraph.refsDependencyGraph[schemaRef] ?? []).map((ref) => resolver.getZodSchemaNameByRef(ref));
+		const enumRefs = resolver.getExtractedEnumZodSchemaNamesReferencedBySchemaRef(schemaRef);
+		return [...refs, ...enumRefs];
+	}
+	const zodSchema = resolver.getCompositeZodSchemaByZodSchemaName(zodSchemaName);
+	if (zodSchema) return Array.from(getSchemaRefs(zodSchema)).map((schemaRef) => resolver.getZodSchemaNameByRef(schemaRef));
+	return [];
+}
+function getSchemaRefs(zodSchema, { skipObjectSchema = false } = {}) {
+	return zodSchema.children.reduce((acc, child) => {
+		const ref = child.ref ?? child.enumRef;
+		if (ref) acc.add(ref);
+		if (child.children.length > 0 && (!skipObjectSchema || !isSchemaObject(child.schema) || child.schema.type !== "object")) getSchemaRefs(child).forEach((ref) => acc.add(ref));
+		return acc;
+	}, /* @__PURE__ */ new Set());
+}
+
+//#endregion
+//#region src/generators/utils/math.utils.ts
+const sum = (arr) => arr.reduce((acc, item) => acc + item, 0);
+
+//#endregion
+//#region src/generators/core/openapi/getOpenAPISchemaComplexity.ts
+function getOpenAPISchemaComplexity(current, schema) {
+	if (!schema) return current;
+	if (isReferenceObject(schema)) return current + 2;
+	if (Array.isArray(schema.type)) {
+		if (schema.type.length === 1) return complexityByComposite("oneOf") + getOpenAPISchemaComplexity(current, {
+			...schema,
+			type: schema.type[0]
+		});
+		return current + complexityByComposite("oneOf") + sum(schema.type.map((prop) => getOpenAPISchemaComplexity(0, {
+			...schema,
+			type: prop
+		})));
+	}
+	if (schema.oneOf) {
+		if (schema.oneOf.length === 1) return complexityByComposite("oneOf") + getOpenAPISchemaComplexity(current, schema.oneOf[0]);
+		return current + complexityByComposite("oneOf") + sum(schema.oneOf.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+	}
+	if (schema.anyOf) {
+		if (schema.anyOf.length === 1) return complexityByComposite("anyOf") + getOpenAPISchemaComplexity(current, schema.anyOf[0]);
+		return current + complexityByComposite("anyOf") + sum(schema.anyOf.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+	}
+	if (schema.allOf) {
+		if (schema.allOf.length === 1) return complexityByComposite("allOf") + getOpenAPISchemaComplexity(current, schema.allOf[0]);
+		return current + complexityByComposite("allOf") + sum(schema.allOf.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+	}
+	if (!schema.type) return current;
+	if (isPrimitiveType(schema.type)) {
+		if (schema.enum) return current + complexityByType(schema) + complexityByComposite("enum") + sum(schema.enum.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+		return current + complexityByType(schema);
+	}
+	if (schema.type === "array") {
+		if (schema.items) return complexityByComposite("array") + getOpenAPISchemaComplexity(current, schema.items);
+		return complexityByComposite("array") + getOpenAPISchemaComplexity(current);
+	}
+	if (schema.type === "object" || schema.properties || schema.additionalProperties) {
+		if (schema.properties) {
+			const props = Object.values(schema.properties);
+			current += complexityByComposite("object") + sum(props.map((prop) => getOpenAPISchemaComplexity(0, prop)));
+		} else current += complexityByComposite("empty-object");
+		if (schema.additionalProperties) if (typeof schema.additionalProperties === "object") current += getOpenAPISchemaComplexity(0, schema.additionalProperties);
+		else current += getOpenAPISchemaComplexity(1);
+	}
+	return current;
+}
+function complexityByType(schema) {
+	return match(schema.type).with("string", "number", "integer", "boolean", () => 1).otherwise(() => 0);
+}
+function complexityByComposite(type) {
+	return match(type).with("oneOf", () => 2).with("anyOf", () => 3).with("allOf", () => 2).with("enum", "array", "empty-object", () => 1).with("object", () => 2).otherwise(() => 0);
+}
+
+//#endregion
+//#region src/generators/core/zod/ZodSchema.class.ts
+var ZodSchema = class {
+	code;
+	ref;
+	enumRef;
+	children = [];
+	meta;
+	constructor(schema, resolver, meta = { referencedBy: [] }, enumRef) {
+		this.schema = schema;
+		this.resolver = resolver;
+		if (isReferenceObject(schema)) this.ref = schema.$ref;
+		if (enumRef) this.enumRef = enumRef;
+		this.meta = {
+			...meta,
+			referencedBy: [...meta?.referencedBy ?? []]
+		};
+		if (this.ref) this.meta.referencedBy.push(this);
+	}
+	getCodeString(tag, options) {
+		if (!this.ref && this.code) return this.code;
+		if (!this.ref) throw new Error("Zod schema is missing both ref and code");
+		const zodSchemaName = this.resolver?.getZodSchemaNameByRef(this.ref);
+		if (!zodSchemaName) return this.ref;
+		const zodSchemaTag = this.resolver?.getTagByZodSchemaName(zodSchemaName);
+		if (options?.tsNamespaces && zodSchemaTag && zodSchemaTag !== tag) return `${getNamespaceName({
+			type: GenerateType.Models,
+			tag: zodSchemaTag,
+			options
+		})}.${zodSchemaName}`;
+		return zodSchemaName;
+	}
+	get complexity() {
+		return getOpenAPISchemaComplexity(0, this.schema);
+	}
+	assign(code) {
+		this.code = code;
+		return this;
+	}
+	inherit(parent) {
+		if (parent) parent.children.push(this);
+		return this;
+	}
+};
+function getParentRef(meta) {
+	if (!meta) return;
+	if (meta.parent?.ref) return meta.parent.ref;
+	return getParentRef(meta.parent?.meta);
+}
+
+//#endregion
+//#region src/generators/core/zod/getZodSchema.ts
+/**
+* @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#schemaObject
+* @see https://github.com/colinhacks/zod
+*/
+function getZodSchema({ schema, resolver, meta: inheritedMeta, tag }) {
+	const zodSchema = new ZodSchema(schema, resolver, inheritedMeta);
+	const meta = {
+		parent: zodSchema.inherit(inheritedMeta?.parent),
+		referencedBy: [...zodSchema.meta.referencedBy]
+	};
+	const params = {
+		resolver,
+		meta,
+		tag
+	};
+	if (isReferenceObject(schema)) return getReferenceZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	const arrayZodSchema = getArrayZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (arrayZodSchema) return arrayZodSchema;
+	const oneOfZodSchema = getOneOfZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (oneOfZodSchema) return oneOfZodSchema;
+	const anyOfZodSchema = getAnyOfZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (anyOfZodSchema) return anyOfZodSchema;
+	const allOfZodSchema = getAllOfZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (allOfZodSchema) return allOfZodSchema;
+	const primitiveZodSchema = getPrimitiveZodSchema({
+		schema,
+		zodSchema,
+		resolver,
+		meta,
+		tag
+	});
+	if (primitiveZodSchema) return primitiveZodSchema;
+	const readonly = resolver.options.allReadonly ? ".readonly()" : "";
+	if (isArraySchemaObject(schema)) {
+		if (schema.items) return zodSchema.assign(`z.array(${getZodSchema({
+			...params,
+			schema: schema.items
+		}).getCodeString(tag, resolver.options)}${getZodChain({
+			schema: schema.items,
+			meta: {
+				...meta,
+				isRequired: true
+			},
+			options: resolver.options
+		})})${readonly}`);
+		return zodSchema.assign(`z.array(${ANY_SCHEMA})${readonly}`);
+	}
+	const schemaType = schema.type ? schema.type.toLowerCase() : void 0;
+	if (schemaType === "object" || schema.properties || schema.additionalProperties) {
+		const hasRequiredArray = schema.required && schema.required.length > 0;
+		const isPartial = resolver.options.withImplicitRequiredProps ? false : schema.properties && !schema.required?.length;
+		let properties = "{}";
+		if (schema.properties) properties = `{ ${Object.entries(schema.properties).map(([prop, propSchema]) => {
+			const propMetadata = {
+				...meta,
+				isRequired: isPartial ? true : hasRequiredArray ? schema.required?.includes(prop) : resolver.options.withImplicitRequiredProps,
+				name: prop,
+				isParentPartial: isPartial
+			};
+			let propActualSchema = propSchema;
+			if (isReferenceObject(propSchema) && resolver) {
+				propActualSchema = resolver.getSchemaByRef(propSchema.$ref);
+				if (!propActualSchema) throw new Error(`Schema ${propSchema.$ref} not found`);
+			}
+			const zodSchema = getZodSchema({
+				...params,
+				schema: propSchema,
+				meta: propMetadata
+			});
+			const propZodSchema = zodSchema.getCodeString(tag, resolver.options) + getZodChain({
+				schema: propActualSchema,
+				meta: propMetadata,
+				options: resolver.options
+			});
+			let isCircular = false;
+			const parentRef = getParentRef(inheritedMeta);
+			if (parentRef) isCircular = [...isReferenceObject(propSchema) ? [propSchema.$ref] : [], ...getSchemaRefs(zodSchema, { skipObjectSchema: true })].some((ref) => resolver.dependencyGraph.deepDependencyGraph[ref]?.has(parentRef));
+			return [
+				prop,
+				propZodSchema,
+				isCircular
+			];
+		}).map(([prop, propSchema, isCircular]) => isCircular ? `get ${wrapWithQuotesIfNeeded(prop)}() { return ${propSchema} }` : `${wrapWithQuotesIfNeeded(prop)}: ${propSchema}`).join(", ")} }`;
+		let additionalPropsSchema = "";
+		if (schema.additionalProperties) additionalPropsSchema = `.catchall(${typeof schema.additionalProperties === "object" && Object.keys(schema.additionalProperties).length > 0 ? getZodSchema({
+			...params,
+			schema: schema.additionalProperties
+		}).getCodeString(tag, resolver.options) + getZodChain({
+			schema: schema.additionalProperties,
+			meta: {
+				...meta,
+				isRequired: true
+			},
+			options: resolver.options
+		}) : ANY_SCHEMA})`;
+		const zodObject = `z.object(${properties})${isPartial ? ".partial()" : ""}${additionalPropsSchema}${readonly}`;
+		return zodSchema.assign(zodObject);
+	}
+	if (schemaType === "any") return zodSchema.assign(ANY_SCHEMA);
+	if (schemaType === "null") return zodSchema.assign("z.null()");
+	if (!schemaType) return zodSchema.assign("z.unknown()");
+	throw new Error(`Unsupported schema type: ${schemaType}`);
+}
+function getReferenceZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isReferenceObject(schema)) return;
+	const refsPath = zodSchema.meta.referencedBy.slice(0, -1).map((prev) => prev.ref ? resolver.getZodSchemaNameByRef(prev.ref) ?? prev.ref : void 0).filter(Boolean);
+	const zodSchemaName = resolver.getZodSchemaNameByRef(schema.$ref);
+	if (refsPath.length > 1 && refsPath.includes(zodSchemaName)) return zodSchema.assign(resolver.getCodeByZodSchemaName(zodSchema.ref));
+	let result = resolver.getCodeByZodSchemaName(schema.$ref);
+	if (!result) {
+		const actualSchema = resolver.getSchemaByRef(schema.$ref);
+		if (!actualSchema) throw new Error(`Schema ${schema.$ref} not found`);
+		result = getZodSchema({
+			schema: actualSchema,
+			resolver,
+			meta,
+			tag
+		}).getCodeString(tag, resolver.options);
+	}
+	if (resolver.getCodeByZodSchemaName(zodSchemaName)) return zodSchema;
+	resolver.setZodSchema(zodSchemaName, result, tag);
+	return zodSchema;
+}
+function getOneOfZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !schema.oneOf) return;
+	if (schema.oneOf.length === 1) {
+		const type = getZodSchema({
+			schema: schema.oneOf[0],
+			resolver,
+			meta,
+			tag
+		});
+		return zodSchema.assign(type.getCodeString(tag, resolver.options));
+	}
+	const hasMultipleAllOf = schema.oneOf?.some((obj) => isSchemaObject(obj) && (obj?.allOf || []).length > 1);
+	if (schema.discriminator && !hasMultipleAllOf) {
+		const propertyName = schema.discriminator.propertyName;
+		return zodSchema.assign(`
+      z.discriminatedUnion("${propertyName}", [${schema.oneOf.map((schema) => getZodSchema({
+			schema,
+			resolver,
+			meta,
+			tag
+		}).getCodeString(tag, resolver.options)).join(", ")}])
+        `);
+	}
+	return zodSchema.assign(`z.union([${schema.oneOf.map((schema) => getZodSchema({
+		schema,
+		resolver,
+		meta,
+		tag
+	}).getCodeString(tag, resolver.options)).join(", ")}])`);
+}
+function getArrayZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !Array.isArray(schema.type)) return;
+	if (schema.type.length === 1) return getZodSchema({
+		schema: {
+			...schema,
+			type: schema.type[0]
+		},
+		resolver,
+		meta,
+		tag
+	});
+	return zodSchema.assign(`z.union([${schema.type.map((prop) => getZodSchema({
+		schema: {
+			...schema,
+			type: prop
+		},
+		resolver,
+		meta,
+		tag
+	}).getCodeString(tag, resolver.options)).join(", ")}])`);
+}
+function getAnyOfZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !schema.anyOf) return;
+	if (schema.anyOf.length === 1) {
+		const type = getZodSchema({
+			schema: schema.anyOf[0],
+			resolver,
+			meta,
+			tag
+		});
+		return zodSchema.assign(type.getCodeString(tag, resolver.options));
+	}
+	const types = schema.anyOf.map((schema) => getZodSchema({
+		schema,
+		resolver,
+		meta,
+		tag
+	})).map((type) => type.getCodeString(tag, resolver.options)).join(", ");
+	return zodSchema.assign(`z.union([${types}])`);
+}
+function getAllOfZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema) || !schema.allOf) return;
+	if (schema.allOf.length === 1) {
+		const type = getZodSchema({
+			schema: schema.allOf[0],
+			resolver,
+			meta,
+			tag
+		});
+		return zodSchema.assign(type.getCodeString(tag, resolver.options));
+	}
+	const { patchRequiredSchemaInLoop, noRequiredOnlyAllof, composedRequiredSchema } = inferRequiredSchema(schema);
+	const types = noRequiredOnlyAllof.map((schema) => {
+		const type = getZodSchema({
+			schema,
+			resolver,
+			meta,
+			tag
+		});
+		if (resolver) patchRequiredSchemaInLoop(schema, resolver.getSchemaByRef.bind(resolver));
+		return type;
+	});
+	if (composedRequiredSchema.required.length) types.push(getZodSchema({
+		schema: composedRequiredSchema,
+		resolver,
+		meta,
+		tag
+	}));
+	const first = types.at(0);
+	const rest = types.slice(1).map((type) => `...${type.getCodeString(tag, resolver.options)}.shape`).join(", ");
+	return zodSchema.assign(`z.object({ ...${first.getCodeString(tag, resolver.options)}.shape, ${rest} })`);
+}
+function getPrimitiveZodSchema({ schema, zodSchema, resolver, meta, tag }) {
+	if (!isSchemaObject(schema)) return;
+	const schemaType = schema.type ? schema.type.toLowerCase() : void 0;
+	if (schemaType && isPrimitiveType(schemaType)) {
+		if (schema.enum) {
+			if (schemaType === "string") return getEnumZodSchema({
+				schema,
+				zodSchema,
+				resolver,
+				meta,
+				tag
+			});
+			if (schema.enum.some((e) => typeof e === "string")) return zodSchema.assign("z.never()");
+			if (schema.enum.length === 1) {
+				const value = schema.enum[0];
+				return zodSchema.assign(`z.literal(${value === null ? "null" : value})`);
+			}
+			return zodSchema.assign(`z.union([${schema.enum.map((value) => `z.literal(${value === null ? "null" : value})`).join(", ")}])`);
+		}
+		return zodSchema.assign(match(schemaType).with("integer", () => match(schema.type).with("integer", () => INT_SCHEMA).otherwise(() => NUMBER_SCHEMA)).with("string", () => match(schema.format).with("binary", () => BLOB_SCHEMA).with("email", () => EMAIL_SCHEMA).with("hostname", "uri", () => URL_SCHEMA).with("uuid", () => UUID_SCHEMA).with("date-time", () => DATETIME_SCHEMA).otherwise(() => STRING_SCHEMA)).otherwise((type) => `z.${type}()`));
+	}
+}
+function getEnumZodSchema({ resolver, schema, zodSchema, meta, tag }) {
+	if (!isSchemaObject(schema)) return;
+	const code = getEnumZodSchemaCode(schema);
+	if (!resolver.options.extractEnums) return zodSchema.assign(code);
+	const enumZodSchema = resolver.getEnumZodSchemaDataByCode(code);
+	if (enumZodSchema) {
+		if (zodSchema.meta.parent?.ref === resolver.getRefByZodSchemaName(enumZodSchema.zodSchemaName)) return zodSchema.assign(enumZodSchema.code);
+		return new ZodSchema({ $ref: resolver.getRefByZodSchemaName(enumZodSchema.zodSchemaName) }, resolver, meta).inherit(zodSchema).assign(code);
+	}
+	const extractedEnumZodSchema = resolver.getExtractedEnumZodSchemaDataByCode(code);
+	if (!extractedEnumZodSchema) return zodSchema.assign(code);
+	if (!extractedEnumZodSchema.zodSchemaName || !extractedEnumZodSchema.tag) throw new Error(`Enum zod schema name or tag not resolved for code: ${code}`);
+	const namespacePrefix = resolver.options.tsNamespaces && extractedEnumZodSchema.tag !== tag ? `${getNamespaceName({
+		type: GenerateType.Models,
+		tag: extractedEnumZodSchema.tag,
+		options: resolver.options
+	})}.` : "";
+	return zodSchema.assign(`${namespacePrefix}${extractedEnumZodSchema.zodSchemaName}`);
+}
+function getEnumZodSchemaCode(schema) {
+	return `${ENUM_SCHEMA}([${schema.enum?.map((value) => value === null ? "null" : `"${value}"`).join(", ")}])`;
+}
+function getEnumZodSchemaCodeFromEnumNames(enumNames) {
+	return `${ENUM_SCHEMA}([${enumNames.map((value) => `"${value}"`).join(", ")}])`;
+}
+
+//#endregion
+//#region src/generators/core/zod/resolveZodSchemaName.ts
+const resolverResolveZodSchemaNameCache = /* @__PURE__ */ new WeakMap();
+function resolveZodSchemaName({ schema, zodSchema, fallbackName, resolver, tag }) {
+	const result = zodSchema.getCodeString();
+	const cacheKey = `${zodSchema.ref ?? ""}|${fallbackName ?? ""}|${tag}|${zodSchema.complexity}|${result}`;
+	let cacheForResolver = resolverResolveZodSchemaNameCache.get(resolver);
+	if (!cacheForResolver) {
+		cacheForResolver = /* @__PURE__ */ new Map();
+		resolverResolveZodSchemaNameCache.set(resolver, cacheForResolver);
+	}
+	const cachedName = cacheForResolver.get(cacheKey);
+	if (cachedName) return cachedName;
+	if ((!isNamedZodSchema(result) || zodSchema.ref === void 0) && fallbackName) {
+		if (zodSchema.complexity < COMPLEXITY_THRESHOLD) return result;
+		const zodSchemaName = getZodSchemaName(fallbackName, resolver.options.schemaSuffix);
+		while (resolver.getCodeByZodSchemaName(zodSchemaName)) if (resolver.getZodSchemaNamesByCompositeCode(result)?.includes(zodSchemaName)) return zodSchemaName;
+		else if (resolver.getCodeByZodSchemaName(zodSchemaName) === zodSchemaName) return zodSchemaName;
+		else throw new Error(`Can't uniquely resolve zod schema name: ${zodSchemaName}`);
+		resolver.setZodSchema(zodSchemaName, result, tag);
+		resolver.addZodSchemaForCompositeCode(result, zodSchema, zodSchemaName, schema);
+		cacheForResolver.set(cacheKey, zodSchemaName);
+		return zodSchemaName;
+	}
+	let resolvedSchema = resolver.getCodeByZodSchemaName(result);
+	if (!resolvedSchema && zodSchema.ref) resolvedSchema = resolver.getCodeByZodSchemaName(resolver.getZodSchemaNameByRef(zodSchema.ref));
+	if (zodSchema.ref && resolvedSchema) {
+		if (getOpenAPISchemaComplexity(0, resolver.getSchemaByRef(zodSchema.ref)) < COMPLEXITY_THRESHOLD) {
+			const resolvedName = resolver.getCodeByZodSchemaName(result);
+			cacheForResolver.set(cacheKey, resolvedName);
+			return resolvedName;
+		}
+		cacheForResolver.set(cacheKey, result);
+		return result;
+	}
+	if (zodSchema.ref) {
+		const resolvedRefName = resolver.getZodSchemaNameByRef(zodSchema.ref);
+		cacheForResolver.set(cacheKey, resolvedRefName);
+		return resolvedRefName;
+	}
+	throw new Error(`Invalid ref: ${zodSchema.ref}`);
+}
+
+//#endregion
+//#region src/generators/core/endpoints/resolveEndpointZodSchema.ts
+const resolverEndpointZodSchemaCache = /* @__PURE__ */ new WeakMap();
+function getResolverSchemaCache(resolver) {
+	let schemaCache = resolverEndpointZodSchemaCache.get(resolver);
+	if (!schemaCache) {
+		schemaCache = {
+			byObject: /* @__PURE__ */ new WeakMap(),
+			byRef: /* @__PURE__ */ new Map()
+		};
+		resolverEndpointZodSchemaCache.set(resolver, schemaCache);
+	}
+	return schemaCache;
+}
+function getOrCreateSchemaEntries(schemaCache, schema) {
+	if (isReferenceObject(schema)) {
+		let entries = schemaCache.byRef.get(schema.$ref);
+		if (!entries) {
+			entries = /* @__PURE__ */ new Map();
+			schemaCache.byRef.set(schema.$ref, entries);
+		}
+		return entries;
+	}
+	let entries = schemaCache.byObject.get(schema);
+	if (!entries) {
+		entries = /* @__PURE__ */ new Map();
+		schemaCache.byObject.set(schema, entries);
+	}
+	return entries;
+}
+function resolveEndpointZodSchema({ resolver, schema, meta, tag, fallbackName, composeBeforeResolve }) {
+	const entries = getOrCreateSchemaEntries(getResolverSchemaCache(resolver), schema);
+	const isRefSchema = isReferenceObject(schema);
+	const normalizedFallbackName = isRefSchema ? "" : fallbackName ?? "";
+	const normalizedTag = isRefSchema ? "" : tag;
+	const metaKey = `required:${Boolean(meta.isRequired)}|name:${meta.name ?? ""}|parentPartial:${Boolean(meta.isParentPartial)}|fallback:${normalizedFallbackName}|tag:${normalizedTag}|compose:${composeBeforeResolve ? 1 : 0}`;
+	const cached = entries.get(metaKey);
+	if (cached) return cached;
+	const zodSchema = getZodSchema({
+		schema,
+		resolver,
+		meta,
+		tag
+	});
+	const schemaObject = resolver.resolveObject(schema);
+	const zodChain = getZodChain({
+		schema: schemaObject,
+		meta: zodSchema.meta,
+		options: resolver.options
+	});
+	const resolved = composeBeforeResolve ? resolveZodSchemaName({
+		schema: schemaObject,
+		zodSchema: zodSchema.assign(zodSchema.getCodeString(tag) + zodChain),
+		fallbackName,
+		resolver,
+		tag
+	}) : `${resolveZodSchemaName({
+		schema: schemaObject,
+		zodSchema,
+		fallbackName,
+		resolver,
+		tag
+	})}${zodChain}`;
+	entries.set(metaKey, resolved);
+	return resolved;
+}
+
+//#endregion
+//#region src/generators/core/endpoints/getEndpointBody.ts
+function getEndpointBody({ resolver, operation, operationName, isUniqueOperationName, tag }) {
+	const requestBodyObj = resolver.resolveObject(operation.requestBody);
+	if (!requestBodyObj) return;
+	const matchingMediaType = Object.keys(requestBodyObj.content ?? {}).find(isParamMediaTypeAllowed);
+	if (!matchingMediaType) return;
+	const schema = requestBodyObj.content?.[matchingMediaType]?.schema;
+	if (!schema) return;
+	const zodSchema = resolveEndpointZodSchema({
+		resolver,
+		schema,
+		meta: { isRequired: requestBodyObj.required ?? true },
+		tag,
+		fallbackName: getBodyZodSchemaName(getZodSchemaOperationName(operationName, isUniqueOperationName, tag)),
+		composeBeforeResolve: false
+	});
+	return {
+		endpointParameter: {
+			name: BODY_PARAMETER_NAME,
+			type: "Body",
+			description: requestBodyObj.description,
+			zodSchema,
+			bodyObject: requestBodyObj
+		},
+		requestFormat: matchingMediaType
+	};
+}
+
+//#endregion
+//#region src/generators/core/endpoints/getEndpointParameter.ts
+function getEndpointParameter({ resolver, param, operationName, isUniqueOperationName, tag }) {
+	const paramObj = resolver.resolveObject(param);
+	if (!ALLOWED_PATH_IN.includes(paramObj.in)) return;
+	let schema = {};
+	if (paramObj.content) {
+		const mediaTypes = Object.keys(paramObj.content ?? {});
+		const matchingMediaType = mediaTypes.find(isParamMediaTypeAllowed);
+		if (!matchingMediaType) throw new Error(`Unsupported media type for param ${paramObj.name}: ${mediaTypes.join(", ")}`);
+		const mediaTypeObject = paramObj.content?.[matchingMediaType];
+		if (!mediaTypeObject) throw new Error(`No content with media type for param ${paramObj.name}: ${matchingMediaType}`);
+		schema = mediaTypeObject?.schema ?? mediaTypeObject;
+	} else if (paramObj.schema) schema = paramObj.schema;
+	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)) {
+		const enumZodSchemaName = getEnumZodSchemaName(fallbackName, resolver.options.enumSuffix, resolver.options.schemaSuffix);
+		const code = getEnumZodSchemaCodeFromEnumNames(paramObj["x-enumNames"]);
+		resolver.setZodSchema(enumZodSchemaName, code, tag);
+		parameterSortingEnumSchemaName = enumZodSchemaName;
+	}
+	const zodSchemaName = resolveEndpointZodSchema({
+		resolver,
+		schema,
+		meta: { isRequired: paramObj.in === "path" ? true : paramObj.required ?? false },
+		tag,
+		fallbackName,
+		composeBeforeResolve: true
+	});
+	return {
+		name: match(paramObj.in).with("path", () => pathParamToVariableName(paramObj.name)).otherwise(() => paramObj.name),
+		type: match(paramObj.in).with("header", () => "Header").with("query", () => "Query").with("path", () => "Path").run(),
+		zodSchema: zodSchemaName,
+		parameterObject: paramObj,
+		parameterSortingEnumSchemaName
+	};
+}
+
+//#endregion
+//#region src/generators/core/endpoints/getEndpointsFromOpenAPIDoc.ts
+function getEndpointsFromOpenAPIDoc(resolver, profiler) {
+	const endpoints = [];
+	const p = profiler ?? new Profiler(false);
+	for (const context of resolver.getOperationContexts()) endpoints.push(buildEndpointFromOperationContext(resolver, context, p));
+	return endpoints;
+}
+function buildEndpointFromOperationContext(resolver, context, profiler) {
+	const p = profiler ?? new Profiler(false);
+	const { path, method, operation, operationName, isUniqueOperationName, tag, parameters, responses } = context;
+	const invalidOperationId = operation.operationId && operation.operationId !== invalidVariableNameCharactersToCamel(operation.operationId);
+	if (operation.operationId && invalidOperationId) resolver.validationErrors.push(getInvalidOperationIdError(operation.operationId));
+	const endpoint = {
+		method,
+		path: replaceHyphenatedPath(path),
+		operationName,
+		description: operation.description,
+		summary: operation.summary,
+		tags: operation.tags?.map(formatTag),
+		requestFormat: JSON_APPLICATION_FORMAT,
+		parameters: [],
+		response: "",
+		errors: [],
+		responseStatusCodes: [],
+		mediaUpload: !!operation["x-media-upload"],
+		mediaDownload: !!operation["x-media-download"]
+	};
+	p.runSync("endpoints.requestBody", () => {
+		if (operation.requestBody) {
+			const body = getEndpointBody({
+				resolver,
+				operation,
+				operationName,
+				isUniqueOperationName,
+				tag
+			});
+			if (body) {
+				endpoint.parameters.push(body.endpointParameter);
+				endpoint.requestFormat = body.requestFormat;
+			}
+		}
+	});
+	p.runSync("endpoints.params", () => {
+		for (const param of parameters) {
+			const endpointParameter = getEndpointParameter({
+				resolver,
+				param,
+				operationName,
+				isUniqueOperationName,
+				tag
+			});
+			if (endpointParameter) endpoint.parameters.push(endpointParameter);
+		}
+	});
+	p.runSync("endpoints.pathParams", () => {
+		const missingPathParameters = getMissingPathParameters(endpoint);
+		missingPathParameters.forEach((pathParam) => {
+			endpoint.parameters.push(pathParam);
+		});
+		if (missingPathParameters.length > 0) resolver.validationErrors.push(getMissingPathParameterError(missingPathParameters, path));
+	});
+	p.runSync("endpoints.responses", () => {
+		for (const responseData of responses) {
+			const { statusCode, responseObj, matchingMediaType, schema } = responseData;
+			endpoint.responseStatusCodes.push(statusCode);
+			let responseZodSchema;
+			if (matchingMediaType) endpoint.responseFormat = matchingMediaType;
+			else {
+				responseZodSchema = VOID_SCHEMA;
+				if (statusCode === "200") resolver.validationErrors.push(getInvalidStatusCodeError({
+					received: "200",
+					expected: "204"
+				}, operation, endpoint));
+			}
+			if (schema) responseZodSchema = resolveEndpointZodSchema({
+				resolver,
+				schema,
+				meta: { isRequired: true },
+				tag,
+				fallbackName: isReferenceObject(schema) ? void 0 : getResponseZodSchemaName({
+					statusCode,
+					operationName,
+					isUniqueOperationName,
+					tag
+				}),
+				composeBeforeResolve: false
+			});
+			if (responseZodSchema) {
+				const status = Number(statusCode);
+				if (isMainResponseStatus(status) && !endpoint.response) {
+					endpoint.response = responseZodSchema;
+					endpoint.responseObject = responseObj;
+					endpoint.responseDescription = responseObj?.description;
+				} else if (statusCode !== "default" && isErrorStatus(status)) endpoint.errors.push({
+					zodSchema: responseZodSchema,
+					status,
+					description: responseObj?.description
+				});
+			}
+		}
+	});
+	if (!endpoint.response) endpoint.response = VOID_SCHEMA;
+	p.runSync("endpoints.statusValidation", () => {
+		const mainStatusCodes = Object.keys(operation.responses).map(Number).filter(isMainResponseStatus);
+		if (mainStatusCodes.length > 1) resolver.validationErrors.push(getMultipleSuccessStatusCodesError(mainStatusCodes.map(String), operation, endpoint));
+	});
+	p.runSync("endpoints.acl", () => {
+		endpoint.acl = getEndpointAcl({
+			resolver,
+			endpoint,
+			operation
+		});
+	});
+	if (operation.security?.[0].Authorization && !endpoint.responseStatusCodes.includes("401")) resolver.validationErrors.push(getMissingStatusCodeError("401", operation, endpoint));
+	if (endpoint.acl?.[0] && !endpoint.responseStatusCodes.includes("403")) resolver.validationErrors.push(getMissingStatusCodeError("403", operation, endpoint));
+	return endpoint;
+}
+function getMissingPathParameters(endpoint) {
+	return [...endpoint.path.matchAll(/:([a-zA-Z0-9_]+)/g)].map((param) => param[1]).filter((pathParam) => endpoint.parameters.findIndex(({ name }) => name === pathParam) === -1).map((name) => getPathParameterFromName(name));
+}
+function getPathParameterFromName(name) {
+	return {
+		name,
+		type: "Path",
+		zodSchema: STRING_SCHEMA,
+		parameterObject: {
+			name,
+			required: true,
+			in: "path",
+			schema: { type: "string" }
+		}
+	};
+}
+
+//#endregion
+//#region src/generators/utils/object.utils.ts
+/** Pick given properties in object */
+function pick(obj, paths) {
+	const result = {};
+	Object.keys(obj).forEach((key) => {
+		if (!paths.includes(key)) return;
+		result[key] = obj[key];
+	});
+	return result;
+}
+/**
+* Deep merge two or more objects/arrays recursively.
+* Arrays are concatenated, objects are merged recursively.
+* Later arguments take precedence over earlier ones.
+* Returns a new object/array without mutating the originals.
+*/
+function deepMerge(source, ...sources) {
+	if (sources.length === 0) return source;
+	let result = source;
+	for (const source of sources) result = mergeTwoValues(result, source);
+	return result;
+}
+/**
+* Merge two values recursively
+*/
+function mergeTwoValues(target, source) {
+	if (source === null || source === void 0) return target;
+	if (target === null || target === void 0) return deepClone(source);
+	if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
+	if (isPlainObject(target) && isPlainObject(source)) {
+		const result = {};
+		for (const [key, targetValue] of Object.entries(target)) result[key] = deepClone(targetValue);
+		for (const [key, sourceValue] of Object.entries(source)) {
+			const targetValue = result[key];
+			if (sourceValue === void 0) continue;
+			else if (sourceValue === null) result[key] = sourceValue;
+			else if (isPlainObject(targetValue) && isPlainObject(sourceValue)) result[key] = mergeTwoValues(targetValue, sourceValue);
+			else if (Array.isArray(targetValue) && Array.isArray(sourceValue)) result[key] = [...targetValue, ...sourceValue];
+			else result[key] = deepClone(sourceValue);
+		}
+		return result;
+	}
+	return deepClone(source);
+}
+/**
+* Deep clone an object or array to avoid reference sharing.
+* Helper function for deepMerge.
+*/
+function deepClone(obj) {
+	if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) result[key] = deepClone(value);
+		return result;
+	}
+	return obj;
+}
+/**
+* Check if a value is a plain object (not an array, Date, etc.)
+*/
+function isPlainObject(obj) {
+	return obj !== null && typeof obj === "object" && !Array.isArray(obj) && Object.prototype.toString.call(obj) === "[object Object]";
+}
+
+//#endregion
+//#region src/generators/const/js.const.ts
+const RESERVED_WORDS = [
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with"
+];
+
+//#endregion
+//#region src/generators/utils/operation.utils.ts
+function isOperationExcluded(operation, options) {
+	const isDeprecated = operation.deprecated && !options.withDeprecatedEndpoints;
+	const isExcluded = isTagExcluded(getOperationTag(operation, options), options);
+	return isDeprecated || isExcluded;
+}
+function getOperationName({ path, method, operation, options, tag, keepOperationTag, keepOperationPrefix }) {
+	const pathOperationName = `${method}${pathToVariableName(path)}`;
+	let operationName = operation.operationId ? invalidVariableNameCharactersToCamel(operation.operationId) : pathOperationName;
+	if (options.removeOperationPrefixEndingWith && keepOperationPrefix) operationName = operationName.split(options.removeOperationPrefixEndingWith).map((split, index) => index === 0 ? split : capitalize(split)).join("");
+	else if (options.removeOperationPrefixEndingWith && !keepOperationPrefix) {
+		const regex = new RegExp(`^.*${options.removeOperationPrefixEndingWith}`);
+		operationName = operationName.replace(regex, "");
+	}
+	if (options.tsNamespaces && !keepOperationTag) {
+		const operationNameWithoutTag = removeWord(operationName, tag);
+		if (operationNameWithoutTag === "") operationName = method.toLowerCase();
+		else if (!RESERVED_WORDS.includes(operationNameWithoutTag)) operationName = operationNameWithoutTag;
+	}
+	return RESERVED_WORDS.includes(operationName) ? pathOperationName : operationName;
+}
+function getUniqueOperationName({ operationsByTag, ...params }) {
+	const { operation, options } = params;
+	const tag = options.splitByTags ? getOperationTag(operation, options) : options.defaultTag;
+	const operationName = (keepOperationTag) => {
+		const name = getOperationName({
+			...params,
+			tag,
+			keepOperationTag
+		});
+		if (operationsByTag[tag].filter((operation) => getOperationName({
+			...params,
+			operation,
+			tag,
+			keepOperationTag
+		}) === name).length === 1) return name;
+	};
+	return operationName() ?? operationName(true) ?? getOperationName({
+		...params,
+		tag,
+		keepOperationTag: true,
+		keepOperationPrefix: true
+	});
+}
+function getUniqueOperationNamesWithoutSplitByTags(openApiDoc, operationsByTag, options) {
+	const operationNames = [];
+	for (const path in openApiDoc.paths) {
+		if (isPathExcluded(path, options)) continue;
+		const pathItemObj = openApiDoc.paths[path];
+		const pathItem = pick(pathItemObj, ALLOWED_METHODS);
+		for (const method in pathItem) {
+			const operation = pathItem[method];
+			if (!operation || isOperationExcluded(operation, options)) continue;
+			const operationName = getUniqueOperationName({
+				path,
+				method,
+				operation,
+				operationsByTag,
+				options
+			});
+			operationNames.push(operationName);
+		}
+	}
+	return operationNames;
+}
+function getOperationsByTag(openApiDoc, options) {
+	const operationsByTag = {};
+	for (const path in openApiDoc.paths) {
+		if (isPathExcluded(path, options)) continue;
+		const pathItemObj = openApiDoc.paths[path];
+		const pathItem = pick(pathItemObj, ALLOWED_METHODS);
+		for (const method in pathItem) {
+			const operation = pathItem[method];
+			if (!operation || isOperationExcluded(operation, options)) continue;
+			const tag = options.splitByTags ? getOperationTag(operation, options) : options.defaultTag;
+			if (!operationsByTag[tag]) operationsByTag[tag] = [];
+			operationsByTag[tag].push(operation);
+		}
+	}
+	return operationsByTag;
+}
+
+//#endregion
+//#region src/generators/core/openapi/getOpenAPISchemaDependencyGraph.ts
+function getOpenAPISchemaDependencyGraph(schemaRef, getSchemaByRef) {
+	const refsDependencyGraph = getRefsDependencyGraph(schemaRef, getSchemaByRef);
+	return {
+		refsDependencyGraph,
+		deepDependencyGraph: getDeepRefsDependencyGraph(schemaRef, refsDependencyGraph)
+	};
+}
+function getRefsDependencyGraph(schemaRef, getSchemaByRef) {
+	const visitedRefs = {};
+	const refsDependencyGraph = {};
+	schemaRef.forEach((ref) => getSchemaRefsDependencyGraph({
+		schema: getSchemaByRef(ref),
+		fromRef: ref,
+		getSchemaByRef,
+		visitedRefs,
+		refsDependencyGraph
+	}));
+	return refsDependencyGraph;
+}
+function getDeepRefsDependencyGraph(schemaRef, refsDependencyGraph) {
+	const visitedDeepRefs = {};
+	const deepDependencyGraph = {};
+	const visit = (dep, ref) => {
+		deepDependencyGraph[ref].add(dep);
+		if (refsDependencyGraph[dep] && ref !== dep) refsDependencyGraph[dep].forEach((transitive) => {
+			const refName = `${ref}__${transitive}`;
+			if (visitedDeepRefs[refName]) return;
+			visitedDeepRefs[refName] = true;
+			visit(transitive, ref);
+		});
+	};
+	schemaRef.forEach((ref) => {
+		const deps = refsDependencyGraph[ref];
+		if (!deps) return;
+		if (!deepDependencyGraph[ref]) deepDependencyGraph[ref] = /* @__PURE__ */ new Set();
+		deps.forEach((dep) => visit(dep, ref));
+	});
+	return deepDependencyGraph;
+}
+function getSchemaRefsDependencyGraph({ schema, fromRef, getSchemaByRef, visitedRefs = {}, refsDependencyGraph = {} }) {
+	const onSchema = (callbackData) => {
+		if (callbackData.type !== "reference" || !callbackData.data) return;
+		const { schema, data } = callbackData;
+		if (!refsDependencyGraph[data.fromRef]) refsDependencyGraph[data.fromRef] = /* @__PURE__ */ new Set();
+		refsDependencyGraph[data.fromRef].add(schema.$ref);
+		if (visitedRefs[schema.$ref]) return true;
+		visitedRefs[data.fromRef] = true;
+		iterateSchema(getSchemaByRef(schema.$ref), {
+			data: { fromRef: schema.$ref },
+			onSchema
+		});
+	};
+	iterateSchema(schema, {
+		data: { fromRef },
+		onSchema
+	});
+	return {
+		visitedRefs,
+		refsDependencyGraph
+	};
+}
+
+//#endregion
+//#region src/generators/core/openapi/getSchemaRefObjs.ts
+function getSchemaRefObjs(resolver, schema, schemaInfo) {
+	const schemaRefObjs = [];
+	const onSchema = (data) => {
+		if (data.type === "reference") schemaRefObjs.push(data.schema);
+		else if (isReferenceObject(data.parentSchema)) {
+			if (data.type === "property") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} has both reference and properties`));
+			else if (data.type === "additionalProperties") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} has both reference and additionalProperties`));
+			else if (data.type === "array") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} is both reference and array schema`));
+			else if (data.type === "composite") resolver.validationErrors.push(getInvalidSchemaError(`${schemaInfo} has both reference and composite keyword`));
+		}
+	};
+	iterateSchema(schema, { onSchema });
+	return schemaRefObjs;
+}
+function getDeepSchemaRefObjs(resolver, schemaRefs) {
+	return schemaRefs.map((schemaRef) => autocorrectRef(schemaRef.$ref)).reduce((acc, schemaRef) => {
+		const refs = resolver.dependencyGraph.deepDependencyGraph[schemaRef];
+		return [
+			...acc,
+			schemaRef,
+			...Array.from(refs ?? [])
+		];
+	}, []);
+}
+
+//#endregion
+//#region src/generators/core/zod/enumExtraction/resolveExtractedEnumZodSchemaNames.ts
+function resolveExtractedEnumZodSchemaNames(resolver) {
+	resolver.extractedEnumZodSchemaData.forEach((enumData) => {
+		const mostCommonLastSegment = getMostCommonAdjacentCombinationSplit(enumData.meta.zodSchemaNameSegments.map((arr) => arr[arr.length - 1]).filter(Boolean));
+		if (!mostCommonLastSegment) throw new Error(`No common last segment found for enum: ${enumData.code}`);
+		enumData.zodSchemaName = getEnumZodSchemaName(mostCommonLastSegment, resolver.options.enumSuffix, resolver.options.schemaSuffix);
+	});
+	let nameResolutionIterationsCounter = 0;
+	while (nameResolutionIterationsCounter < 5) {
+		if (allExtractedEnumZodSchemaNamesAreUnique(resolver)) break;
+		additionalResolveExtractedEnumZodSchemaName(resolver, nameResolutionIterationsCounter + 2);
+		nameResolutionIterationsCounter++;
+	}
+	if (!allExtractedEnumZodSchemaNamesAreUnique(resolver)) resolver.extractedEnumZodSchemaData.filter((enumData) => !isUnique(resolver, enumData)).forEach((enumData) => {
+		enumData.zodSchemaName = getEnumZodSchemaName(enumData.meta.zodSchemaNameSegments[0].map((name) => sanitizeName(capitalize(name))).join(""), resolver.options.enumSuffix, resolver.options.schemaSuffix);
+	});
+	if (!allExtractedEnumZodSchemaNamesAreUnique(resolver)) throw new Error("Failed to resolve unique names for enum zod schemas");
+}
+function allExtractedEnumZodSchemaNamesAreUnique(resolver) {
+	return resolver.extractedEnumZodSchemaData.every((enumData) => isUnique(resolver, enumData));
+}
+function additionalResolveExtractedEnumZodSchemaName(resolver, index) {
+	resolver.extractedEnumZodSchemaData.forEach((enumData) => {
+		const enumsDataWithSameName = resolver.extractedEnumZodSchemaData.filter(({ zodSchemaName }) => enumData.zodSchemaName === zodSchemaName);
+		if (enumsDataWithSameName.length === 1) return;
+		suffixWithPreviousSegmentName(enumsDataWithSameName, index);
+	});
+}
+function suffixWithPreviousSegmentName(enumsData, index = 2) {
+	enumsData.forEach((data) => {
+		const precedingLastFragments = data.meta.zodSchemaNameSegments.map((arr) => arr[arr.length - index]).filter(Boolean);
+		if (precedingLastFragments.length === 1) data.zodSchemaName = [sanitizeName(capitalize(precedingLastFragments[0])), data.zodSchemaName].filter(Boolean).join("");
+		else {
+			const secondLastFragmentSplit = getMostCommonAdjacentCombinationSplit(precedingLastFragments);
+			data.zodSchemaName = [secondLastFragmentSplit ? sanitizeName(capitalize(secondLastFragmentSplit)) : "", data.zodSchemaName].filter(Boolean).join("");
+		}
+	});
+}
+function isUnique(resolver, enumData) {
+	return resolver.extractedEnumZodSchemaData.filter(({ zodSchemaName }) => enumData.zodSchemaName === zodSchemaName).length === 1;
+}
+function sanitizeName(name) {
+	return name.replace(/(Dto|DTO|Response|Request)/g, "");
+}
+
+//#endregion
+//#region src/generators/core/zod/enumExtraction/resolveExtractedEnumZodSchemaTags.ts
+function resolveExtractedEnumZodSchemaTags(resolver) {
+	resolver.extractedEnumZodSchemaData.forEach((enumData) => {
+		const tags = getUniqueArray(enumData.meta.tags);
+		enumData.tag = tags.length === 1 ? tags[0] : resolver.options.defaultTag;
+	});
+}
+
+//#endregion
+//#region src/generators/core/zod/enumExtraction/updateExtractedEnumZodSchemaData.ts
+function updateExtractedEnumZodSchemaData({ schema, nameSegments = [], includeSelf, ...params }) {
+	if (includeSelf) handleExtractedEnumZodSchemaDataUpdate({
+		schema,
+		nameSegments,
+		...params
+	});
+	const onSchema = (data) => {
+		if (data.type === "reference") return true;
+		const segments = [...data.data?.nameSegments ?? []];
+		if (data.type === "property") segments.push(data.propertyName);
+		handleExtractedEnumZodSchemaDataUpdate({
+			schema: data.schema,
+			nameSegments: [...segments],
+			...params
+		});
+	};
+	iterateSchema(schema, {
+		data: { nameSegments },
+		onSchema
+	});
+}
+function handleExtractedEnumZodSchemaDataUpdate({ resolver, schema, schemaRef, schemaInfo, tags, nameSegments = [] }) {
+	if (!schema || isReferenceObject(schema) || !schema.enum) return;
+	const code = getEnumZodSchemaCode(schema);
+	const enumZodSchema = resolver.extractedEnumZodSchemaData.find((data) => data.code === code);
+	if (enumZodSchema) {
+		enumZodSchema.meta.zodSchemaNameSegments.push(nameSegments);
+		enumZodSchema.meta.tags.push(...tags);
+		enumZodSchema.meta.schemaRefs.push(...schemaRef ? [schemaRef] : []);
+		enumZodSchema.meta.schemas.push(...schema ? [schema] : []);
+	} else resolver.extractedEnumZodSchemaData.push({
+		code,
+		meta: {
+			zodSchemaNameSegments: [nameSegments],
+			tags: [...tags],
+			schemaRefs: schemaRef ? [schemaRef] : [],
+			schemas: schema ? [schema] : []
+		}
+	});
+	resolver.validationErrors.push(getNotAllowedInlineEnumError(schemaRef ? `${getSchemaNameByRef(schemaRef)}.${nameSegments[nameSegments.length - 1]}` : schemaInfo ?? nameSegments.join(".")));
+}
+
+//#endregion
+//#region src/generators/core/zod/getZodSchemasFromOpenAPIDoc.ts
+function getZodSchemasFromOpenAPIDoc(resolver, profiler) {
+	const p = profiler ?? new Profiler(false);
+	const zodSchemas = {};
+	const enumZodSchemas = {};
+	Object.entries(resolver.openApiDoc.components?.schemas ?? {}).forEach(([name, schema]) => p.runSync("zod.extract.schemaEntry", () => {
+		const schemaData = resolver.getSchemaDataByName(name);
+		if (resolver.options.excludeRedundantZodSchemas && (!schemaData || schemaData.deepRefOperations.length === 0 && schemaData.tags.length === 0)) return;
+		const zodSchemaName = getZodSchemaName(name, resolver.options.schemaSuffix);
+		if (zodSchemas[zodSchemaName]) return;
+		const tag = resolver.getTagByZodSchemaName(zodSchemaName);
+		const schemaObject = resolver.resolveObject(schema);
+		if (schemaObject.enum) enumZodSchemas[zodSchemaName] = getEnumZodSchemaCode(schemaObject);
+		else zodSchemas[zodSchemaName] = p.runSync("zod.extract.schemaToCode", () => getZodSchema({
+			schema,
+			resolver,
+			tag
+		}).getCodeString(tag));
+	}));
+	return {
+		zodSchemas,
+		enumZodSchemas
+	};
+}
+function getEnumZodSchemasFromOpenAPIDoc(resolver) {
+	const enumZodSchemas = [];
+	Object.entries(resolver.openApiDoc.components?.schemas ?? {}).forEach(([name, schema]) => {
+		const zodSchemaName = getZodSchemaName(name, resolver.options.schemaSuffix);
+		const schemaObject = resolver.resolveObject(schema);
+		if (!enumZodSchemas.find((enumZodSchema) => enumZodSchema.zodSchemaName === zodSchemaName) && schemaObject.enum) enumZodSchemas.push({
+			zodSchemaName,
+			code: getEnumZodSchemaCode(schemaObject)
+		});
+	});
+	return enumZodSchemas;
+}
+
+//#endregion
+//#region src/generators/core/SchemaResolver.class.ts
+var SchemaResolver = class {
+	schemaData = [];
+	zodSchemaData = [];
+	compositeZodSchemaData = [];
+	schemaRefs;
+	schemaByRef = /* @__PURE__ */ new Map();
+	schemaDataByRef = /* @__PURE__ */ new Map();
+	schemaDataByName = /* @__PURE__ */ new Map();
+	refByZodSchemaName = /* @__PURE__ */ new Map();
+	zodSchemaDataByName = /* @__PURE__ */ new Map();
+	compositeByCode = /* @__PURE__ */ new Map();
+	compositeSchemaByZodSchemaName = /* @__PURE__ */ new Map();
+	dependencyGraph;
+	enumZodSchemas = [];
+	extractedEnumZodSchemaData = [];
+	operationsByTag = {};
+	operationNames = [];
+	operationNameCounts = /* @__PURE__ */ new Map();
+	operationContexts = [];
+	validationErrors = [];
+	get docSchemas() {
+		return this.openApiDoc.components?.schemas ?? {};
+	}
+	constructor(openApiDoc, options, profiler) {
+		this.openApiDoc = openApiDoc;
+		this.options = options;
+		this.profiler = profiler;
+		this.schemaRefs = Object.keys(this.docSchemas).map(getSchemaRef);
+		this.dependencyGraph = getOpenAPISchemaDependencyGraph(this.schemaRefs, this.getSchemaByRef.bind(this));
+		this.enumZodSchemas = getEnumZodSchemasFromOpenAPIDoc(this);
+		this.operationsByTag = getOperationsByTag(openApiDoc, options);
+		this.operationNames = getUniqueOperationNamesWithoutSplitByTags(openApiDoc, this.operationsByTag, options);
+		for (const name of this.operationNames) this.operationNameCounts.set(name, (this.operationNameCounts.get(name) ?? 0) + 1);
+		this.initialize();
+	}
+	getSchemaByRef(ref) {
+		const correctRef = autocorrectRef(ref);
+		const cachedSchema = this.schemaByRef.get(correctRef);
+		if (cachedSchema) return cachedSchema;
+		const schema = this.docSchemas[getSchemaNameByRef(correctRef)];
+		this.schemaByRef.set(correctRef, schema);
+		return schema;
+	}
+	getSchemaDataByName(name) {
+		return this.schemaDataByName.get(name);
+	}
+	getZodSchemaNameByRef(ref) {
+		const zodSchemaName = this.getSchemaDataByRef(autocorrectRef(ref))?.zodSchemaName ?? this.extractedEnumZodSchemaData.find((data) => data.zodSchemaName === ref)?.zodSchemaName;
+		if (!zodSchemaName) throw new Error(`Zod schema not found for ref: ${ref}`);
+		return zodSchemaName;
+	}
+	getRefByZodSchemaName(zodSchemaName) {
+		return this.refByZodSchemaName.get(zodSchemaName);
+	}
+	getTagByZodSchemaName(zodSchemaName) {
+		if (!this.options.splitByTags) return this.options.defaultTag;
+		const extractedEnumZodSchema = this.extractedEnumZodSchemaData.find((data) => data.zodSchemaName === zodSchemaName);
+		if (extractedEnumZodSchema) return formatTag(extractedEnumZodSchema.tag ?? this.options.defaultTag);
+		const schemaRef = this.getRefByZodSchemaName(zodSchemaName);
+		const tags = getUniqueArray(schemaRef ? this.getSchemaDataByRef(schemaRef)?.tags ?? [] : [], this.zodSchemaDataByName.get(zodSchemaName)?.tags ?? []);
+		return formatTag((tags.length === 1 ? tags[0] : this.options.defaultTag) ?? this.options.defaultTag);
+	}
+	getCodeByZodSchemaName(name) {
+		return this.zodSchemaDataByName.get(name)?.code;
+	}
+	getZodSchemaNamesByCompositeCode(code) {
+		return this.compositeByCode.get(code)?.zodSchemas.map((schema) => schema.zodSchemaName);
+	}
+	setZodSchema(name, code, tag) {
+		const zodSchema = this.zodSchemaDataByName.get(name);
+		if (zodSchema) {
+			zodSchema.code = code;
+			zodSchema.tags = (zodSchema.tags ?? []).concat(tag);
+		} else {
+			const newZodSchemaData = {
+				zodSchemaName: name,
+				code,
+				tags: [tag]
+			};
+			this.zodSchemaData.push(newZodSchemaData);
+			this.zodSchemaDataByName.set(name, newZodSchemaData);
+		}
+	}
+	addZodSchemaForCompositeCode(code, zodSchema, zodSchemaName, schema) {
+		const compositeZodSchema = {
+			zodSchemaName,
+			zodSchema,
+			schema
+		};
+		const compositeData = this.compositeByCode.get(code);
+		if (compositeData) compositeData.zodSchemas.push(compositeZodSchema);
+		else {
+			const newCompositeData = {
+				code,
+				zodSchemas: [compositeZodSchema]
+			};
+			this.compositeZodSchemaData.push(newCompositeData);
+			this.compositeByCode.set(code, newCompositeData);
+		}
+		this.compositeSchemaByZodSchemaName.set(zodSchemaName, {
+			zodSchema,
+			schema
+		});
+	}
+	getCompositeZodSchemaByZodSchemaName(zodSchemaName) {
+		return this.compositeSchemaByZodSchemaName.get(zodSchemaName)?.zodSchema;
+	}
+	getSchemaByCompositeZodSchemaName(compositeZodSchemaName) {
+		return this.compositeSchemaByZodSchemaName.get(compositeZodSchemaName)?.schema;
+	}
+	getEnumZodSchemaDataByCode(code) {
+		return this.enumZodSchemas.find((data) => data.code === code);
+	}
+	getExtractedEnumZodSchemaDataByCode(code) {
+		return this.extractedEnumZodSchemaData.find((data) => data.code === code);
+	}
+	getExtractedEnumZodSchemaNamesReferencedBySchemaRef(schemaRef) {
+		return this.extractedEnumZodSchemaData.reduce((acc, { zodSchemaName, meta }) => {
+			if (zodSchemaName && meta.schemaRefs.includes(schemaRef)) return [...acc, zodSchemaName];
+			return acc;
+		}, []);
+	}
+	getZodSchemas() {
+		const zodSchemas = {};
+		for (const { zodSchemaName, code } of this.zodSchemaData) zodSchemas[zodSchemaName] = code;
+		return zodSchemas;
+	}
+	getExtractedEnumZodSchemas() {
+		const zodSchemas = {};
+		for (const { zodSchemaName, code } of this.extractedEnumZodSchemaData) if (zodSchemaName) zodSchemas[zodSchemaName] = code;
+		return zodSchemas;
+	}
+	resolveObject(obj) {
+		return isReferenceObject(obj) ? this.getSchemaByRef(obj.$ref) : obj;
+	}
+	isSchemaCircular(ref) {
+		return this.dependencyGraph.deepDependencyGraph[ref]?.has(ref);
+	}
+	getCircularSchemaChain(ref, currentRef = ref, chain = [], visited = []) {
+		if (visited.includes(currentRef)) return [];
+		visited.push(currentRef);
+		if (this.dependencyGraph.refsDependencyGraph[currentRef]?.has(ref)) return [
+			...chain,
+			currentRef,
+			ref
+		];
+		return Array.from(this.dependencyGraph.refsDependencyGraph[currentRef]?.values() ?? []).flatMap((childRef) => {
+			const childChain = this.getCircularSchemaChain(ref, childRef, chain, visited);
+			return childChain.length > 0 ? [currentRef, ...childChain] : childChain;
+		});
+	}
+	getBaseUrl() {
+		const serverUrl = this.openApiDoc.servers?.[0]?.url;
+		if (this.options.baseUrl === "" && serverUrl) return serverUrl;
+		return this.options.baseUrl;
+	}
+	isOperationNameUnique(operationName) {
+		return (this.operationNameCounts.get(operationName) ?? 0) <= 1;
+	}
+	getOperationContexts() {
+		return this.operationContexts;
+	}
+	getZodSchemaObj(zodSchemaName) {
+		const ref = this.getRefByZodSchemaName(zodSchemaName);
+		if (ref) return this.getSchemaByRef(ref);
+		const schema = this.getSchemaByCompositeZodSchemaName(zodSchemaName);
+		if (schema) return schema;
+		const enumZodSchemaData = this.getExtractedEnumZodSchemaDataByName(zodSchemaName);
+		if (enumZodSchemaData) {
+			const schemaObject = {};
+			for (const schema of enumZodSchemaData.meta.schemas) Object.assign(schemaObject, this.resolveObject(schema));
+			return schemaObject;
+		}
+	}
+	getSchemaDataByRef(ref) {
+		return this.schemaDataByRef.get(ref);
+	}
+	getExtractedEnumZodSchemaDataByName(enumZodSchemaName) {
+		return this.extractedEnumZodSchemaData.find(({ zodSchemaName }) => zodSchemaName === enumZodSchemaName);
+	}
+	initialize() {
+		const p = this.profiler ?? new Profiler(false);
+		p.runSync("resolver.init.seedSchemas", () => {
+			this.schemaRefs.forEach((ref) => {
+				const correctRef = autocorrectRef(ref);
+				const name = getSchemaNameByRef(correctRef);
+				const zodSchemaName = getZodSchemaName(name, this.options.schemaSuffix);
+				const data = {
+					ref: correctRef,
+					name,
+					zodSchemaName,
+					tags: [],
+					deepRefOperations: []
+				};
+				this.schemaData.push(data);
+				this.schemaDataByRef.set(correctRef, data);
+				this.schemaDataByName.set(name, data);
+				this.refByZodSchemaName.set(zodSchemaName, correctRef);
+			});
+		});
+		p.runSync("resolver.init.operationsLoop", () => {
+			for (const path in this.openApiDoc.paths) {
+				if (isPathExcluded(path, this.options)) continue;
+				const pathItemObj = this.openApiDoc.paths[path];
+				const pathParameters = this.getParameters(pathItemObj.parameters ?? []);
+				const pathItem = pick(pathItemObj, ALLOWED_METHODS);
+				for (const method in pathItem) {
+					const operation = pathItem[method];
+					if (!operation || isOperationExcluded(operation, this.options)) continue;
+					const tag = getOperationTag(operation, this.options);
+					const operationName = getUniqueOperationName({
+						path,
+						method,
+						operation,
+						operationsByTag: this.operationsByTag,
+						options: this.options
+					});
+					const isUniqueOperationName = this.isOperationNameUnique(operationName);
+					const parameters = p.runSync("resolver.init.parameters.mergeResolve", () => Object.entries({
+						...pathParameters,
+						...this.getParameters(operation.parameters ?? [])
+					}).map(([, param]) => this.resolveObject(param)));
+					const responses = p.runSync("resolver.init.responses.prepare", () => Object.entries(operation.responses).map(([statusCode, response]) => {
+						const responseObj = this.resolveObject(response);
+						const matchingMediaType = Object.keys(responseObj?.content ?? {}).find(isMediaTypeAllowed);
+						return {
+							statusCode,
+							responseObj,
+							matchingMediaType,
+							schema: matchingMediaType ? responseObj.content?.[matchingMediaType]?.schema : void 0
+						};
+					}));
+					const zodSchemaOperationName = snakeToCamel(getZodSchemaOperationName(operationName, isUniqueOperationName, tag));
+					const schemaRefObjs = [];
+					p.runSync("resolver.init.parameters.refs", () => {
+						parameters.forEach((parameter) => {
+							const parameterObject = this.resolveObject(parameter);
+							const parameterSchema = parameterObject.schema;
+							const schemaInfo = `Operation ${operation.operationId ?? path} parameter ${parameterObject.name}`;
+							schemaRefObjs.push(...getSchemaRefObjs(this, parameterSchema, schemaInfo));
+							if (this.options.extractEnums) updateExtractedEnumZodSchemaData({
+								resolver: this,
+								schema: parameterSchema,
+								schemaInfo,
+								tags: [tag],
+								nameSegments: [zodSchemaOperationName, parameterObject.name],
+								includeSelf: true
+							});
+						});
+					});
+					p.runSync("resolver.init.requestBody.refs", () => {
+						if (operation.requestBody) {
+							const requestBodyObj = this.resolveObject(operation.requestBody);
+							const matchingMediaType = Object.keys(requestBodyObj.content ?? {}).find(isParamMediaTypeAllowed);
+							if (matchingMediaType) {
+								const matchingMediaSchema = requestBodyObj.content?.[matchingMediaType]?.schema;
+								const schemaInfo = `Operation ${operation.operationId} request body`;
+								schemaRefObjs.push(...getSchemaRefObjs(this, matchingMediaSchema, schemaInfo));
+								if (this.options.extractEnums) updateExtractedEnumZodSchemaData({
+									resolver: this,
+									schema: matchingMediaSchema,
+									schemaInfo,
+									tags: [tag],
+									nameSegments: [getBodyZodSchemaName(zodSchemaOperationName)]
+								});
+							}
+						}
+					});
+					p.runSync("resolver.init.responses.refs", () => {
+						for (const responseData of responses) {
+							if (!responseData.matchingMediaType) continue;
+							const schemaInfo = `Operation ${operation.operationId} response body`;
+							schemaRefObjs.push(...getSchemaRefObjs(this, responseData.schema, schemaInfo));
+							if (this.options.extractEnums) updateExtractedEnumZodSchemaData({
+								resolver: this,
+								schema: responseData.schema,
+								schemaInfo,
+								tags: [tag],
+								nameSegments: [getResponseZodSchemaName({
+									statusCode: responseData.statusCode,
+									operationName,
+									isUniqueOperationName,
+									tag
+								})]
+							});
+						}
+					});
+					const deepRefs = p.runSync("resolver.init.deepRefs", () => getDeepSchemaRefObjs(this, schemaRefObjs));
+					const operationContext = {
+						path,
+						method,
+						operation,
+						tag,
+						operationName,
+						isUniqueOperationName,
+						parameters,
+						deepRefs,
+						responses
+					};
+					this.operationContexts.push(operationContext);
+					deepRefs.forEach((schemaRef) => {
+						const schemaData = this.getSchemaDataByRef(schemaRef);
+						if (schemaData) {
+							schemaData.tags.push(tag);
+							schemaData.deepRefOperations.push(operation);
+						}
+					});
+				}
+			}
+		});
+		if (this.options.extractEnums) p.runSync("resolver.init.enums.finalize", () => {
+			this.schemaRefs.forEach((ref) => {
+				const schemaRef = autocorrectRef(ref);
+				updateExtractedEnumZodSchemaData({
+					resolver: this,
+					schema: this.getSchemaByRef(schemaRef),
+					schemaRef,
+					tags: this.getSchemaDataByRef(schemaRef)?.tags ?? [],
+					nameSegments: [getSchemaNameByRef(schemaRef)]
+				});
+			});
+			resolveExtractedEnumZodSchemaTags(this);
+			this.handleDuplicateEnumZodSchemas();
+			resolveExtractedEnumZodSchemaNames(this);
+		});
+	}
+	handleDuplicateEnumZodSchemas() {
+		const codes = new Set(this.enumZodSchemas.map(({ code }) => code));
+		const duplicates = this.enumZodSchemas.filter(({ code }) => codes.has(code));
+		this.schemaData.forEach((schemaData) => {
+			const duplicateCode = duplicates.find(({ zodSchemaName }) => zodSchemaName === schemaData.zodSchemaName)?.code;
+			if (!duplicateCode) return;
+			const duplicate = this.extractedEnumZodSchemaData.find(({ code }) => code === duplicateCode);
+			if (!duplicate || this.getEnumZodSchemaDataByCode(duplicate.code)?.zodSchemaName !== schemaData.zodSchemaName) return;
+			schemaData.tags.push(...duplicate.meta.tags ?? []);
+			duplicate.meta.schemaRefs.forEach((ref) => {
+				if (!this.dependencyGraph.refsDependencyGraph[ref]) this.dependencyGraph.refsDependencyGraph[ref] = /* @__PURE__ */ new Set();
+				this.dependencyGraph.refsDependencyGraph[ref].add(schemaData.ref);
+				if (!this.dependencyGraph.deepDependencyGraph[ref]) this.dependencyGraph.deepDependencyGraph[ref] = /* @__PURE__ */ new Set();
+				this.dependencyGraph.deepDependencyGraph[ref].add(schemaData.ref);
+			});
+		});
+		this.extractedEnumZodSchemaData.splice(0, this.extractedEnumZodSchemaData.length, ...this.extractedEnumZodSchemaData.filter(({ code }) => !codes.has(code)));
+	}
+	getParameters(parameters) {
+		return Object.fromEntries((parameters ?? []).map((param) => [isReferenceObject(param) ? param.$ref : param.name, param]));
+	}
+};
+
+//#endregion
+//#region src/generators/utils/sort.utils.ts
+/** @see https://gist.github.com/RubyTuesdayDONO/5006455 */
+function topologicalSort(graph) {
+	const sorted = [];
+	const visited = {};
+	function visit(name, ancestors) {
+		if (!Array.isArray(ancestors)) ancestors = [];
+		ancestors.push(name);
+		visited[name] = true;
+		if (graph[name]) graph[name].forEach((dep) => {
+			if (ancestors.includes(dep)) return;
+			if (visited[dep]) return;
+			visit(dep, ancestors.slice(0));
+		});
+		if (!sorted.includes(name)) sorted.push(name);
+	}
+	Object.keys(graph).forEach((name) => visit(name, []));
+	return sorted;
+}
+/** Sort object keys using a reference order array, sort keys not in reference order in lasts positions */
+function sortObjKeysFromArray(obj, orderedKeys) {
+	const entries = Object.entries(obj);
+	const sortedEntries = entries.filter(([key]) => orderedKeys.includes(key)).toSorted(([a], [b]) => orderedKeys.indexOf(a) - orderedKeys.indexOf(b)).concat(entries.filter(([key]) => !orderedKeys.includes(key)));
+	return Object.fromEntries(sortedEntries);
+}
+
+//#endregion
+//#region src/generators/core/zod/sortZodSchemasByTopology.ts
+function sortZodSchemasByTopology(resolver, zodSchemas) {
+	return sortObjKeysFromArray(zodSchemas, topologicalSort(resolver.dependencyGraph.deepDependencyGraph).map((ref) => resolver.getZodSchemaNameByRef(ref)));
+}
+
+//#endregion
+//#region src/generators/core/getDataFromOpenAPIDoc.ts
+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 zodSchemasFromDocSchemas = p.runSync("data.zod.extract", () => getZodSchemasFromOpenAPIDoc(resolver, p));
+	let zodSchemas = {
+		...zodSchemasFromDocSchemas.zodSchemas,
+		...resolver.getZodSchemas(),
+		...zodSchemasFromDocSchemas.enumZodSchemas
+	};
+	zodSchemas = p.runSync("data.zod.sortTopology", () => sortZodSchemasByTopology(resolver, zodSchemas));
+	zodSchemas = {
+		...resolver.getExtractedEnumZodSchemas(),
+		...zodSchemas
+	};
+	return {
+		resolver,
+		data: p.runSync("data.splitByTags", () => splitDataByTags({
+			resolver,
+			endpoints,
+			zodSchemas,
+			options
+		}))
+	};
+}
+function splitDataByTags({ resolver, endpoints, zodSchemas, options }) {
+	const data = /* @__PURE__ */ new Map();
+	if (!options.splitByTags) {
+		data.set(options.defaultTag, {
+			endpoints,
+			zodSchemas
+		});
+		return data;
+	}
+	endpoints.forEach((endpoint) => {
+		getTagElement(getEndpointTag(endpoint, options), data).endpoints.push(endpoint);
+	});
+	Object.entries(zodSchemas).forEach(([zodSchemaName, zodSchemaCode]) => {
+		const tag = options.modelsInCommon ? options.defaultTag : resolver.getTagByZodSchemaName(zodSchemaName);
+		if (tag) getTagElement(tag, data).zodSchemas[zodSchemaName] = zodSchemaCode;
+	});
+	return data;
+}
+function getTagElement(tag, data) {
+	if (!data.has(tag)) data.set(tag, {
+		endpoints: [],
+		zodSchemas: {}
+	});
+	return data.get(tag);
+}
+
+//#endregion
+//#region src/generators/utils/file.utils.ts
+function readFileSync(filePath) {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		path.resolve(process.cwd(), filePath),
+		path.resolve(moduleDir, "../../../", filePath),
+		path.resolve(moduleDir, "../", filePath)
+	];
+	for (const candidatePath of candidates) if (fs.existsSync(candidatePath)) return fs.readFileSync(candidatePath, "utf-8");
+	throw new Error(`Cannot read file: ${filePath}`);
+}
+function readAssetSync(fileName) {
+	return readFileSync(`src/assets/${fileName}`);
+}
+function getOutputFileName({ output, fileName }) {
+	return `${output}/${fileName}`;
+}
+function writeFileWithDirSync(file, data) {
+	const dir = path.dirname(file);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	if (fs.existsSync(file)) {
+		if (fs.readFileSync(file, "utf-8") === data) return;
+	}
+	fs.writeFileSync(file, data, "utf-8");
+}
+function writeFileSync$1({ fileName, content }) {
+	writeFileWithDirSync(fileName, content);
+}
+function writeGenerateFileData(filesData) {
+	filesData.forEach(writeFileSync$1);
+}
+
+//#endregion
+//#region src/generators/generate/generateAcl.ts
+function generateAcl({ resolver, data, tag }) {
+	const aclData = getAclData({
+		resolver,
+		data,
+		tag
+	});
+	if (!aclData) return;
+	const { hasAdditionalAbilityImports, modelsImports, endpoints } = aclData;
+	const caslAbilityTupleImport = {
+		bindings: [CASL_ABILITY_BINDING.abilityTuple, ...hasAdditionalAbilityImports ? [CASL_ABILITY_BINDING.forcedSubject, CASL_ABILITY_BINDING.subject] : []],
+		from: CASL_ABILITY_IMPORT.from
+	};
+	const lines = [];
+	lines.push(renderImport$5(caslAbilityTupleImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$5(modelsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: GenerateType.Acl,
+		tag,
+		options: resolver.options
+	})} {`);
+	for (const endpoint of endpoints) {
+		lines.push(renderAbilityFunction(endpoint));
+		lines.push("");
+	}
+	if (resolver.options.tsNamespaces) lines.push("}");
+	return lines.join("\n").trimEnd() + "\n";
+}
+function generateAppAcl({ resolver, data }) {
+	const { appAbilitiesType, hasAdditionalAbilityImports, modelsImports } = getAppAbilitiesType({
+		resolver,
+		data
+	});
+	const caslAbilityTupleImport = {
+		bindings: [
+			CASL_ABILITY_BINDING.pureAbility,
+			CASL_ABILITY_BINDING.abilityTuple,
+			...!appAbilitiesType ? [CASL_ABILITY_BINDING.subjectType] : [],
+			...hasAdditionalAbilityImports ? [CASL_ABILITY_BINDING.forcedSubject] : []
+		],
+		from: CASL_ABILITY_IMPORT.from
+	};
+	const lines = [];
+	lines.push(renderImport$5(caslAbilityTupleImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$5(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$5(importData) {
+	return `import ${[...importData.defaultImport ? [importData.defaultImport] : [], ...importData.bindings ? [`{ ${importData.bindings.join(", ")} }`] : []].join(", ")} from "${importData.from}";`;
+}
+function renderAbilityFunction(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 { ${(propertyType.type ?? "") + (propertyType.zodSchemaName ?? "")} } 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("")} } `);
+	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(" | ")}>;`);
+	return lines.join("\n");
+}
+
+//#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$1(createEndpoint);
+			if (body) importedZodSchemas.push(body.zodSchema);
+			config.create = {
+				acl: getAclConfig(createEndpoint, resolver.options),
+				mutation: getImportedQueryName(createEndpoint, resolver.options),
+				inputDefs: getInputsConfig(resolver, body)
+			};
+		}
+		const updateEndpoint = extendedEndpoints.find((endpoint) => isUpdateEndpoint(endpoint, readAllEndpoint));
+		if (updateEndpoint) {
+			importedEndpoints.push(updateEndpoint);
+			const body = getEndpointBody$1(updateEndpoint);
+			if (body) importedZodSchemas.push(body.zodSchema);
+			config.update = {
+				acl: getAclConfig(updateEndpoint, resolver.options),
+				mutation: getImportedQueryName(updateEndpoint, resolver.options),
+				inputDefs: getInputsConfig(resolver, body)
+			};
+		}
+		const deleteEndpoint = extendedEndpoints.find((endpoint) => isDeleteEndpoint(endpoint, readAllEndpoint));
+		if (deleteEndpoint) {
+			importedEndpoints.push(deleteEndpoint);
+			config.delete = {
+				acl: getAclConfig(deleteEndpoint, resolver.options),
+				mutation: getImportedQueryName(deleteEndpoint, resolver.options)
+			};
+		}
+		const bulkDeleteEndpoint = extendedEndpoints.find((endpoint) => isBulkDeleteEndpoint(endpoint, readAllEndpoint));
+		if (bulkDeleteEndpoint) {
+			importedEndpoints.push(bulkDeleteEndpoint);
+			const body = getEndpointBody$1(bulkDeleteEndpoint);
+			if (body) importedZodSchemas.push(body.zodSchema);
+			config.bulkDelete = {
+				acl: getAclConfig(bulkDeleteEndpoint, resolver.options),
+				mutation: getImportedQueryName(bulkDeleteEndpoint, resolver.options),
+				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 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 = isReferenceObject(itemSchema) ? resolver.getZodSchemaNameByRef(itemSchema.$ref) : ANY_SCHEMA;
+	const columns = Object.keys(itemSchemaObj?.properties ?? {}).reduce((acc, key) => ({
+		...acc,
+		[key]: true
+	}), {});
+	const sortableEnumSchemaName = endpoint.parameters.find((param) => param.parameterObject && isSortingParameterObject(param.parameterObject))?.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/generate/generateConfigs.ts
+function generateConfigs(generateTypeParams) {
+	const { configs, hasZodImport, modelsImports, queriesImports, aclImports } = getBuilderConfigs(generateTypeParams);
+	if (configs.length === 0) return;
+	const { resolver, tag } = generateTypeParams;
+	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 (hasZodImport) lines.push(renderImport$4(ZOD_IMPORT));
+	if (hasDynamicInputsImport) lines.push(renderImport$4(dynamicInputsImport));
+	if (hasDynamicColumnsImport) lines.push(renderImport$4(dynamicColumnsImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$4(modelsImport));
+	for (const queriesImport of queriesImports) lines.push(renderImport$4(queriesImport));
+	for (const aclImport of aclImports) lines.push(renderImport$4(aclImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: GenerateType.Configs,
+		tag,
+		options: resolver.options
+	})} {`);
+	for (const config of configs) {
+		lines.push(renderBuilderConfig(config));
+		lines.push("");
+	}
+	if (resolver.options.tsNamespaces) lines.push("}");
+	return lines.join("\n").trimEnd() + "\n";
+}
+function renderImport$4(importData) {
+	return `import ${[...importData.defaultImport ? [importData.defaultImport] : [], ...importData.bindings ? [`{ ${importData.bindings.join(", ")} }`] : []].join(", ")} 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 renderBuilderConfig(config) {
+	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.inputDefs) lines.push(`        schema: ${config.create.inputDefs.schema},`);
+		lines.push(`        mutation: ${config.create.mutation},`);
+		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.inputDefs) lines.push(`        schema: ${config.update.inputDefs.schema},`);
+		lines.push(`        mutation: ${config.update.mutation},`);
+		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: ${config.delete.mutation},`);
+		lines.push("    },");
+	}
+	lines.push("};");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/generators/generate/generateEndpoints.ts
+function generateEndpoints({ resolver, data, tag }) {
+	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 hasAxiosImport = hasAxiosRequestConfig;
+	const axiosImport = {
+		bindings: hasAxiosRequestConfig ? [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 zodSchemas = getUniqueArray([...endpoints.map((endpoint) => endpoint.response), ...generateParse ? endpointParamsParseSchemas : []]);
+	const hasZodImport = zodSchemas.some((schema) => !isNamedZodSchema(schema));
+	const hasZodExtendedImport = resolver.options.parseRequestParams && endpointParamsParseSchemas.length > 0;
+	const zodExtendedImport = {
+		bindings: [ZOD_EXTENDED.namespace],
+		from: getZodExtendedImportPath(resolver.options)
+	};
+	const modelsImports = getModelsImports({
+		resolver,
+		tag,
+		zodSchemas: zodSchemas.filter(isNamedZodSchema),
+		zodSchemasAsTypes: getUniqueArray(endpointParams.map((param) => param.zodSchema).filter(isNamedZodSchema))
+	});
+	const lines = [];
+	lines.push(renderImport$3(appRestClientImport));
+	if (hasAxiosImport) lines.push(renderImport$3(axiosImport));
+	if (hasZodImport) lines.push(renderImport$3(ZOD_IMPORT));
+	if (hasZodExtendedImport) lines.push(renderImport$3(zodExtendedImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$3(modelsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: GenerateType.Endpoints,
+		tag,
+		options: resolver.options
+	})} {`);
+	for (const endpoint of endpoints) {
+		const endpointParams = renderEndpointParams$1(resolver, endpoint, {});
+		renderEndpointArgs$1(resolver, endpoint, {});
+		const endpointBody = getEndpointBody$1(endpoint);
+		const hasUndefinedEndpointBody = requiresBody(endpoint) && !endpointBody && hasEndpointConfig(endpoint, resolver);
+		const endpointConfig = renderEndpointConfig(resolver, endpoint);
+		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)} },`);
+		lines.push(`        \`${getEndpointPath(endpoint)}\`,`);
+		if (endpointBody) lines.push(`        ${generateParse ? renderEndpointParamParse(resolver, endpointBody, endpointBody.name) : 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 renderImport$3(importData) {
+	return `import ${[...importData.defaultImport ? [importData.defaultImport] : [], ...importData.bindings ? [`{ ${importData.bindings.join(", ")} }`] : []].join(", ")} 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) {
+	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)})${addOptional ? ".optional()" : ""}` : `${getImportedZodSchemaName(resolver, param.zodSchema)}${addOptional ? ".optional()" : ""}`;
+	const queryArgs = param.type === "Query" ? `, { type: "query", name: "${paramName}" }` : "";
+	return `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.parse}(${schemaValue}, ${paramName}${queryArgs})`;
+}
+function renderEndpointConfig(resolver, endpoint) {
+	const endpointConfig = getEndpointConfig(endpoint);
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	if (Object.keys(endpointConfig).length === 0) return hasAxiosRequestConfig ? AXIOS_REQUEST_CONFIG_NAME : "";
+	const lines = [];
+	lines.push("{");
+	if (hasAxiosRequestConfig) 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) : 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 }) {
+	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$2(ZOD_IMPORT));
+	for (const modelsImport of modelsImports) lines.push(renderImport$2(modelsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${getNamespaceName({
+		type: GenerateType.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: GenerateType.Models,
+		tag,
+		options: resolver.options
+	});
+	const commonNamespace = getNamespaceName({
+		type: GenerateType.Models,
+		tag: resolver.options.defaultTag,
+		options: resolver.options
+	});
+	const commonModelsPath = `${getImportPath(resolver.options)}${getTagImportPath({
+		type: GenerateType.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);
+		}
+	}
+	while (queue.length > 0) {
+		const schemaName = queue.shift();
+		if (!schemaName) continue;
+		const refs = getZodSchemaRefs(resolver, schemaName);
+		for (const ref of refs) enqueue(ref);
+	}
+	return Array.from(usedSchemaNames);
+}
+function renderImport$2(importData) {
+	return `import ${[...importData.defaultImport ? [importData.defaultImport] : [], ...importData.bindings ? [`{ ${importData.bindings.join(", ")} }`] : []].join(", ")} 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/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/generateQueries.ts
+const endpointParamMappingCache = /* @__PURE__ */ new WeakMap();
+function generateQueries(params) {
+	const { resolver, data, tag } = params;
+	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 hasAxiosImport = hasAxiosRequestConfig || hasAxiosDefaultImport;
+	const axiosImport = {
+		defaultImport: hasAxiosDefaultImport ? AXIOS_DEFAULT_IMPORT_NAME : void 0,
+		bindings: hasAxiosRequestConfig ? [AXIOS_REQUEST_CONFIG_TYPE] : [],
+		from: AXIOS_IMPORT.from
+	};
+	const { queryEndpoints, infiniteQueryEndpoints, mutationEndpoints, aclEndpoints } = endpointGroups;
+	const queryImport = {
+		bindings: [
+			...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.optionsType, MUTATION_EFFECTS.hookName] : []],
+		from: getMutationEffectsImportPath(resolver.options)
+	};
+	const hasAclCheck = resolver.options.checkAcl && aclEndpoints.length > 0;
+	const aclCheckImport = {
+		bindings: [ACL_CHECK_HOOK],
+		from: getAclCheckImportPath(resolver.options)
+	};
+	const queryTypesImport = {
+		bindings: [
+			"OpenApiQueryConfig",
+			...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: ["OpenApiWorkspaceContext"],
+		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 endpointRuntimeSchemas = getUniqueArray([...endpoints.map((endpoint) => endpoint.response), ...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: getZodExtendedImportPath(resolver.options)
+	};
+	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: GenerateType.Queries,
+		tag,
+		options: resolver.options
+	});
+	const lines = [];
+	if (hasAxiosImport) lines.push(renderImport$1(axiosImport));
+	if (inlineEndpoints) {
+		lines.push(renderImport$1(appRestClientImport));
+		if (hasZodImport) lines.push(renderImport$1(ZOD_IMPORT));
+		if (hasZodExtendedImport) lines.push(renderImport$1(zodExtendedImport));
+	}
+	lines.push(renderImport$1(queryImport));
+	if (hasMutationEffects) lines.push(renderImport$1(queryModulesImport));
+	if (hasMutationEffectsImport) lines.push(renderImport$1(mutationEffectsImport));
+	if (hasAclCheck) {
+		lines.push(renderImport$1(aclCheckImport));
+		for (const aclImport of aclImports) lines.push(renderImport$1(aclImport));
+	}
+	lines.push(renderImport$1(queryTypesImport));
+	if (hasWorkspaceContext) lines.push(renderImport$1(workspaceContextImport));
+	for (const modelsImport of modelsImports) lines.push(renderImport$1(modelsImport));
+	for (const endpointsImport of endpointsImports) lines.push(renderImport$1(endpointsImport));
+	lines.push("");
+	if (resolver.options.tsNamespaces) lines.push(`export namespace ${namespace} {`);
+	if (inlineEndpoints) {
+		lines.push(...renderInlineEndpoints({
+			resolver,
+			endpoints
+		}));
+		lines.push("");
+	}
+	lines.push(`export const ${QUERIES_MODULE_NAME} = ${hasMutationEffects ? `${QUERY_MODULE_ENUM}.${tag}` : `"${namespace}"`};`);
+	lines.push("");
+	lines.push(renderQueryKeys({
+		resolver,
+		queryEndpoints
+	}));
+	lines.push("");
+	for (const endpoint of endpoints) {
+		const endpointInfo = endpointGroups.infoByEndpoint.get(endpoint);
+		if (endpointInfo?.query) {
+			lines.push(renderQuery({
+				resolver,
+				endpoint,
+				inlineEndpoints
+			}));
+			lines.push("");
+		}
+		if (endpointInfo?.mutation) {
+			lines.push(renderMutation({
+				resolver,
+				endpoint,
+				inlineEndpoints,
+				precomputed: endpointGroups.mutationDataByEndpoint.get(endpoint)
+			}));
+			lines.push("");
+		}
+		if (endpointInfo?.infiniteQuery) {
+			lines.push(renderInfiniteQuery({
+				resolver,
+				endpoint,
+				inlineEndpoints
+			}));
+			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(Object.entries(options ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([optionName, optionValue]) => [optionName, Boolean(optionValue)]));
+	const cached = endpointCache.get(key);
+	if (cached) return cached;
+	const computed = mapEndpointParamsToFunctionParams(resolver, endpoint, options);
+	endpointCache.set(key, computed);
+	return computed;
+}
+function renderImport$1(importData) {
+	return `import ${[...importData.defaultImport ? [importData.defaultImport] : [], ...importData.bindings ? [`{ ${importData.bindings.join(", ")} }`] : []].join(", ")} 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 renderEndpointParamDescription(endpointParam) {
+	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}\``);
+	return strs.join(". ");
+}
+function getWorkspaceParamNames(resolver, endpoint) {
+	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));
+	return getUniqueArray([...workspaceParamNames, ...aclParamNames]);
+}
+function getWorkspaceParamReplacements(resolver, endpoint) {
+	return Object.fromEntries(getWorkspaceParamNames(resolver, endpoint).map((name) => [name, `${name}FromWorkspace`]));
+}
+function renderWorkspaceParamResolutions({ replacements, indent }) {
+	const workspaceParamNames = Object.keys(replacements);
+	if (workspaceParamNames.length === 0) return [];
+	const lines = [`${indent}const workspaceContext = OpenApiWorkspaceContext.useContext();`];
+	for (const paramName of workspaceParamNames) lines.push(`${indent}const ${replacements[paramName]} = OpenApiWorkspaceContext.resolveParam(workspaceContext, "${paramName}", ${paramName});`);
+	return lines;
+}
+function renderAclCheckCall(resolver, endpoint, replacements, indent = "") {
+	const checkParams = getAbilityConditionsTypes(endpoint)?.map((condition) => invalidVariableNameCharactersToCamel(condition.name));
+	const paramNames = new Set(endpoint.parameters.map((param) => invalidVariableNameCharactersToCamel(param.name)));
+	const hasAllCheckParams = checkParams?.every((param) => paramNames.has(param));
+	const args = hasAbilityConditions(endpoint) && hasAllCheckParams ? `{ ${(checkParams ?? []).map((param) => {
+		const resolvedParam = replacements?.[param] ?? param;
+		return resolvedParam === param ? param : `${param}: ${resolvedParam}`;
+	}).join(", ")} } ` : "";
+	return `${indent}checkAcl(${getImportedAbilityFunctionName(endpoint, resolver.options)}(${args}));`;
+}
+function addAsteriskAfterNewLine(str) {
+	return str.replace(/\n/g, "\n *");
+}
+function renderQueryJsDocs({ resolver, endpoint, mode }) {
+	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 } : {} });
+	for (const endpointParam of params) {
+		const source = mode === "mutation" ? "mutation" : "object";
+		lines.push(` * @param { ${endpointParam.type} } ${source}.${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)}${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 }) {
+	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 })}) => [...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
+		})}) => [...keys.all, "${endpoint.path}", "infinite", ${renderEndpointArgs(resolver, endpoint, { excludePageParam: true })}] as const,`);
+	}
+	lines.push("};");
+	return lines.join("\n");
+}
+function renderInlineEndpoints({ resolver, endpoints }) {
+	const lines = [];
+	for (const endpoint of endpoints) {
+		const endpointParams = renderEndpointParams(resolver, endpoint, {});
+		const endpointBody = getEndpointBody$1(endpoint);
+		const hasUndefinedEndpointBody = requiresBody(endpoint) && !endpointBody && hasEndpointConfig(endpoint, resolver);
+		const endpointConfig = renderInlineEndpointConfig(resolver, endpoint);
+		lines.push(`const ${getEndpointName(endpoint)} = (${endpointParams}${resolver.options.axiosRequestConfig ? `${AXIOS_REQUEST_CONFIG_NAME}?: ${AXIOS_REQUEST_CONFIG_TYPE}` : ""}) => {`);
+		lines.push(`  return ${APP_REST_CLIENT_NAME}.${endpoint.method}(`);
+		lines.push(`    { resSchema: ${getImportedZodSchemaName(resolver, endpoint.response)} },`);
+		lines.push(`    \`${getEndpointPath(endpoint)}\`,`);
+		if (endpointBody) lines.push(`    ${resolver.options.parseRequestParams ? renderInlineEndpointParamParse(resolver, endpointBody, endpointBody.name) : endpointBody.name},`);
+		else if (hasUndefinedEndpointBody) lines.push("    undefined,");
+		lines.push(`    ${endpointConfig}`);
+		lines.push("  );");
+		lines.push("};");
+		lines.push("");
+	}
+	return lines;
+}
+function renderInlineEndpointParamParse(resolver, param, paramName) {
+	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)})${addOptional ? ".optional()" : ""}` : `${getImportedZodSchemaName(resolver, param.zodSchema)}${addOptional ? ".optional()" : ""}`;
+	const queryArgs = param.type === "Query" ? `, { type: "query", name: "${paramName}" }` : "";
+	return `${ZOD_EXTENDED.namespace}.${ZOD_EXTENDED.exports.parse}(${schemaValue}, ${paramName}${queryArgs})`;
+}
+function renderInlineEndpointConfig(resolver, endpoint) {
+	const endpointConfig = getEndpointConfig(endpoint);
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	if (Object.keys(endpointConfig).length === 0) return hasAxiosRequestConfig ? AXIOS_REQUEST_CONFIG_NAME : "";
+	const lines = [];
+	lines.push("{");
+	if (hasAxiosRequestConfig) 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) : 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 renderQuery({ resolver, endpoint, inlineEndpoints }) {
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const hasAclCheck = resolver.options.checkAcl && endpoint.acl;
+	const workspaceParamReplacements = resolver.options.workspaceContext ? getWorkspaceParamReplacements(resolver, endpoint) : {};
+	const endpointArgs = renderEndpointArgs(resolver, endpoint, {});
+	const resolvedEndpointArgs = renderEndpointArgs(resolver, endpoint, {}, workspaceParamReplacements);
+	const endpointParams = renderEndpointParams(resolver, endpoint, { optionalPathParams: resolver.options.workspaceContext });
+	const hasQueryFn = endpointArgs.length > 0 || hasAxiosRequestConfig || hasAclCheck;
+	const hasQueryFnBody = Boolean(hasAclCheck) || Object.keys(workspaceParamReplacements).length > 0;
+	const importedEndpoint = inlineEndpoints ? getEndpointName(endpoint) : getImportedEndpointName(endpoint, resolver.options);
+	const lines = [];
+	lines.push(renderQueryJsDocs({
+		resolver,
+		endpoint,
+		mode: "query"
+	}));
+	lines.push(`export const ${getQueryName(endpoint)} = <TData>(${endpointParams ? `{ ${endpointArgs} }: { ${endpointParams} }, ` : ""}options?: AppQueryOptions<typeof ${importedEndpoint}, 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,
+		indent: "  "
+	}));
+	lines.push("  ");
+	lines.push(`  return ${QUERY_HOOKS.query}({`);
+	lines.push(`    queryKey: keys.${getEndpointName(endpoint)}(${resolvedEndpointArgs}),`);
+	if (hasQueryFn) {
+		lines.push(`    queryFn: () => ${hasQueryFnBody ? "{ " : ""}`);
+		if (hasAclCheck) lines.push(renderAclCheckCall(resolver, endpoint, workspaceParamReplacements, "    "));
+		lines.push(`    ${hasQueryFnBody ? "return " : ""}${importedEndpoint}(${resolvedEndpointArgs}${hasAxiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""})${hasQueryFnBody ? " }" : ""},`);
+	} else lines.push(`    queryFn: ${importedEndpoint},`);
+	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 hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const workspaceParamReplacements = resolver.options.workspaceContext ? getWorkspaceParamReplacements(resolver, endpoint) : {};
+	const endpointParams = renderEndpointParams(resolver, endpoint, {
+		includeFileParam: true,
+		optionalPathParams: resolver.options.workspaceContext
+	});
+	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 lines = [];
+	lines.push(renderQueryJsDocs({
+		resolver,
+		endpoint,
+		mode: "mutation"
+	}));
+	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("  const queryConfig = OpenApiQueryConfig.useConfig();");
+	if (hasAclCheck) lines.push(`  const { checkAcl } = ${ACL_CHECK_HOOK}();`);
+	if (Object.keys(workspaceParamReplacements).length > 0) lines.push("  const workspaceContext = OpenApiWorkspaceContext.useContext();");
+	if (hasMutationEffects) lines.push(`  const { runMutationEffects } = useMutationEffects({ currentModule: ${QUERIES_MODULE_NAME} });`);
+	lines.push("");
+	lines.push(`  return ${QUERY_HOOKS.mutation}({`);
+	const mutationFnArg = endpointParams ? `{ ${destructuredMutationArgs}${endpoint.mediaUpload ? `${destructuredMutationArgs ? ", " : ""}abortController, onUploadProgress` : ""} }` : "";
+	lines.push(`    mutationFn: ${endpoint.mediaUpload ? "async " : ""}(${mutationFnArg}) => ${hasMutationFnBody ? "{ " : ""}`);
+	for (const [paramName, resolvedParamName] of Object.entries(workspaceParamReplacements)) lines.push(`      const ${resolvedParamName} = OpenApiWorkspaceContext.resolveParam(workspaceContext, "${paramName}", ${paramName});`);
+	if (hasAclCheck) lines.push(renderAclCheckCall(resolver, endpoint, workspaceParamReplacements, "      "));
+	if (endpoint.mediaUpload) {
+		lines.push(`      const uploadInstructions = await ${endpointFunction}(${resolvedEndpointArgs}${hasAxiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""});`);
+		lines.push("      ");
+		lines.push("      if (file && uploadInstructions.url) {");
+		lines.push("        const method = (data?.method?.toLowerCase() ?? \"put\") as \"put\" | \"post\";");
+		lines.push("        let dataToSend: File | FormData = file;");
+		lines.push("        if (method === \"post\") {");
+		lines.push("          dataToSend = new FormData();");
+		lines.push("          if (uploadInstructions.fields) {");
+		lines.push("            for (const [key, value] of uploadInstructions.fields) {");
+		lines.push("              dataToSend.append(key, value);");
+		lines.push("            }");
+		lines.push("          }");
+		lines.push("          dataToSend.append(\"file\", file);");
+		lines.push("        }");
+		lines.push("        await axios[method](uploadInstructions.url, dataToSend, {");
+		lines.push("          headers: {");
+		lines.push("            \"Content-Type\": file.type,");
+		lines.push("          },");
+		lines.push("          signal: abortController?.signal,");
+		lines.push("          onUploadProgress: onUploadProgress");
+		lines.push("          ? (progressEvent) => onUploadProgress({ loaded: progressEvent.loaded, total: progressEvent.total ?? 0 })");
+		lines.push("          : undefined,");
+		lines.push("        });");
+		lines.push("      }");
+		lines.push("      ");
+		lines.push("      return uploadInstructions;");
+	} else lines.push(`      ${hasMutationFnBody ? "return " : ""}${endpointFunction}(${resolvedEndpointArgs}${hasAxiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""})`);
+	if (hasMutationFnBody) lines.push("    },");
+	else lines.push(",");
+	lines.push("    ...options,");
+	if (hasMutationEffects) {
+		lines.push("    onSuccess: async (resData, variables, onMutateResult, context) => {");
+		if (updateQueryEndpoints.length > 0) {
+			if (destructuredVariables.length > 0) lines.push(`      const { ${destructuredVariables.join(", ")} } = variables;`);
+			for (const [paramName, resolvedParamName] of Object.entries(workspaceParamReplacements)) lines.push(`      const ${resolvedParamName} = OpenApiWorkspaceContext.resolveParam(workspaceContext, "${paramName}", ${paramName});`);
+			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 workspaceParamReplacements = resolver.options.workspaceContext ? getWorkspaceParamReplacements(resolver, endpoint) : {};
+	const endpointParams = renderEndpointParams(resolver, endpoint, {
+		excludePageParam: true,
+		optionalPathParams: resolver.options.workspaceContext
+	});
+	const endpointArgsWithoutPage = renderEndpointArgs(resolver, endpoint, { excludePageParam: true });
+	const resolvedEndpointArgsWithoutPage = renderEndpointArgs(resolver, endpoint, { excludePageParam: true }, workspaceParamReplacements);
+	renderEndpointArgs(resolver, endpoint, { replacePageParam: true });
+	const resolvedEndpointArgsWithPage = renderEndpointArgs(resolver, endpoint, { replacePageParam: true }, workspaceParamReplacements);
+	const endpointFunction = inlineEndpoints ? getEndpointName(endpoint) : getImportedEndpointName(endpoint, resolver.options);
+	const hasQueryFnBody = Boolean(hasAclCheck) || Object.keys(workspaceParamReplacements).length > 0;
+	const lines = [];
+	lines.push(renderQueryJsDocs({
+		resolver,
+		endpoint,
+		mode: "infiniteQuery"
+	}));
+	lines.push(`export const ${getInfiniteQueryName(endpoint)} = <TData>(${endpointParams ? `{ ${endpointArgsWithoutPage} }: { ${endpointParams} }, ` : ""}options?: AppInfiniteQueryOptions<typeof ${endpointFunction}, 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,
+		indent: "  "
+	}));
+	lines.push("");
+	lines.push(`  return ${QUERY_HOOKS.infiniteQuery}({`);
+	lines.push(`    queryKey: keys.${getEndpointName(endpoint)}Infinite(${resolvedEndpointArgsWithoutPage}),`);
+	lines.push(`    queryFn: ({ pageParam }) => ${hasQueryFnBody ? "{ " : ""}`);
+	if (hasAclCheck) lines.push(renderAclCheckCall(resolver, endpoint, workspaceParamReplacements, "    "));
+	lines.push(`    ${hasQueryFnBody ? "return " : ""}${endpointFunction}(${resolvedEndpointArgsWithPage}${hasAxiosRequestConfig ? `, ${AXIOS_REQUEST_CONFIG_NAME}` : ""})${hasQueryFnBody ? " }" : ""},`);
+	lines.push("    initialPageParam: 1,");
+	lines.push(`    getNextPageParam: ({ ${resolver.options.infiniteQueryResponseParamNames.page}, ${resolver.options.infiniteQueryResponseParamNames.totalItems}, ${resolver.options.infiniteQueryResponseParamNames.limit}: limitParam }) => {`);
+	lines.push(`      const pageParam = ${resolver.options.infiniteQueryResponseParamNames.page} ?? 1;`);
+	lines.push(`      return pageParam * limitParam < ${resolver.options.infiniteQueryResponseParamNames.totalItems} ? pageParam + 1 : null;`);
+	lines.push("    },");
+	lines.push("    ...options,");
+	lines.push("  });");
+	lines.push("};");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/generators/generate/generateAclCheck.ts
+function generateAclCheck(resolver) {
+	const abilityContextImportPath = resolver.options.abilityContextImportPath ?? ABILITY_CONTEXT_IMPORT.from;
+	const appAbilitiesImportPath = getAppAbilitiesImportPath(resolver.options);
+	const errorHandlingImportPath = resolver.options.errorHandlingImportPath ?? ERROR_HANDLING_IMPORT.from;
+	const genericAppAbilities = resolver.options.abilityContextGenericAppAbilities ? `<${ACL_APP_ABILITIES}>` : "";
+	return `import { ${CASL_ABILITY_BINDING.abilityTuple} } from "@casl/ability";
+import { type ${ERROR_HANDLERS.ErrorHandler}, ${ERROR_HANDLERS.SharedErrorHandler} } from "${errorHandlingImportPath}";
+import { ${ABILITY_CONTEXT} } from "${abilityContextImportPath}";
+import { useCallback } from "react";
+import { ${ACL_APP_ABILITIES} } from "${appAbilitiesImportPath}";
+
+interface UseAclCheckProps {
+  errorHandler?: ${ERROR_HANDLERS.ErrorHandler}<never>;
+}
+
+export function ${ACL_CHECK_HOOK}({ errorHandler }: UseAclCheckProps = {}) {
+  const ability = ${ABILITY_CONTEXT}.useAbility${genericAppAbilities}();
+
+  const checkAcl = useCallback((appAbility: ${ACL_APP_ABILITIES}) => {
+    if (!ability.can(...(appAbility as ${CASL_ABILITY_BINDING.abilityTuple}))) {
+      (errorHandler ?? ${ERROR_HANDLERS.SharedErrorHandler}).rethrowError(new Error("ACL check failed"));
+    }
+  }, [ability, errorHandler]);
+
+  return { checkAcl };
+}
+`;
+}
+
+//#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/generateQueryModules.ts
+function generateQueryModules({ resolver, data }) {
+	const modules = [];
+	data.forEach((_, tag) => {
+		const endpoints = data.get(tag)?.endpoints;
+		if (!endpoints || endpoints.length === 0) return;
+		modules.push({
+			tag,
+			namespace: getNamespaceName({
+				type: GenerateType.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/generate/generateZodExtended.ts
+function generateZodExtended(resolver) {
+	const errorHandlingImport = {
+		...ERROR_HANDLING_IMPORT,
+		from: resolver.options.errorHandlingImportPath ?? ERROR_HANDLING_IMPORT.from
+	};
+	return `${renderImport(ZOD_IMPORT)}
+${renderImport(errorHandlingImport)}
+
+export namespace ZodExtended {
+  interface ParseOptions {
+    type: "body" | "query";
+    name?: string;
+    errorHandler?: ${ERROR_HANDLERS.ErrorHandler}<never>;
+  }
+
+  export function ${ZOD_EXTENDED.exports.parse}<ZOutput, ZInput>(
+    schema: z.ZodType<ZOutput, ZInput>,
+    data: unknown,
+    { type, name, errorHandler }: ParseOptions = { type: "body" },
+  ) {
+    try {
+      return schema.parse(data);
+    } catch (e) {
+      if (e instanceof z.ZodError) {
+        e.name = \`FE Request \${type === "body" ? "body" : "query param"}\${name ? \` ("\${name}")\` : ""} schema mismatch - ZodError\`;
+      }
+      (errorHandler ?? ${ERROR_HANDLERS.SharedErrorHandler}).rethrowError(e);
+      throw e;
+    }
+  }
+
+  function isSortExpValid(enumSchema: z.ZodEnum, data?: string) {
+    if (data === undefined || data === "" || enumSchema.options.length === 0) {
+      return true;
+    }
+
+    const prefixedEnumOptions = \`([+-]?(\${enumSchema.options.join("|")}))\`;
+    const commaSeparatedOptions = \`(\${prefixedEnumOptions})(\\s*,\\s*\${prefixedEnumOptions})*\`;
+    return new RegExp(\`^\${commaSeparatedOptions}$\`).test(data);
+  }
+
+  export const ${ZOD_EXTENDED.exports.sortExp} = (enumSchema: z.ZodEnum) =>
+    z.string().superRefine((arg, ctx) => {
+      if (!isSortExpValid(enumSchema, arg)) {
+        ctx.addIssue({
+          code: "invalid_value",
+          message: "Invalid sorting string.",
+          values: [],
+        });
+      }
+    });
+}
+`;
+}
+function renderImport(importData) {
+	return `import ${[...importData.defaultImport ? [importData.defaultImport] : [], ...importData.bindings ? [`{ ${importData.bindings.join(", ")} }`] : []].join(", ")} from "${importData.from}";`;
+}
+
+//#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
+		})
+	}, ...resolver.options.checkAcl ? [{
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName: getFileNameWithExtension(ACL_CHECK_FILE)
+		}),
+		content: generateAclCheck(resolver)
+	}] : []];
+}
+function getMutationEffectsFiles(data, resolver) {
+	if (!resolver.options.mutationEffects) return [];
+	return [...getAssetFiles([MUTATION_EFFECTS_FILE, CROSS_TAB_QUERY_INVALIDATION_FILE], resolver), {
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName: getFileNameWithExtension(QUERY_MODULES_FILE)
+		}),
+		content: generateQueryModules({
+			resolver,
+			data
+		})
+	}];
+}
+function getZodExtendedFiles(data, resolver) {
+	if (!resolver.options.parseRequestParams) return [];
+	return [{
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName: getFileNameWithExtension(ZOD_EXTENDED_FILE)
+		}),
+		content: generateZodExtended(resolver)
+	}];
+}
+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)
+	}];
+}
+function getAssetFiles(files, resolver) {
+	return files.map((file) => getAssetFile(file, resolver));
+}
+function getAssetFile(file, resolver) {
+	const fileName = getFileNameWithExtension(file);
+	let content = readAssetSync(fileName);
+	if (file.fileName === MUTATION_EFFECTS_FILE.fileName) content = content.replace("import { OpenApiQueryConfig, QueryModule, InvalidationMap } from \"../lib/config/queryConfig.context\";", `import { OpenApiQueryConfig, InvalidationMap } from "${PACKAGE_IMPORT_PATH}";\nimport { QueryModule } from "./${QUERY_MODULES_FILE.fileName}";`);
+	return {
+		fileName: getOutputFileName({
+			output: resolver.options.output,
+			fileName
+		}),
+		content
+	};
+}
+
+//#endregion
+//#region src/generators/generateCodeFromOpenAPIDoc.ts
+function generateCodeFromOpenAPIDoc(openApiDoc, options, profiler) {
+	const p = profiler ?? new Profiler(false);
+	const importPath = options.standalone && options.importPath === "ts" ? "relative" : options.importPath;
+	const { resolver, data } = p.runSync("data.extract", () => getDataFromOpenAPIDoc(openApiDoc, {
+		...options,
+		importPath
+	}, 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 ? [GenerateType.Models] : [
+		GenerateType.Models,
+		...shouldGenerateEndpoints ? [GenerateType.Endpoints] : [],
+		GenerateType.Queries,
+		...resolver.options.acl ? [GenerateType.Acl] : [],
+		...resolver.options.builderConfigs ? [GenerateType.Configs] : []
+	];
+	const generateFunctions = {
+		[GenerateType.Models]: generateModels,
+		[GenerateType.Endpoints]: generateEndpoints,
+		[GenerateType.Queries]: generateQueries,
+		[GenerateType.Acl]: generateAcl,
+		[GenerateType.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 === GenerateType.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)));
+	return generateFilesData;
+}
+
+//#endregion
+export { VALIDATION_ERROR_TYPE_TITLE as S, isMediaTypeAllowed as _, deepMerge as a, formatTag as b, getSchemaTsMetaType as c, getTagImportPath as d, getQueryName as f, groupByType as g, GenerateType as h, getDataFromOpenAPIDoc as i, getTsTypeBase as l, getNamespaceName as m, getOutputFileName as n, isMutation as o, DEFAULT_GENERATE_OPTIONS as p, writeGenerateFileData as r, isQuery as s, generateCodeFromOpenAPIDoc as t, getTagFileName as u, isParamMediaTypeAllowed as v, Profiler as x, invalidVariableNameCharactersToCamel as y };