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

package/dist/generate.utils-CT-LA-gX.cjs

@@ -1,2267 +0,0 @@
-//#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 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,
-	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 = (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(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(zodSchemaName, options.schemaSuffix);
-const getImportedZodSchemaName = (resolver, zodSchemaName, namespaceTag) => {
-	if (!isNamedZodSchema(zodSchemaName)) return zodSchemaName;
-	const tag = getOwningOrLocalProxyTag(resolver, zodSchemaName, 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, 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 (uploadInstructions.fields) {",
-		"      for (const [key, value] of uploadInstructions.fields) {",
-		"        dataToSend.append(key, 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);
-	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
-	}).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;
-}
-//#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_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, "PACKAGE_IMPORT_PATH", {
-	enumerable: true,
-	get: function() {
-		return PACKAGE_IMPORT_PATH;
-	}
-});
-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;
-	}
-});