@povio/openapi-codegen-cli 3.3.0-rc.2 → 3.3.1

package/dist/generate.utils-SfgYwPe7.cjs

@@ -0,0 +1,2271 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let fs = require("fs");
+fs = __toESM(fs, 1);
+let path = require("path");
+path = __toESM(path, 1);
+require("url");
+let node_module = require("node:module");
+let node_fs = require("node:fs");
+let node_url = require("node:url");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let openapi_types = require("openapi-types");
+//#region src/generators/const/package.const.ts
+const PACKAGE_IMPORT_PATH = "@povio/openapi-codegen-cli";
+const AXIOS_PACKAGE_IMPORT_PATH = `${PACKAGE_IMPORT_PATH}/axios`;
+const NATIVE_PACKAGE_IMPORT_PATH = `${PACKAGE_IMPORT_PATH}/native`;
+const REST_PACKAGE_IMPORT_PATH = `${PACKAGE_IMPORT_PATH}/rest`;
+const QUERY_PACKAGE_IMPORT_PATH = `${PACKAGE_IMPORT_PATH}/query`;
+const CONFIG_PACKAGE_IMPORT_PATH = `${PACKAGE_IMPORT_PATH}/config`;
+//#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/const/options.const.ts
+const DEFAULT_GENERATE_OPTIONS = {
+	input: "http://localhost:4000/docs-json/",
+	output: "output",
+	clearOutput: false,
+	incremental: true,
+	splitByTags: true,
+	defaultTag: "Common",
+	includeTags: [],
+	excludeTags: [],
+	excludePathRegex: "",
+	excludeRedundantZodSchemas: true,
+	tsNamespaces: true,
+	treeShakeableNamespaces: false,
+	tsPath: "@/data",
+	importPath: "ts",
+	configs: {
+		["models"]: {
+			outputFileNameSuffix: "models",
+			namespaceSuffix: "Models"
+		},
+		["endpoints"]: {
+			outputFileNameSuffix: "api",
+			namespaceSuffix: "Api"
+		},
+		["queries"]: {
+			outputFileNameSuffix: "queries",
+			namespaceSuffix: "Queries"
+		},
+		["acl"]: {
+			outputFileNameSuffix: "acl",
+			namespaceSuffix: "Acl"
+		},
+		["configs"]: {
+			outputFileNameSuffix: "configs",
+			namespaceSuffix: "Configs"
+		}
+	},
+	baseUrl: "",
+	modelsOnly: false,
+	standalone: false,
+	compileSchemas: false,
+	lazySchemas: false,
+	generateJsDoc: false,
+	schemaSuffix: SCHEMA_SUFFIX,
+	enumSuffix: ENUM_SUFFIX,
+	modelsInCommon: false,
+	modelsInModules: false,
+	withDefaultValues: true,
+	extractEnums: true,
+	replaceOptionalWithNullish: false,
+	restClient: "axios",
+	restClientImportPath: "",
+	zodImportPath: "@povio/openapi-codegen-cli/zod",
+	errorHandlingImportPath: "",
+	removeOperationPrefixEndingWith: "Controller_",
+	parseRequestParams: true,
+	inlineEndpoints: false,
+	inlineEndpointsExcludeModules: [],
+	queryTypesImportPath: QUERY_PACKAGE_IMPORT_PATH,
+	mutationEffectsImportPath: QUERY_PACKAGE_IMPORT_PATH,
+	axiosRequestConfig: false,
+	mutationEffects: true,
+	mutationDefaultOnError: false,
+	workspaceContext: [],
+	prefetchQueries: true,
+	mutationScope: false,
+	infiniteQueries: false,
+	infiniteQueryParamNames: { page: "page" },
+	infiniteQueryResponseParamNames: {
+		page: "page",
+		totalItems: "totalItems",
+		limit: "limit"
+	},
+	acl: true,
+	checkAcl: true,
+	abilityContextGenericAppAbilities: false,
+	abilityContextImportPath: "",
+	aclCheckImportPath: "@povio/openapi-codegen-cli/acl",
+	builderConfigs: false,
+	filterParamName: "filter",
+	dataResponseParamNames: ["data", "items"],
+	dynamicInputsImportPath: "@povio/ui",
+	dynamicColumnsImportPath: "@povio/ui"
+};
+//#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/utils/file.utils.ts
+function getOutputFileName({ output, fileName }) {
+	return `${output}/${fileName}`;
+}
+async function writeFileIfChanged(file, data, skipExistingCheck = false) {
+	if (skipExistingCheck) {
+		await fs.default.promises.writeFile(file, data, "utf-8");
+		return;
+	}
+	try {
+		if (await fs.default.promises.readFile(file, "utf-8") === data) return;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	await fs.default.promises.writeFile(file, data, "utf-8");
+}
+async function writeFile({ fileName, content }, options) {
+	const formattedContent = options?.formatGeneratedFile ? await options.formatGeneratedFile({
+		fileName,
+		content
+	}) : content;
+	await fs.default.promises.mkdir(path.default.dirname(fileName), { recursive: true });
+	await writeFileIfChanged(fileName, formattedContent, options?.skipExistingCheck);
+}
+async function writeGenerateFileData(filesData, options) {
+	if (!options?.formatGeneratedFile) {
+		const directories = new Set(filesData.map(({ fileName }) => path.default.dirname(fileName)));
+		for (const directory of directories) fs.default.mkdirSync(directory, { recursive: true });
+		await Promise.all(filesData.map(({ fileName, content }) => writeFileIfChanged(fileName, content, options?.skipExistingCheck)));
+		return;
+	}
+	for (const file of filesData) await writeFile(file, options);
+}
+function removeStaleGeneratedFiles({ output, filesData, options }) {
+	if (!fs.default.existsSync(output)) return;
+	const expectedFiles = new Set(filesData.map((file) => path.default.resolve(file.fileName)));
+	const generatedSuffixes = new Set(Object.values(options.configs).map((config) => config.outputFileNameSuffix));
+	const staleFiles = [];
+	const visit = (dirPath) => {
+		for (const dirent of fs.default.readdirSync(dirPath, { withFileTypes: true })) {
+			const entryPath = path.default.join(dirPath, dirent.name);
+			if (dirent.isDirectory()) {
+				visit(entryPath);
+				continue;
+			}
+			if (isGeneratedFile(entryPath, output, generatedSuffixes) && !expectedFiles.has(path.default.resolve(entryPath))) staleFiles.push(entryPath);
+		}
+	};
+	visit(output);
+	staleFiles.forEach((filePath) => fs.default.rmSync(filePath, { force: true }));
+	removeEmptyDirectories(output);
+}
+function isGeneratedFile(filePath, output, generatedSuffixes) {
+	const relativePath = path.default.relative(output, filePath);
+	if (relativePath === ".openapi-codegen-cache.json") return true;
+	const normalizedRelativePath = relativePath.split(path.default.sep).join("/");
+	if ([
+		"app-rest-client.ts",
+		"queryModules.ts",
+		"acl/app.ability.ts"
+	].includes(normalizedRelativePath)) return true;
+	if (path.default.parse(filePath).ext !== ".ts") return false;
+	const segments = relativePath.split(path.default.sep).filter(Boolean);
+	if (segments.length < 2) return false;
+	const moduleName = segments[0];
+	const fileName = segments[segments.length - 1];
+	if (!fileName.startsWith(`${moduleName}.`)) return false;
+	const suffix = fileName.slice(moduleName.length + 1).replace(/\.tsx?$/, "");
+	return generatedSuffixes.has(suffix);
+}
+function removeEmptyDirectories(root) {
+	if (!fs.default.existsSync(root)) return;
+	const removeIfEmpty = (dirPath) => {
+		for (const dirent of fs.default.readdirSync(dirPath, { withFileTypes: true })) if (dirent.isDirectory()) removeIfEmpty(path.default.join(dirPath, dirent.name));
+		if (dirPath !== root && fs.default.readdirSync(dirPath).length === 0) fs.default.rmdirSync(dirPath);
+	};
+	removeIfEmpty(root);
+}
+//#endregion
+//#region src/helpers/profile.helper.ts
+function nowMs() {
+	return Number(process.hrtime.bigint()) / 1e6;
+}
+var Profiler = class {
+	enabled;
+	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/native/native-bindings.ts
+let bindings;
+let nativePath;
+function getNativePath() {
+	if (nativePath) return nativePath;
+	const moduleDir = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+	const binaryName = `openapi-codegen-native-${process.platform}-${process.arch}.node`;
+	nativePath = [node_path.default.join(moduleDir, binaryName), node_path.default.resolve(moduleDir, "../../dist", binaryName)].find(node_fs.existsSync);
+	if (!nativePath) throw new Error("Native OpenAPI codegen module is not built. Run `bun run build:native`.");
+	return nativePath;
+}
+function hasNativeBindings() {
+	try {
+		getNativeBindings();
+		return true;
+	} catch {
+		return false;
+	}
+}
+function shouldUseNativeCodegen() {
+	if (process.env.OPENAPI_CODEGEN_NATIVE === "0") return false;
+	if (process.env.OPENAPI_CODEGEN_NATIVE === "1") return true;
+	return hasNativeBindings();
+}
+function getNativeBindings() {
+	if (!bindings) {
+		const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+		const resolvedNativePath = getNativePath();
+		if (typeof process.dlopen === "function") {
+			const nativeModule = { exports: {} };
+			process.dlopen(nativeModule, resolvedNativePath);
+			bindings = nativeModule.exports;
+		} else bindings = require$1(resolvedNativePath);
+	}
+	return bindings;
+}
+function compileNativeData(source, yaml, optionsJson) {
+	return getNativeBindings().compileData(source, yaml, optionsJson);
+}
+//#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 DOMAIN_ERRORS_FILE = {
+	fileName: "domain-errors",
+	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"
+};
+ERROR_HANDLERS.ErrorHandler, ERROR_HANDLERS.SharedErrorHandler;
+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 ZOD_EXTENDED = {
+	namespace: "ZodExtended",
+	exports: {
+		parse: "parse",
+		sortExp: "sortExp"
+	}
+};
+//#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) => {
+	const splits = strs.flatMap((str) => getAdjacentStringCombinations(splitByUppercase(capitalize(str))));
+	return getLongestMostCommon(splits);
+};
+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/array.utils.ts
+const getUniqueArray = (...arrs) => [...new Set(arrs.flat())];
+//#endregion
+//#region src/generators/utils/namespace.utils.ts
+const getNamespaceName = ({ type, tag, options }) => `${capitalize(tag)}${options.configs[type].namespaceSuffix}`;
+//#endregion
+//#region src/generators/utils/tag.utils.ts
+const formattedTagCache = /* @__PURE__ */ new Map();
+const tagFilterCache = /* @__PURE__ */ new WeakMap();
+function formatTag(tag) {
+	let formattedTag = formattedTagCache.get(tag);
+	if (formattedTag === void 0) {
+		formattedTag = nonWordCharactersToCamel(tag);
+		formattedTagCache.set(tag, formattedTag);
+	}
+	return formattedTag;
+}
+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 isTagIncluded(tag, options) {
+	const normalizedTag = formatTag(tag).toLowerCase();
+	let filters = tagFilterCache.get(options);
+	if (!filters) {
+		filters = {
+			include: new Set(options.includeTags.map((includeTag) => formatTag(includeTag).toLowerCase())),
+			exclude: new Set(options.excludeTags.map((excludeTag) => formatTag(excludeTag).toLowerCase()))
+		};
+		tagFilterCache.set(options, filters);
+	}
+	if (filters.include.has(normalizedTag)) return true;
+	if (filters.exclude.has(normalizedTag)) return false;
+	return options.includeTags.length === 0;
+}
+function shouldInlineEndpointsForTag(tag, options) {
+	if (!options.inlineEndpoints) return false;
+	return !(options.inlineEndpointsExcludeModules ?? []).some((moduleName) => formatTag(moduleName).toLowerCase() === tag.toLowerCase());
+}
+//#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/const/openapi.const.ts
+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 = [
+	openapi_types.OpenAPIV3.HttpMethods.GET,
+	openapi_types.OpenAPIV3.HttpMethods.PUT,
+	openapi_types.OpenAPIV3.HttpMethods.POST,
+	openapi_types.OpenAPIV3.HttpMethods.DELETE,
+	openapi_types.OpenAPIV3.HttpMethods.OPTIONS,
+	openapi_types.OpenAPIV3.HttpMethods.HEAD,
+	openapi_types.OpenAPIV3.HttpMethods.PATCH,
+	openapi_types.OpenAPIV3.HttpMethods.TRACE
+];
+const PRIMITIVE_TYPE_LIST = [
+	"string",
+	"number",
+	"integer",
+	"boolean"
+];
+const COMPOSITE_KEYWORDS = [
+	"allOf",
+	"anyOf",
+	"oneOf"
+];
+//#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/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/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) {
+	const formatted = prefixStringStartingWithNumberIfNeeded(text).normalize("NFKD").trim().replace(/\s+/g, "_").replace(/--+/g, "-").replace(/-+/g, "_").replace(/[^\w-]+/g, "_");
+	return snakeToCamel(formatted);
+}
+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) {
+	const preserveUnderscore = name.replaceAll("_", "#");
+	return snakeToCamel(preserveUnderscore.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, schema = param.schema, resolver) => {
+	const enumNames = getParameterEnumNames(param, schema);
+	return Array.isArray(enumNames) && enumNames.length > 0 && isStringLikeParameterSchema(schema, resolver);
+};
+function getParameterEnumNames(param, schema = param.schema) {
+	return param["x-enumNames"] ?? (schema && isSchemaObject(schema) ? schema["x-enumNames"] : void 0);
+}
+function isStringLikeParameterSchema(schema, resolver) {
+	if (!schema) return false;
+	if (isReferenceObject(schema)) return resolver ? isStringLikeParameterSchema(resolver.resolveObject(schema), resolver) : true;
+	if (schema.type === "string" || Array.isArray(schema.type) && schema.type.includes("string")) return true;
+	return [
+		...schema.allOf ?? [],
+		...schema.oneOf ?? [],
+		...schema.anyOf ?? []
+	].some((compositeSchema) => isStringLikeParameterSchema(compositeSchema, resolver));
+}
+const isPathExcluded = (path, options) => {
+	if (!options.excludePathRegex) return false;
+	return new RegExp(options.excludePathRegex).test(path);
+};
+//#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/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(isNamedZodSchema(zodSchemaName) ? zodSchemaName.split(".")[0] : zodSchemaName, options.schemaSuffix);
+const getImportedZodSchemaName = (resolver, zodSchemaName, namespaceTag) => {
+	if (!isNamedZodSchema(zodSchemaName)) return zodSchemaName;
+	const tag = getOwningOrLocalProxyTag(resolver, zodSchemaName.split(".")[0], namespaceTag);
+	return `${resolver.options.tsNamespaces ? `${getNamespaceName({
+		type: "models",
+		tag,
+		options: resolver.options
+	})}.` : ""}${zodSchemaName}`;
+};
+function getOwningOrLocalProxyTag(resolver, zodSchemaName, namespaceTag) {
+	if (namespaceTag && (resolver.options.modelsInCommon || resolver.options.modelsInModules) && resolver.options.splitByTags) return namespaceTag;
+	return resolver.getTagByZodSchemaName(zodSchemaName) ?? namespaceTag;
+}
+const getImportedZodSchemaInferedTypeName = (resolver, zodSchemaName, currentTag, namespaceTag) => {
+	if (!isNamedZodSchema(zodSchemaName)) return zodSchemaName === "z.void()" ? "void" : zodSchemaName;
+	const tag = getOwningOrLocalProxyTag(resolver, zodSchemaName.split(".")[0], namespaceTag);
+	return `${resolver.options.tsNamespaces && (Boolean(namespaceTag) || tag !== currentTag) ? `${getNamespaceName({
+		type: "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.acl.utils.ts
+const getAbilityFunctionName = (endpoint) => `canUse${capitalize(snakeToCamel(endpoint.operationName))}`;
+const getImportedAbilityFunctionName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: "acl",
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getAbilityFunctionName(endpoint)}`;
+};
+const getAbilityAction = (endpoint) => endpoint.acl?.[0].action;
+const getAbilitySubject = (endpoint) => endpoint.acl?.[0].subject;
+const hasAbilityConditions = (endpoint) => !!getAbilityConditionsTypes(endpoint)?.length;
+const getAbilityConditionsTypes = (endpoint) => endpoint.acl?.[0].conditionsTypes?.sort((a, b) => a.name.localeCompare(b.name));
+const getAbilityDescription = (endpoint) => endpoint.acl?.[0]?.description;
+const getAbilitySubjectTypes = (endpoint, resolver, tag) => {
+	const abilitySubject = getAbilitySubject(endpoint);
+	const types = [`"${abilitySubject ?? ""}"`];
+	if (hasAbilityConditions(endpoint)) types.push(`ForcedSubject<"${abilitySubject}"> & { ${getAbilityConditionsTypes(endpoint)?.map((conditionType) => `${conditionType.name}${conditionType.required ? "" : "?"}: ${getAbilityConditionType(conditionType, resolver, tag)},`).join(" ")} }`);
+	return types;
+};
+function getAbilityConditionType(conditionType, resolver, tag) {
+	if (!conditionType.zodSchemaName) return conditionType.type ?? "";
+	if (!resolver) return `${conditionType.type ?? ""}${conditionType.zodSchemaName}`;
+	return getImportedZodSchemaInferedTypeName(resolver, conditionType.zodSchemaName, tag, tag);
+}
+function getAclData({ resolver, data, tag }) {
+	const endpoints = data.get(tag)?.endpoints.filter(({ acl }) => acl && acl.length > 0);
+	if (!endpoints || endpoints.length === 0) return;
+	const hasAdditionalAbilityImports = endpoints.some(({ acl }) => acl?.[0].conditions && Object.keys(acl[0].conditions).length > 0);
+	const aclZodSchemas = endpoints.reduce((acc, endpoint) => {
+		const zodSchemas = endpoint.acl?.[0].conditionsTypes?.reduce((acc, propertyType) => [...acc, ...propertyType?.zodSchemaName ? [propertyType.zodSchemaName] : []], []);
+		return [...acc, ...zodSchemas ?? []];
+	}, []);
+	return {
+		endpoints,
+		hasAdditionalAbilityImports,
+		modelsImports: getModelsImports({
+			resolver,
+			tag,
+			zodSchemasAsTypes: getUniqueArray(aclZodSchemas)
+		})
+	};
+}
+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, /* @__PURE__ */ new Set([...appAbilitiesTypeMap.get(abilityAction) ?? [], ...getAbilitySubjectTypes(endpoint, resolver, tag)]));
+		});
+	});
+	const modelsImports = mergeImports(resolver.options, ...modelsImportsArr);
+	return {
+		appAbilitiesType: appAbilitiesTypeMap.size > 0 ? Object.fromEntries(Array.from(appAbilitiesTypeMap.entries()).map(([key, valueSet]) => [key, Array.from(valueSet)])) : void 0,
+		modelsImports,
+		hasAdditionalAbilityImports
+	};
+};
+/** Renders a `checkAcl(...)` call, passing the ability's conditions object only when the
+* ability function actually expects one (i.e. the endpoint declares matching conditions). */
+function renderAclCheckCall(resolver, endpoint, replacements, indent = "") {
+	const checkParams = getAbilityConditionsTypes(endpoint)?.map((condition) => invalidVariableNameCharactersToCamel(condition.name));
+	const paramNames = new Set(endpoint.parameters.map((param) => invalidVariableNameCharactersToCamel(param.name)));
+	const hasAllCheckParams = checkParams?.every((param) => paramNames.has(param));
+	const args = hasAbilityConditions(endpoint) && hasAllCheckParams ? `{ ${(checkParams ?? []).map((param) => {
+		const resolvedParam = replacements?.[param] ?? param;
+		return resolvedParam === param ? param : `${param}: ${resolvedParam}`;
+	}).join(", ")} } ` : "";
+	return `${indent}checkAcl(${getImportedAbilityFunctionName(endpoint, resolver.options)}(${args}));`;
+}
+//#endregion
+//#region src/generators/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 NATIVE_REQUEST_CONFIG_TYPE = "TransportRequestConfig";
+const NATIVE_RESPONSE_TYPE = "TransportResponse";
+const AXIOS_IMPORT = {
+	defaultImport: AXIOS_DEFAULT_IMPORT_NAME,
+	bindings: [],
+	typeBindings: [AXIOS_REQUEST_CONFIG_TYPE],
+	from: "axios"
+};
+function getRequestConfigTypeName(restClient) {
+	return restClient === "native" ? NATIVE_REQUEST_CONFIG_TYPE : AXIOS_REQUEST_CONFIG_TYPE;
+}
+//#endregion
+//#region src/generators/utils/endpoint.utils.ts
+const isGetEndpoint = (endpoint) => endpoint.method === openapi_types.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 === openapi_types.OpenAPIV3.HttpMethods.GET && !isPathSegmentParam(endpoint.pathSegments.at(-1)) && isPaginatedGetEndpoint(endpoint, options);
+const isReadEndpoint = (endpoint, readAllEndpoint) => endpoint.method === openapi_types.OpenAPIV3.HttpMethods.GET && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isCreateEndpoint = (endpoint, readAllEndpoint) => endpoint.method === openapi_types.OpenAPIV3.HttpMethods.POST && hasMatchingPathWithoutTrailingParam(endpoint, readAllEndpoint);
+const isUpdateEndpoint = (endpoint, readAllEndpoint) => [openapi_types.OpenAPIV3.HttpMethods.PUT, openapi_types.OpenAPIV3.HttpMethods.PATCH].includes(endpoint.method) && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isDeleteEndpoint = (endpoint, readAllEndpoint) => endpoint.method === openapi_types.OpenAPIV3.HttpMethods.DELETE && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isBulkDeleteEndpoint = (endpoint, readAllEndpoint) => endpoint.method === openapi_types.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/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/utils/ts.utils.ts
+function primitiveTypeToTsType(type) {
+	switch (type) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+	}
+}
+//#endregion
+//#region src/generators/utils/generate/generate.endpoints.utils.ts
+const endpointNameCache = /* @__PURE__ */ new WeakMap();
+const endpointPathCache = /* @__PURE__ */ new WeakMap();
+const endpointBodyCache = /* @__PURE__ */ new WeakMap();
+const endpointConfigCache = /* @__PURE__ */ new WeakMap();
+const getEndpointName = (endpoint) => {
+	let name = endpointNameCache.get(endpoint);
+	if (name === void 0) {
+		name = decapitalize(snakeToCamel(endpoint.operationName));
+		endpointNameCache.set(endpoint, name);
+	}
+	return name;
+};
+function getImportedEndpointName(endpoint, options) {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: "endpoints",
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getEndpointName(endpoint)}`;
+}
+const requiresBody = (endpoint) => endpoint.method !== openapi_types.OpenAPIV3.HttpMethods.GET;
+const findEndpointBody = (endpoint) => endpoint.parameters.find((param) => param.type === "Body");
+const getEndpointBody = (endpoint) => {
+	if (!endpointBodyCache.has(endpoint)) endpointBodyCache.set(endpoint, findEndpointBody(endpoint));
+	return endpointBodyCache.get(endpoint);
+};
+const hasEndpointConfig = (endpoint, resolver) => {
+	const endpointConfig = getEndpointConfig(endpoint);
+	const hasAxiosRequestConfig = resolver.options.axiosRequestConfig;
+	const needsBlobConfig = endpoint.mediaDownload || endpoint.response === "z.instanceof(Blob)";
+	return Object.keys(endpointConfig).length > 0 || hasAxiosRequestConfig || needsBlobConfig;
+};
+const getEndpointPath = (endpoint) => {
+	let endpointPath = endpointPathCache.get(endpoint);
+	if (endpointPath === void 0) {
+		endpointPath = endpoint.path.replace(/:([a-zA-Z0-9_]+)/g, "${$1}");
+		endpointPathCache.set(endpoint, endpointPath);
+	}
+	return endpointPath;
+};
+function mapEndpointParamsToFunctionParams(resolver, endpoint, options) {
+	const optionalPathParams = options?.optionalPathParams ? new Set(options.optionalPathParams) : void 0;
+	const params = endpoint.parameters.map((param) => {
+		let type = "string";
+		if (isNamedZodSchema(param.zodSchema)) type = getImportedZodSchemaInferedTypeName(resolver, param.zodSchema, void 0, options?.modelNamespaceTag);
+		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 !== "data") && (!options?.excludePageParam || param.name !== resolver.options.infiniteQueryParamNames.page) && (!options?.includeOnlyRequiredParams || param.required) && (!options?.excludePathParams || param.paramType !== "Path")).map((param) => ({
+		...param,
+		name: options?.replacePageParam && param.name === resolver.options.infiniteQueryParamNames.page ? "pageParam" : param.name,
+		required: param.paramType === "Path" && optionalPathParams?.has(param.name) ? false : param.required && (param.paramType === "Path" || !options?.pathParamsRequiredOnly)
+	}));
+}
+function getEndpointConfig(endpoint) {
+	let config = endpointConfigCache.get(endpoint);
+	if (!config) {
+		config = createEndpointConfig(endpoint);
+		endpointConfigCache.set(endpoint, config);
+	}
+	return config;
+}
+function createEndpointConfig(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 } : {}
+	};
+}
+/** Renders the body of a media-upload mutationFn: call the endpoint (without the file arg) to
+* get upload instructions, then upload the file itself to the returned URL. Shared between
+* renderMutation (*.queries.ts) and renderMutationContent (*.configs.ts / builderConfigs) so
+* both mutation paths stay in sync. Lines are relative to the caller's own indent. */
+function renderMediaUploadMutationBody({ resolver, endpointFunction, resolvedEndpointArgs }) {
+	return [
+		`const uploadInstructions = await ${endpointFunction}(${resolvedEndpointArgs}${resolver.options.axiosRequestConfig ? `${resolvedEndpointArgs ? ", " : ""}${AXIOS_REQUEST_CONFIG_NAME}` : ""});`,
+		"",
+		"if (file && uploadInstructions.url) {",
+		`  const method = (uploadInstructions.method?.toLowerCase() ?? "put") as "put" | "post";`,
+		"  let dataToSend: File | FormData = file;",
+		"  if (method === \"post\") {",
+		"    dataToSend = new FormData();",
+		"    if (\"fields\" in uploadInstructions && uploadInstructions.fields) {",
+		"      for (const [key, value] of Object.entries(uploadInstructions.fields)) {",
+		"        dataToSend.append(key, String(value));",
+		"      }",
+		"    }",
+		"    dataToSend.append(\"file\", file);",
+		"  }",
+		resolver.options.restClient === "native" ? "  await AppRestClient.upload(uploadInstructions.url, dataToSend, {" : "  await axios[method](uploadInstructions.url, dataToSend, {",
+		resolver.options.restClient === "native" ? "    headers: method === \"put\" ? { \"Content-Type\": file.type } : undefined," : "    headers: {",
+		...resolver.options.restClient === "native" ? [] : ["      \"Content-Type\": file.type,", "    },"],
+		"    signal: abortController?.signal,",
+		"    onUploadProgress: onUploadProgress",
+		"    ? (progressEvent) => onUploadProgress({ loaded: progressEvent.loaded, total: progressEvent.total ?? 0 })",
+		"    : undefined,",
+		resolver.options.restClient === "native" ? "  }, method);" : "  });",
+		"}",
+		"",
+		"return uploadInstructions;"
+	];
+}
+//#endregion
+//#region src/generators/utils/generate/generate.query.utils.ts
+const operationNameByEndpoint = /* @__PURE__ */ new WeakMap();
+const capitalizedOperationNameByEndpoint = /* @__PURE__ */ new WeakMap();
+function getOperationName(endpoint) {
+	let name = operationNameByEndpoint.get(endpoint);
+	if (name === void 0) {
+		name = snakeToCamel(endpoint.operationName);
+		operationNameByEndpoint.set(endpoint, name);
+	}
+	return name;
+}
+function getCapitalizedOperationName(endpoint) {
+	let name = capitalizedOperationNameByEndpoint.get(endpoint);
+	if (name === void 0) {
+		name = capitalize(getOperationName(endpoint));
+		capitalizedOperationNameByEndpoint.set(endpoint, name);
+	}
+	return name;
+}
+const getQueryName = (endpoint, mutation) => {
+	const addMutationSuffix = isQuery(endpoint) && isMutation(endpoint) && mutation;
+	return `use${getCapitalizedOperationName(endpoint)}${addMutationSuffix ? "Mutation" : ""}`;
+};
+const getInfiniteQueryName = (endpoint) => `use${getCapitalizedOperationName(endpoint)}Infinite`;
+const getQueryOptionsName = (endpoint) => `${getOperationName(endpoint)}QueryOptions`;
+const getInfiniteQueryOptionsName = (endpoint) => `${getOperationName(endpoint)}InfiniteQueryOptions`;
+const getPrefetchQueryName = (endpoint) => `prefetch${getCapitalizedOperationName(endpoint)}`;
+const getPrefetchInfiniteQueryName = (endpoint) => `prefetch${getCapitalizedOperationName(endpoint)}Infinite`;
+const getImportedQueryName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: "queries",
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getQueryName(endpoint)}`;
+};
+const getImportedInfiniteQueryName = (endpoint, options) => {
+	return `${options.tsNamespaces ? `${getNamespaceName({
+		type: "queries",
+		tag: getEndpointTag(endpoint, options),
+		options
+	})}.` : ""}${getInfiniteQueryName(endpoint)}`;
+};
+//#endregion
+//#region src/generators/utils/generate/generate.imports.utils.ts
+function getModelsImports({ resolver, tag, zodSchemas = [], zodSchemasAsTypes = [] }) {
+	const type = "models";
+	const getTag = (zodSchemaName) => resolver.getTagByZodSchemaName(zodSchemaName.split(".")[0]);
+	const zodSchemaImports = getImports({
+		type,
+		tag,
+		entities: zodSchemas,
+		getTag,
+		getEntityName: (zodSchema) => zodSchema.split(".")[0],
+		options: resolver.options
+	});
+	const zodSchemaTypeImports = getImports({
+		type,
+		tag,
+		entities: zodSchemasAsTypes,
+		getTag,
+		getEntityName: (zodSchema) => getZodSchemaInferedTypeName(zodSchema, resolver.options),
+		options: resolver.options
+	}).map((importData) => ({
+		...importData,
+		...resolver.options.tsNamespaces ? {} : { typeOnly: true }
+	}));
+	return mergeImports(resolver.options, zodSchemaImports, zodSchemaTypeImports);
+}
+function getEndpointsImports({ tag, endpoints, options }) {
+	return getImports({
+		type: "endpoints",
+		tag,
+		entities: endpoints,
+		getTag: (endpoint) => getEndpointTag(endpoint, options),
+		getEntityName: getEndpointName,
+		options
+	});
+}
+function getQueriesImports({ tag, endpoints, options }) {
+	return getImports({
+		type: "queries",
+		tag,
+		entities: endpoints,
+		getTag: (endpoint) => getEndpointTag(endpoint, options),
+		getEntityName: getQueryName,
+		options
+	});
+}
+function getInfiniteQueriesImports({ tag, endpoints, options }) {
+	return getImports({
+		type: "queries",
+		tag,
+		entities: endpoints,
+		getTag: (endpoint) => getEndpointTag(endpoint, options),
+		getEntityName: getInfiniteQueryName,
+		options
+	});
+}
+function getAclImports({ tag, endpoints, options }) {
+	return getImports({
+		type: "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(`src/data`, "g").test(options.output)) importPath = options.output.replace(new RegExp(`.*${TEMPLATE_DATA_FILE_PATH}`, "g"), options.tsPath);
+	return `${importPath}/`.replace(/\/\//g, "/");
+}
+function getImports({ type = "models", tag: currentTag, entities, getTag, getEntityName, options }) {
+	const imports = /* @__PURE__ */ new Map();
+	entities.forEach((entity) => {
+		const tag = type === "models" && (options.modelsInCommon || options.modelsInModules) && 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,
+				bindings: importItem.typeOnly ? [] : [...importItem.bindings],
+				typeBindings: [...importItem.typeBindings ?? [], ...importItem.typeOnly ? importItem.bindings : []]
+			});
+			else {
+				const existing = merged.get(importItem.from);
+				if (!options.tsNamespaces && !importItem.typeOnly) existing.bindings.push(...importItem.bindings);
+				existing.typeBindings = [
+					...existing.typeBindings ?? [],
+					...importItem.typeBindings ?? [],
+					...importItem.typeOnly ? importItem.bindings : []
+				];
+				existing.typeOnly = false;
+			}
+		});
+	});
+	return Array.from(merged.values()).map((importItem) => ({
+		...importItem,
+		bindings: getUniqueArray(importItem.bindings),
+		typeBindings: getUniqueArray(importItem.typeBindings ?? []).filter((binding) => !importItem.bindings.includes(binding)),
+		typeOnly: Boolean(importItem.typeOnly && importItem.bindings.length === 0 && (importItem.typeBindings?.length ?? 0) > 0)
+	}));
+}
+//#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 === "@povio/openapi-codegen-cli" ? QUERY_PACKAGE_IMPORT_PATH : options.queryTypesImportPath;
+}
+//#endregion
+Object.defineProperty(exports, "ALLOWED_METHODS", {
+	enumerable: true,
+	get: function() {
+		return ALLOWED_METHODS;
+	}
+});
+Object.defineProperty(exports, "ALLOWED_PATH_IN", {
+	enumerable: true,
+	get: function() {
+		return ALLOWED_PATH_IN;
+	}
+});
+Object.defineProperty(exports, "ANY_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return ANY_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "APP_REST_CLIENT_FILE", {
+	enumerable: true,
+	get: function() {
+		return APP_REST_CLIENT_FILE;
+	}
+});
+Object.defineProperty(exports, "APP_REST_CLIENT_NAME", {
+	enumerable: true,
+	get: function() {
+		return APP_REST_CLIENT_NAME;
+	}
+});
+Object.defineProperty(exports, "AXIOS_DEFAULT_IMPORT_NAME", {
+	enumerable: true,
+	get: function() {
+		return AXIOS_DEFAULT_IMPORT_NAME;
+	}
+});
+Object.defineProperty(exports, "AXIOS_IMPORT", {
+	enumerable: true,
+	get: function() {
+		return AXIOS_IMPORT;
+	}
+});
+Object.defineProperty(exports, "AXIOS_PACKAGE_IMPORT_PATH", {
+	enumerable: true,
+	get: function() {
+		return AXIOS_PACKAGE_IMPORT_PATH;
+	}
+});
+Object.defineProperty(exports, "AXIOS_REQUEST_CONFIG_NAME", {
+	enumerable: true,
+	get: function() {
+		return AXIOS_REQUEST_CONFIG_NAME;
+	}
+});
+Object.defineProperty(exports, "AXIOS_REQUEST_CONFIG_TYPE", {
+	enumerable: true,
+	get: function() {
+		return AXIOS_REQUEST_CONFIG_TYPE;
+	}
+});
+Object.defineProperty(exports, "BLOB_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return BLOB_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "BODY_PARAMETER_NAME", {
+	enumerable: true,
+	get: function() {
+		return BODY_PARAMETER_NAME;
+	}
+});
+Object.defineProperty(exports, "BUILDERS_UTILS", {
+	enumerable: true,
+	get: function() {
+		return BUILDERS_UTILS;
+	}
+});
+Object.defineProperty(exports, "CONFIG_PACKAGE_IMPORT_PATH", {
+	enumerable: true,
+	get: function() {
+		return CONFIG_PACKAGE_IMPORT_PATH;
+	}
+});
+Object.defineProperty(exports, "DATETIME_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return DATETIME_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_GENERATE_OPTIONS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_GENERATE_OPTIONS;
+	}
+});
+Object.defineProperty(exports, "DOMAIN_ERRORS_FILE", {
+	enumerable: true,
+	get: function() {
+		return DOMAIN_ERRORS_FILE;
+	}
+});
+Object.defineProperty(exports, "EMAIL_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return EMAIL_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "ENUM_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return ENUM_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "INT_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return INT_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "JSON_APPLICATION_FORMAT", {
+	enumerable: true,
+	get: function() {
+		return JSON_APPLICATION_FORMAT;
+	}
+});
+Object.defineProperty(exports, "MUTATION_EFFECTS", {
+	enumerable: true,
+	get: function() {
+		return MUTATION_EFFECTS;
+	}
+});
+Object.defineProperty(exports, "NATIVE_PACKAGE_IMPORT_PATH", {
+	enumerable: true,
+	get: function() {
+		return NATIVE_PACKAGE_IMPORT_PATH;
+	}
+});
+Object.defineProperty(exports, "NATIVE_RESPONSE_TYPE", {
+	enumerable: true,
+	get: function() {
+		return NATIVE_RESPONSE_TYPE;
+	}
+});
+Object.defineProperty(exports, "NUMBER_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return NUMBER_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "Profiler", {
+	enumerable: true,
+	get: function() {
+		return Profiler;
+	}
+});
+Object.defineProperty(exports, "QUERY_MODULES_FILE", {
+	enumerable: true,
+	get: function() {
+		return QUERY_MODULES_FILE;
+	}
+});
+Object.defineProperty(exports, "QUERY_MODULE_ENUM", {
+	enumerable: true,
+	get: function() {
+		return QUERY_MODULE_ENUM;
+	}
+});
+Object.defineProperty(exports, "QUERY_OPTIONS_TYPES", {
+	enumerable: true,
+	get: function() {
+		return QUERY_OPTIONS_TYPES;
+	}
+});
+Object.defineProperty(exports, "REST_PACKAGE_IMPORT_PATH", {
+	enumerable: true,
+	get: function() {
+		return REST_PACKAGE_IMPORT_PATH;
+	}
+});
+Object.defineProperty(exports, "STRING_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return STRING_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "URL_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return URL_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "UUID_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return UUID_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "VOID_SCHEMA", {
+	enumerable: true,
+	get: function() {
+		return VOID_SCHEMA;
+	}
+});
+Object.defineProperty(exports, "ZOD_EXTENDED", {
+	enumerable: true,
+	get: function() {
+		return ZOD_EXTENDED;
+	}
+});
+Object.defineProperty(exports, "ZOD_IMPORT", {
+	enumerable: true,
+	get: function() {
+		return ZOD_IMPORT;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "autocorrectRef", {
+	enumerable: true,
+	get: function() {
+		return autocorrectRef;
+	}
+});
+Object.defineProperty(exports, "camelToSpaceSeparated", {
+	enumerable: true,
+	get: function() {
+		return camelToSpaceSeparated;
+	}
+});
+Object.defineProperty(exports, "capitalize", {
+	enumerable: true,
+	get: function() {
+		return capitalize;
+	}
+});
+Object.defineProperty(exports, "compileNativeData", {
+	enumerable: true,
+	get: function() {
+		return compileNativeData;
+	}
+});
+Object.defineProperty(exports, "decapitalize", {
+	enumerable: true,
+	get: function() {
+		return decapitalize;
+	}
+});
+Object.defineProperty(exports, "deepMerge", {
+	enumerable: true,
+	get: function() {
+		return deepMerge;
+	}
+});
+Object.defineProperty(exports, "escapeControlCharacters", {
+	enumerable: true,
+	get: function() {
+		return escapeControlCharacters;
+	}
+});
+Object.defineProperty(exports, "formatTag", {
+	enumerable: true,
+	get: function() {
+		return formatTag;
+	}
+});
+Object.defineProperty(exports, "getAbilityAction", {
+	enumerable: true,
+	get: function() {
+		return getAbilityAction;
+	}
+});
+Object.defineProperty(exports, "getAbilityConditionType", {
+	enumerable: true,
+	get: function() {
+		return getAbilityConditionType;
+	}
+});
+Object.defineProperty(exports, "getAbilityConditionsTypes", {
+	enumerable: true,
+	get: function() {
+		return getAbilityConditionsTypes;
+	}
+});
+Object.defineProperty(exports, "getAbilityDescription", {
+	enumerable: true,
+	get: function() {
+		return getAbilityDescription;
+	}
+});
+Object.defineProperty(exports, "getAbilityFunctionName", {
+	enumerable: true,
+	get: function() {
+		return getAbilityFunctionName;
+	}
+});
+Object.defineProperty(exports, "getAbilitySubject", {
+	enumerable: true,
+	get: function() {
+		return getAbilitySubject;
+	}
+});
+Object.defineProperty(exports, "getAbilitySubjectTypes", {
+	enumerable: true,
+	get: function() {
+		return getAbilitySubjectTypes;
+	}
+});
+Object.defineProperty(exports, "getAclData", {
+	enumerable: true,
+	get: function() {
+		return getAclData;
+	}
+});
+Object.defineProperty(exports, "getAclImports", {
+	enumerable: true,
+	get: function() {
+		return getAclImports;
+	}
+});
+Object.defineProperty(exports, "getAppAbilitiesType", {
+	enumerable: true,
+	get: function() {
+		return getAppAbilitiesType;
+	}
+});
+Object.defineProperty(exports, "getAppRestClientImportPath", {
+	enumerable: true,
+	get: function() {
+		return getAppRestClientImportPath;
+	}
+});
+Object.defineProperty(exports, "getBodyZodSchemaName", {
+	enumerable: true,
+	get: function() {
+		return getBodyZodSchemaName;
+	}
+});
+Object.defineProperty(exports, "getDestructuredVariables", {
+	enumerable: true,
+	get: function() {
+		return getDestructuredVariables;
+	}
+});
+Object.defineProperty(exports, "getEndpointBody", {
+	enumerable: true,
+	get: function() {
+		return getEndpointBody;
+	}
+});
+Object.defineProperty(exports, "getEndpointConfig", {
+	enumerable: true,
+	get: function() {
+		return getEndpointConfig;
+	}
+});
+Object.defineProperty(exports, "getEndpointName", {
+	enumerable: true,
+	get: function() {
+		return getEndpointName;
+	}
+});
+Object.defineProperty(exports, "getEndpointPath", {
+	enumerable: true,
+	get: function() {
+		return getEndpointPath;
+	}
+});
+Object.defineProperty(exports, "getEndpointTag", {
+	enumerable: true,
+	get: function() {
+		return getEndpointTag;
+	}
+});
+Object.defineProperty(exports, "getEndpointsImports", {
+	enumerable: true,
+	get: function() {
+		return getEndpointsImports;
+	}
+});
+Object.defineProperty(exports, "getEnumZodSchemaName", {
+	enumerable: true,
+	get: function() {
+		return getEnumZodSchemaName;
+	}
+});
+Object.defineProperty(exports, "getFileNameWithExtension", {
+	enumerable: true,
+	get: function() {
+		return getFileNameWithExtension;
+	}
+});
+Object.defineProperty(exports, "getImportPath", {
+	enumerable: true,
+	get: function() {
+		return getImportPath;
+	}
+});
+Object.defineProperty(exports, "getImportedAbilityFunctionName", {
+	enumerable: true,
+	get: function() {
+		return getImportedAbilityFunctionName;
+	}
+});
+Object.defineProperty(exports, "getImportedEndpointName", {
+	enumerable: true,
+	get: function() {
+		return getImportedEndpointName;
+	}
+});
+Object.defineProperty(exports, "getImportedInfiniteQueryName", {
+	enumerable: true,
+	get: function() {
+		return getImportedInfiniteQueryName;
+	}
+});
+Object.defineProperty(exports, "getImportedQueryName", {
+	enumerable: true,
+	get: function() {
+		return getImportedQueryName;
+	}
+});
+Object.defineProperty(exports, "getImportedZodSchemaInferedTypeName", {
+	enumerable: true,
+	get: function() {
+		return getImportedZodSchemaInferedTypeName;
+	}
+});
+Object.defineProperty(exports, "getImportedZodSchemaName", {
+	enumerable: true,
+	get: function() {
+		return getImportedZodSchemaName;
+	}
+});
+Object.defineProperty(exports, "getInfiniteQueriesImports", {
+	enumerable: true,
+	get: function() {
+		return getInfiniteQueriesImports;
+	}
+});
+Object.defineProperty(exports, "getInfiniteQueryName", {
+	enumerable: true,
+	get: function() {
+		return getInfiniteQueryName;
+	}
+});
+Object.defineProperty(exports, "getInfiniteQueryOptionsName", {
+	enumerable: true,
+	get: function() {
+		return getInfiniteQueryOptionsName;
+	}
+});
+Object.defineProperty(exports, "getModelsImports", {
+	enumerable: true,
+	get: function() {
+		return getModelsImports;
+	}
+});
+Object.defineProperty(exports, "getMostCommonAdjacentCombinationSplit", {
+	enumerable: true,
+	get: function() {
+		return getMostCommonAdjacentCombinationSplit;
+	}
+});
+Object.defineProperty(exports, "getNamespaceName", {
+	enumerable: true,
+	get: function() {
+		return getNamespaceName;
+	}
+});
+Object.defineProperty(exports, "getOperationTag", {
+	enumerable: true,
+	get: function() {
+		return getOperationTag;
+	}
+});
+Object.defineProperty(exports, "getOutputFileName", {
+	enumerable: true,
+	get: function() {
+		return getOutputFileName;
+	}
+});
+Object.defineProperty(exports, "getParamZodSchemaName", {
+	enumerable: true,
+	get: function() {
+		return getParamZodSchemaName;
+	}
+});
+Object.defineProperty(exports, "getParameterEnumNames", {
+	enumerable: true,
+	get: function() {
+		return getParameterEnumNames;
+	}
+});
+Object.defineProperty(exports, "getPathSegments", {
+	enumerable: true,
+	get: function() {
+		return getPathSegments;
+	}
+});
+Object.defineProperty(exports, "getPrefetchInfiniteQueryName", {
+	enumerable: true,
+	get: function() {
+		return getPrefetchInfiniteQueryName;
+	}
+});
+Object.defineProperty(exports, "getPrefetchQueryName", {
+	enumerable: true,
+	get: function() {
+		return getPrefetchQueryName;
+	}
+});
+Object.defineProperty(exports, "getQueriesImports", {
+	enumerable: true,
+	get: function() {
+		return getQueriesImports;
+	}
+});
+Object.defineProperty(exports, "getQueryModulesImportPath", {
+	enumerable: true,
+	get: function() {
+		return getQueryModulesImportPath;
+	}
+});
+Object.defineProperty(exports, "getQueryName", {
+	enumerable: true,
+	get: function() {
+		return getQueryName;
+	}
+});
+Object.defineProperty(exports, "getQueryOptionsName", {
+	enumerable: true,
+	get: function() {
+		return getQueryOptionsName;
+	}
+});
+Object.defineProperty(exports, "getQueryTypesImportPath", {
+	enumerable: true,
+	get: function() {
+		return getQueryTypesImportPath;
+	}
+});
+Object.defineProperty(exports, "getRequestConfigTypeName", {
+	enumerable: true,
+	get: function() {
+		return getRequestConfigTypeName;
+	}
+});
+Object.defineProperty(exports, "getResponseZodSchemaName", {
+	enumerable: true,
+	get: function() {
+		return getResponseZodSchemaName;
+	}
+});
+Object.defineProperty(exports, "getSchemaDescriptions", {
+	enumerable: true,
+	get: function() {
+		return getSchemaDescriptions;
+	}
+});
+Object.defineProperty(exports, "getSchemaNameByRef", {
+	enumerable: true,
+	get: function() {
+		return getSchemaNameByRef;
+	}
+});
+Object.defineProperty(exports, "getSchemaRef", {
+	enumerable: true,
+	get: function() {
+		return getSchemaRef;
+	}
+});
+Object.defineProperty(exports, "getTagFileName", {
+	enumerable: true,
+	get: function() {
+		return getTagFileName;
+	}
+});
+Object.defineProperty(exports, "getTagImportPath", {
+	enumerable: true,
+	get: function() {
+		return getTagImportPath;
+	}
+});
+Object.defineProperty(exports, "getUniqueArray", {
+	enumerable: true,
+	get: function() {
+		return getUniqueArray;
+	}
+});
+Object.defineProperty(exports, "getZodSchemaDescription", {
+	enumerable: true,
+	get: function() {
+		return getZodSchemaDescription;
+	}
+});
+Object.defineProperty(exports, "getZodSchemaInferedTypeName", {
+	enumerable: true,
+	get: function() {
+		return getZodSchemaInferedTypeName;
+	}
+});
+Object.defineProperty(exports, "getZodSchemaName", {
+	enumerable: true,
+	get: function() {
+		return getZodSchemaName;
+	}
+});
+Object.defineProperty(exports, "getZodSchemaOperationName", {
+	enumerable: true,
+	get: function() {
+		return getZodSchemaOperationName;
+	}
+});
+Object.defineProperty(exports, "getZodSchemaPropertyDescriptions", {
+	enumerable: true,
+	get: function() {
+		return getZodSchemaPropertyDescriptions;
+	}
+});
+Object.defineProperty(exports, "getZodSchemaType", {
+	enumerable: true,
+	get: function() {
+		return getZodSchemaType;
+	}
+});
+Object.defineProperty(exports, "hasAbilityConditions", {
+	enumerable: true,
+	get: function() {
+		return hasAbilityConditions;
+	}
+});
+Object.defineProperty(exports, "hasEndpointConfig", {
+	enumerable: true,
+	get: function() {
+		return hasEndpointConfig;
+	}
+});
+Object.defineProperty(exports, "inferRequiredSchema", {
+	enumerable: true,
+	get: function() {
+		return inferRequiredSchema;
+	}
+});
+Object.defineProperty(exports, "invalidVariableNameCharactersToCamel", {
+	enumerable: true,
+	get: function() {
+		return invalidVariableNameCharactersToCamel;
+	}
+});
+Object.defineProperty(exports, "isArraySchemaObject", {
+	enumerable: true,
+	get: function() {
+		return isArraySchemaObject;
+	}
+});
+Object.defineProperty(exports, "isBulkDeleteEndpoint", {
+	enumerable: true,
+	get: function() {
+		return isBulkDeleteEndpoint;
+	}
+});
+Object.defineProperty(exports, "isCreateEndpoint", {
+	enumerable: true,
+	get: function() {
+		return isCreateEndpoint;
+	}
+});
+Object.defineProperty(exports, "isDeleteEndpoint", {
+	enumerable: true,
+	get: function() {
+		return isDeleteEndpoint;
+	}
+});
+Object.defineProperty(exports, "isEnumZodSchema", {
+	enumerable: true,
+	get: function() {
+		return isEnumZodSchema;
+	}
+});
+Object.defineProperty(exports, "isErrorStatus", {
+	enumerable: true,
+	get: function() {
+		return isErrorStatus;
+	}
+});
+Object.defineProperty(exports, "isInfiniteQuery", {
+	enumerable: true,
+	get: function() {
+		return isInfiniteQuery;
+	}
+});
+Object.defineProperty(exports, "isMainResponseStatus", {
+	enumerable: true,
+	get: function() {
+		return isMainResponseStatus;
+	}
+});
+Object.defineProperty(exports, "isMediaTypeAllowed", {
+	enumerable: true,
+	get: function() {
+		return isMediaTypeAllowed;
+	}
+});
+Object.defineProperty(exports, "isMutation", {
+	enumerable: true,
+	get: function() {
+		return isMutation;
+	}
+});
+Object.defineProperty(exports, "isNamedZodSchema", {
+	enumerable: true,
+	get: function() {
+		return isNamedZodSchema;
+	}
+});
+Object.defineProperty(exports, "isParamMediaTypeAllowed", {
+	enumerable: true,
+	get: function() {
+		return isParamMediaTypeAllowed;
+	}
+});
+Object.defineProperty(exports, "isPathExcluded", {
+	enumerable: true,
+	get: function() {
+		return isPathExcluded;
+	}
+});
+Object.defineProperty(exports, "isPathSegmentParam", {
+	enumerable: true,
+	get: function() {
+		return isPathSegmentParam;
+	}
+});
+Object.defineProperty(exports, "isPrimitiveType", {
+	enumerable: true,
+	get: function() {
+		return isPrimitiveType;
+	}
+});
+Object.defineProperty(exports, "isQuery", {
+	enumerable: true,
+	get: function() {
+		return isQuery;
+	}
+});
+Object.defineProperty(exports, "isReadAllEndpoint", {
+	enumerable: true,
+	get: function() {
+		return isReadAllEndpoint;
+	}
+});
+Object.defineProperty(exports, "isReadEndpoint", {
+	enumerable: true,
+	get: function() {
+		return isReadEndpoint;
+	}
+});
+Object.defineProperty(exports, "isReferenceObject", {
+	enumerable: true,
+	get: function() {
+		return isReferenceObject;
+	}
+});
+Object.defineProperty(exports, "isSchemaObject", {
+	enumerable: true,
+	get: function() {
+		return isSchemaObject;
+	}
+});
+Object.defineProperty(exports, "isSortingParameterObject", {
+	enumerable: true,
+	get: function() {
+		return isSortingParameterObject;
+	}
+});
+Object.defineProperty(exports, "isTagIncluded", {
+	enumerable: true,
+	get: function() {
+		return isTagIncluded;
+	}
+});
+Object.defineProperty(exports, "isUpdateEndpoint", {
+	enumerable: true,
+	get: function() {
+		return isUpdateEndpoint;
+	}
+});
+Object.defineProperty(exports, "iterateSchema", {
+	enumerable: true,
+	get: function() {
+		return iterateSchema;
+	}
+});
+Object.defineProperty(exports, "kebabToCamel", {
+	enumerable: true,
+	get: function() {
+		return kebabToCamel;
+	}
+});
+Object.defineProperty(exports, "mapEndpointParamsToFunctionParams", {
+	enumerable: true,
+	get: function() {
+		return mapEndpointParamsToFunctionParams;
+	}
+});
+Object.defineProperty(exports, "mergeImports", {
+	enumerable: true,
+	get: function() {
+		return mergeImports;
+	}
+});
+Object.defineProperty(exports, "pathParamToVariableName", {
+	enumerable: true,
+	get: function() {
+		return pathParamToVariableName;
+	}
+});
+Object.defineProperty(exports, "pathToVariableName", {
+	enumerable: true,
+	get: function() {
+		return pathToVariableName;
+	}
+});
+Object.defineProperty(exports, "pick", {
+	enumerable: true,
+	get: function() {
+		return pick;
+	}
+});
+Object.defineProperty(exports, "removeStaleGeneratedFiles", {
+	enumerable: true,
+	get: function() {
+		return removeStaleGeneratedFiles;
+	}
+});
+Object.defineProperty(exports, "removeWord", {
+	enumerable: true,
+	get: function() {
+		return removeWord;
+	}
+});
+Object.defineProperty(exports, "renderAclCheckCall", {
+	enumerable: true,
+	get: function() {
+		return renderAclCheckCall;
+	}
+});
+Object.defineProperty(exports, "renderMediaUploadMutationBody", {
+	enumerable: true,
+	get: function() {
+		return renderMediaUploadMutationBody;
+	}
+});
+Object.defineProperty(exports, "replaceHyphenatedPath", {
+	enumerable: true,
+	get: function() {
+		return replaceHyphenatedPath;
+	}
+});
+Object.defineProperty(exports, "requiresBody", {
+	enumerable: true,
+	get: function() {
+		return requiresBody;
+	}
+});
+Object.defineProperty(exports, "shouldInlineEndpointsForTag", {
+	enumerable: true,
+	get: function() {
+		return shouldInlineEndpointsForTag;
+	}
+});
+Object.defineProperty(exports, "shouldUseNativeCodegen", {
+	enumerable: true,
+	get: function() {
+		return shouldUseNativeCodegen;
+	}
+});
+Object.defineProperty(exports, "snakeToCamel", {
+	enumerable: true,
+	get: function() {
+		return snakeToCamel;
+	}
+});
+Object.defineProperty(exports, "unwrapQuotesIfNeeded", {
+	enumerable: true,
+	get: function() {
+		return unwrapQuotesIfNeeded;
+	}
+});
+Object.defineProperty(exports, "wrapWithQuotesIfNeeded", {
+	enumerable: true,
+	get: function() {
+		return wrapWithQuotesIfNeeded;
+	}
+});
+Object.defineProperty(exports, "writeGenerateFileData", {
+	enumerable: true,
+	get: function() {
+		return writeGenerateFileData;
+	}
+});