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

package/dist/generate.runner-BGhsnDm8.mjs

@@ -0,0 +1,1674 @@
+import { createRequire } from "node:module";
+import fs from "fs";
+import { OpenAPIV3 } from "openapi-types";
+import path from "path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path$1 from "node:path";
+//#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/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/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/const/endpoints.const.ts
+const JSON_APPLICATION_FORMAT = "application/json";
+const DEFAULT_HEADERS = {
+	"Content-Type": JSON_APPLICATION_FORMAT,
+	Accept: JSON_APPLICATION_FORMAT
+};
+const BODY_PARAMETER_NAME = "data";
+const AXIOS_DEFAULT_IMPORT_NAME = "axios";
+const AXIOS_REQUEST_CONFIG_NAME = "config";
+const AXIOS_REQUEST_CONFIG_TYPE = "AxiosRequestConfig";
+const AXIOS_IMPORT = {
+	defaultImport: AXIOS_DEFAULT_IMPORT_NAME,
+	bindings: [],
+	typeBindings: [AXIOS_REQUEST_CONFIG_TYPE],
+	from: "axios"
+};
+//#endregion
+//#region src/generators/const/zod.const.ts
+const SCHEMA_SUFFIX = "Schema";
+const ENUM_SUFFIX = "Enum";
+const BODY_SCHEMA_SUFFIX = "Body";
+const PARAM_SCHEMA_SUFFIX = "Param";
+const RESPONSE_SCHEMA_SUFFIX = "Response";
+const ERROR_RESPONSE_SCHEMA_SUFFIX = "ErrorResponse";
+const VOID_SCHEMA = "z.void()";
+const ANY_SCHEMA = "z.any()";
+const BLOB_SCHEMA = "z.instanceof(Blob)";
+const ENUM_SCHEMA = "z.enum";
+const INT_SCHEMA = "z.int()";
+const NUMBER_SCHEMA = "z.number()";
+const STRING_SCHEMA = "z.string()";
+const EMAIL_SCHEMA = "z.email()";
+const URL_SCHEMA = "z.url()";
+const UUID_SCHEMA = "z.uuid()";
+const DATETIME_SCHEMA = "z.iso.datetime({ offset: true })";
+const ZOD_IMPORT = {
+	bindings: ["z"],
+	from: "zod"
+};
+//#endregion
+//#region src/generators/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 = [
+	OpenAPIV3.HttpMethods.GET,
+	OpenAPIV3.HttpMethods.PUT,
+	OpenAPIV3.HttpMethods.POST,
+	OpenAPIV3.HttpMethods.DELETE,
+	OpenAPIV3.HttpMethods.OPTIONS,
+	OpenAPIV3.HttpMethods.HEAD,
+	OpenAPIV3.HttpMethods.PATCH,
+	OpenAPIV3.HttpMethods.TRACE
+];
+const PRIMITIVE_TYPE_LIST = [
+	"string",
+	"number",
+	"integer",
+	"boolean"
+];
+const COMPOSITE_KEYWORDS = [
+	"allOf",
+	"anyOf",
+	"oneOf"
+];
+//#endregion
+//#region src/generators/utils/openapi-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/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/namespace.utils.ts
+const getNamespaceName = ({ type, tag, options }) => `${capitalize(tag)}${options.configs[type].namespaceSuffix}`;
+//#endregion
+//#region src/generators/const/package.const.ts
+const PACKAGE_IMPORT_PATH = "@povio/openapi-codegen-cli";
+//#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/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/js.utils.ts
+const isValidPropertyName = (str) => /^(?:[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+)$/.test(str);
+const invalidVariableNameCharactersToCamel = (str) => str.replace(/^[^a-zA-Z_$]*/g, "").replace(/[^a-zA-Z0-9_$]+(\w)?/g, (_, char) => char?.toUpperCase() ?? "");
+//#endregion
+//#region src/generators/utils/endpoint.utils.ts
+const isGetEndpoint = (endpoint) => endpoint.method === OpenAPIV3.HttpMethods.GET;
+const isPaginatedGetEndpoint = (endpoint, options) => isGetEndpoint(endpoint) && Object.values(options.infiniteQueryParamNames).every((infiniteQueryParam) => endpoint.parameters.some((param) => param.name === infiniteQueryParam && param.type === "Query"));
+const isReadAllEndpoint = (endpoint, options) => endpoint.method === OpenAPIV3.HttpMethods.GET && !isPathSegmentParam(endpoint.pathSegments.at(-1)) && isPaginatedGetEndpoint(endpoint, options);
+const isReadEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.GET && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isCreateEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.POST && hasMatchingPathWithoutTrailingParam(endpoint, readAllEndpoint);
+const isUpdateEndpoint = (endpoint, readAllEndpoint) => [OpenAPIV3.HttpMethods.PUT, OpenAPIV3.HttpMethods.PATCH].includes(endpoint.method) && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isDeleteEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.DELETE && hasMatchingPathWithTrailingParam(endpoint, readAllEndpoint);
+const isBulkDeleteEndpoint = (endpoint, readAllEndpoint) => endpoint.method === OpenAPIV3.HttpMethods.DELETE && hasMatchingPathWithoutTrailingParam(endpoint, readAllEndpoint);
+const getPathSegments = (path) => path.split("/").filter(Boolean);
+const isPathSegmentParam = (pathSegment) => pathSegment?.startsWith(":");
+const hasMatchingPath = (endpoint, readAllEndpoint) => readAllEndpoint.pathSegments.every((segment, index) => isPathSegmentParam(segment) && isPathSegmentParam(endpoint.pathSegments[index]) || segment === endpoint.pathSegments[index]);
+const hasMatchingPathWithoutTrailingParam = (endpoint, readAllEndpoint) => endpoint.pathSegments.length === readAllEndpoint.pathSegments.length && hasMatchingPath(endpoint, readAllEndpoint);
+const hasMatchingPathWithTrailingParam = (endpoint, readAllEndpoint) => endpoint.pathSegments.length - 1 === readAllEndpoint.pathSegments.length && isPathSegmentParam(endpoint.pathSegments.at(-1)) && hasMatchingPath(endpoint, readAllEndpoint);
+//#endregion
+//#region src/generators/const/acl.const.ts
+const ACL_APP_ABILITY_FILE = {
+	fileName: "acl/app.ability",
+	extension: "ts"
+};
+const ACL_APP_ABILITIES = "AppAbilities";
+const ACL_CHECK_HOOK = "useAclCheck";
+const CASL_ABILITY_BINDING = {
+	abilityTuple: "AbilityTuple",
+	pureAbility: "PureAbility",
+	forcedSubject: "ForcedSubject",
+	subjectType: "Subject",
+	subject: "subject"
+};
+const CASL_ABILITY_IMPORT = {
+	bindings: [
+		CASL_ABILITY_BINDING.abilityTuple,
+		CASL_ABILITY_BINDING.pureAbility,
+		CASL_ABILITY_BINDING.forcedSubject,
+		CASL_ABILITY_BINDING.subjectType,
+		CASL_ABILITY_BINDING.subject
+	],
+	from: "@casl/ability"
+};
+//#endregion
+//#region src/generators/const/options.const.ts
+const DEFAULT_GENERATE_OPTIONS = {
+	input: "http://localhost:4000/docs-json/",
+	output: "output",
+	clearOutput: false,
+	incremental: true,
+	splitByTags: true,
+	defaultTag: "Common",
+	includeTags: [],
+	excludeTags: [],
+	excludePathRegex: "",
+	excludeRedundantZodSchemas: true,
+	tsNamespaces: true,
+	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,
+	withDefaultValues: true,
+	extractEnums: true,
+	replaceOptionalWithNullish: false,
+	restClientImportPath: "",
+	zodImportPath: "@povio/openapi-codegen-cli/zod",
+	errorHandlingImportPath: "",
+	removeOperationPrefixEndingWith: "Controller_",
+	parseRequestParams: true,
+	inlineEndpoints: false,
+	inlineEndpointsExcludeModules: [],
+	queryTypesImportPath: PACKAGE_IMPORT_PATH,
+	mutationEffectsImportPath: 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/array.utils.ts
+const getUniqueArray = (...arrs) => [...new Set(arrs.flat())];
+//#endregion
+//#region src/generators/core/openapi/iterateSchema.ts
+function iterateSchema(schema, options) {
+	if (!schema) return;
+	const { data, onSchema } = options;
+	if (isReferenceObject(schema) && onSchema({
+		type: "reference",
+		schema,
+		data
+	}) === true) return;
+	const schemaObj = schema;
+	if (COMPOSITE_KEYWORDS.some((prop) => prop in schemaObj && schemaObj[prop])) {
+		const schemaObjs = schemaObj.allOf ?? schemaObj.anyOf ?? schemaObj.oneOf ?? [];
+		for (const compositeObj of schemaObjs) {
+			if (onSchema?.({
+				type: "composite",
+				parentSchema: schema,
+				schema: compositeObj,
+				data
+			}) === true) continue;
+			iterateSchema(compositeObj, {
+				data,
+				onSchema
+			});
+		}
+	}
+	if (schemaObj.properties) for (const [propertyName, propertyObj] of Object.entries(schemaObj.properties)) {
+		if (onSchema({
+			type: "property",
+			parentSchema: schema,
+			schema: propertyObj,
+			data,
+			propertyName
+		}) === true) continue;
+		iterateSchema(propertyObj, options);
+	}
+	if (schemaObj.additionalProperties && typeof schemaObj.additionalProperties === "object") {
+		if (onSchema({
+			type: "additionalProperties",
+			parentSchema: schema,
+			schema: schemaObj.additionalProperties,
+			data
+		}) === true) return;
+		iterateSchema(schemaObj.additionalProperties, options);
+	}
+	if (schemaObj.type === "array") {
+		const arrayObj = schema.items;
+		if (onSchema({
+			type: "array",
+			parentSchema: schema,
+			schema: arrayObj,
+			data
+		}) === true) return;
+		iterateSchema(arrayObj, options);
+	}
+}
+//#endregion
+//#region src/generators/utils/generate/generate.openapi.utils.ts
+const schemaDescriptionsCache = /* @__PURE__ */ new WeakMap();
+function getSchemaDescriptions(schemaObj) {
+	const cachedSchemaDescriptions = schemaDescriptionsCache.get(schemaObj);
+	if (cachedSchemaDescriptions) return cachedSchemaDescriptions;
+	const schemaDescriptions = [
+		"minimum",
+		"exclusiveMinimum",
+		"maximum",
+		"exclusiveMaximum",
+		"minItems",
+		"minLength",
+		"minProperties",
+		"maxItems",
+		"maxLength",
+		"maxProperties",
+		"default",
+		"example"
+	].filter((key) => schemaObj[key] !== void 0).reduce((acc, key) => [...acc, `${capitalize(camelToSpaceSeparated(key))}: \`${schemaObj[key]}\``], []);
+	schemaDescriptionsCache.set(schemaObj, schemaDescriptions);
+	return schemaDescriptions;
+}
+//#endregion
+//#region src/generators/utils/generate/generate.zod.utils.ts
+const getZodSchemaInferedTypeName = (zodSchemaName, options) => removeSuffix(zodSchemaName, options.schemaSuffix);
+const getImportedZodSchemaName = (resolver, zodSchemaName, 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.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/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.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
+//#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";
+	}
+}
+function getTsTypeBase({ zodSchemaName, schema, resolver }) {
+	let type = "void";
+	let tag;
+	if (zodSchemaName && isNamedZodSchema(zodSchemaName)) {
+		type = getImportedZodSchemaInferedTypeName(resolver, zodSchemaName);
+		tag = resolver.getTagByZodSchemaName(zodSchemaName);
+	} else if (schema?.type && isPrimitiveType(schema?.type)) type = primitiveTypeToTsType(schema?.type);
+	const splitType = type.split(".");
+	return {
+		type: splitType[splitType.length - 1],
+		...splitType.length > 1 ? { namespace: splitType[0] } : {},
+		...tag ? { importPath: getTagImportPath({
+			type: "models",
+			tag,
+			includeTagDir: true,
+			options: resolver.options
+		}) } : {}
+	};
+}
+function getSchemaTsMetaType({ schema, isCircular, parentTypes, resolver }) {
+	if (!schema) return { metaType: "primitive" };
+	for (const compositeKeyword of COMPOSITE_KEYWORDS) {
+		const compositeObjs = schema[compositeKeyword];
+		if (!compositeObjs) continue;
+		if (compositeObjs.length > 1) {
+			const metaTypes = compositeObjs.map((compositeObj) => {
+				return getSchemaTsMetaType({
+					schema: resolver.resolveObject(compositeObj),
+					parentTypes,
+					resolver
+				});
+			});
+			if (metaTypes.every(({ metaType }) => metaType === "object")) return {
+				metaType: "object",
+				objectProperties: metaTypes.reduce((acc, { objectProperties }) => {
+					const objectPropertyNames = new Set(objectProperties.map(({ name }) => name));
+					return [...acc.filter(({ name }) => !objectPropertyNames.has(name)), ...objectProperties];
+				}, [])
+			};
+			else return {
+				metaType: "composite",
+				[compositeKeyword]: metaTypes
+			};
+		} else schema = resolver.resolveObject(compositeObjs[0]);
+	}
+	if (schema.type === "array") return {
+		metaType: "array",
+		arrayType: getArraySchemaTsType({
+			arraySchema: schema,
+			resolver,
+			parentTypes
+		})
+	};
+	else if ((schema.type === "object" || schema.properties) && isCircular) return {
+		metaType: "object",
+		objectProperties: [],
+		isCircular: true
+	};
+	else if (schema.type === "object" || schema.properties) return {
+		metaType: "object",
+		objectProperties: getSchemaTsProperties({
+			schema,
+			parentTypes,
+			resolver
+		})
+	};
+	return { metaType: "primitive" };
+}
+function getArraySchemaTsType({ arraySchema, parentTypes, resolver }) {
+	let zodSchemaName;
+	let schema;
+	if (isReferenceObject(arraySchema.items)) {
+		const ref = arraySchema.items.$ref;
+		zodSchemaName = resolver.getZodSchemaNameByRef(ref);
+		schema = resolver.getSchemaByRef(ref);
+	} else schema = arraySchema.items;
+	const tsType = getTsTypeBase({
+		zodSchemaName,
+		schema,
+		resolver
+	});
+	const isCircular = getIsCircular(tsType, parentTypes);
+	const tsMetaType = getSchemaTsMetaType({
+		schema,
+		isCircular,
+		parentTypes: [...parentTypes, tsType],
+		resolver
+	});
+	return {
+		...tsType,
+		...tsMetaType
+	};
+}
+function getSchemaTsProperties({ schema, parentTypes, resolver }) {
+	return Object.entries(schema?.properties ?? {}).map(([name, property]) => {
+		const isRequired = schema?.required?.includes(name) ?? false;
+		if (isReferenceObject(property)) {
+			const zodSchemaName = resolver.getZodSchemaNameByRef(property.$ref);
+			const schema = resolver.getSchemaByRef(property.$ref);
+			const tsType = getTsTypeBase({
+				zodSchemaName,
+				schema,
+				resolver
+			});
+			const tsMetaType = getSchemaTsMetaType({
+				schema,
+				isCircular: getIsCircular(tsType, parentTypes),
+				parentTypes: [...parentTypes, tsType],
+				resolver
+			});
+			return {
+				name,
+				isRequired,
+				...tsType,
+				...tsMetaType
+			};
+		} else if (property.type === "array") return {
+			name,
+			isRequired,
+			type: "array",
+			metaType: "array",
+			arrayType: getArraySchemaTsType({
+				arraySchema: property,
+				parentTypes,
+				resolver
+			})
+		};
+		else if (isPrimitiveType(property.type)) return {
+			name,
+			isRequired,
+			type: primitiveTypeToTsType(property.type),
+			metaType: "primitive"
+		};
+		return {
+			name,
+			isRequired,
+			type: "void",
+			metaType: "primitive"
+		};
+	});
+}
+function getIsCircular(tsType, parentTypes) {
+	return parentTypes.findIndex(({ type, namespace }) => type === tsType.type && namespace === tsType.namespace) > -1;
+}
+//#endregion
+//#region src/generators/utils/generate/generate.endpoints.utils.ts
+const 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 !== 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);",
+		"  }",
+		"  await axios[method](uploadInstructions.url, dataToSend, {",
+		"    headers: {",
+		"      \"Content-Type\": file.type,",
+		"    },",
+		"    signal: abortController?.signal,",
+		"    onUploadProgress: onUploadProgress",
+		"    ? (progressEvent) => onUploadProgress({ loaded: progressEvent.loaded, total: progressEvent.total ?? 0 })",
+		"    : undefined,",
+		"  });",
+		"}",
+		"",
+		"return uploadInstructions;"
+	];
+}
+//#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/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.promises.writeFile(file, data, "utf-8");
+		return;
+	}
+	try {
+		if (await fs.promises.readFile(file, "utf-8") === data) return;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	await fs.promises.writeFile(file, data, "utf-8");
+}
+async function writeFile({ fileName, content }, options) {
+	const formattedContent = options?.formatGeneratedFile ? await options.formatGeneratedFile({
+		fileName,
+		content
+	}) : content;
+	await fs.promises.mkdir(path.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.dirname(fileName)));
+		for (const directory of directories) fs.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.existsSync(output)) return;
+	const expectedFiles = new Set(filesData.map((file) => path.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.readdirSync(dirPath, { withFileTypes: true })) {
+			const entryPath = path.join(dirPath, dirent.name);
+			if (dirent.isDirectory()) {
+				visit(entryPath);
+				continue;
+			}
+			if (isGeneratedFile(entryPath, output, generatedSuffixes) && !expectedFiles.has(path.resolve(entryPath))) staleFiles.push(entryPath);
+		}
+	};
+	visit(output);
+	staleFiles.forEach((filePath) => fs.rmSync(filePath, { force: true }));
+	removeEmptyDirectories(output);
+}
+function isGeneratedFile(filePath, output, generatedSuffixes) {
+	const relativePath = path.relative(output, filePath);
+	if (relativePath === ".openapi-codegen-cache.json") return true;
+	const normalizedRelativePath = relativePath.split(path.sep).join("/");
+	if ([
+		"app-rest-client.ts",
+		"queryModules.ts",
+		"acl/app.ability.ts"
+	].includes(normalizedRelativePath)) return true;
+	if (path.parse(filePath).ext !== ".ts") return false;
+	const segments = relativePath.split(path.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.existsSync(root)) return;
+	const removeIfEmpty = (dirPath) => {
+		for (const dirent of fs.readdirSync(dirPath, { withFileTypes: true })) if (dirent.isDirectory()) removeIfEmpty(path.join(dirPath, dirent.name));
+		if (dirPath !== root && fs.readdirSync(dirPath).length === 0) fs.rmdirSync(dirPath);
+	};
+	removeIfEmpty(root);
+}
+//#endregion
+//#region src/generators/core/resolveConfig.ts
+function resolveConfig({ fileConfig = {}, params: { includeTags, excludeTags, inlineEndpointsExcludeModules, workspaceContext, ...options } }) {
+	const resolvedConfig = deepMerge(DEFAULT_GENERATE_OPTIONS, fileConfig ?? {}, {
+		...options,
+		includeTags: includeTags?.split(","),
+		excludeTags: excludeTags?.split(","),
+		inlineEndpointsExcludeModules: inlineEndpointsExcludeModules?.split(","),
+		workspaceContext: workspaceContext?.split(",")
+	});
+	resolvedConfig.checkAcl = resolvedConfig.acl && resolvedConfig.checkAcl;
+	resolvedConfig.workspaceContext = Array.from(new Set((resolvedConfig.workspaceContext ?? []).map((value) => value.trim()).filter(Boolean)));
+	return resolvedConfig;
+}
+//#endregion
+//#region src/native/native-bindings.ts
+let bindings;
+let nativePath;
+function getNativePath() {
+	if (nativePath) return nativePath;
+	const moduleDir = path$1.dirname(fileURLToPath(import.meta.url));
+	const binaryName = `openapi-codegen-native-${process.platform}-${process.arch}.node`;
+	nativePath = [path$1.join(moduleDir, binaryName), path$1.resolve(moduleDir, "../../dist", binaryName)].find(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 = createRequire(import.meta.url);
+		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/native/generateFilesFromNativeOpenAPI.ts
+function generateFilesFromNativeOpenAPI(source, yaml, options) {
+	if (!supportsCompleteNativeRender(options)) {
+		if (process.env.OPENAPI_CODEGEN_REQUIRE_FULL_NATIVE === "1") throw new Error("The selected options are not supported by the full native renderer");
+		return;
+	}
+	const nativeData = compileNativeData(source, yaml, JSON.stringify({
+		...options,
+		nativeCompact: true
+	})).data;
+	if (!nativeData.renderedComplete) {
+		if (process.env.OPENAPI_CODEGEN_REQUIRE_FULL_NATIVE === "1") throw new Error("The selected options are not supported by the full native renderer");
+		return;
+	}
+	const files = [];
+	const taggedRenderers = options.modelsOnly ? [["models", nativeData.renderedModels]] : [
+		["models", nativeData.renderedModels],
+		["endpoints", nativeData.renderedEndpoints],
+		["queries", nativeData.renderedQueries],
+		...options.acl ? [["acl", nativeData.renderedAcl]] : []
+	];
+	for (const tag of nativeData.renderedTags) for (const [type, rendered] of taggedRenderers) {
+		const content = rendered[tag];
+		if (content) files.push(taggedFile(options, tag, type, content));
+	}
+	if (!options.modelsOnly) {
+		if (options.acl && nativeData.renderedShared.appAcl) files.push(outputFile(options, "acl/app.ability.ts", nativeData.renderedShared.appAcl));
+		if (options.mutationEffects && nativeData.renderedShared.queryModules) files.push(outputFile(options, "queryModules.ts", nativeData.renderedShared.queryModules));
+		if (!options.restClientImportPath) files.push(outputFile(options, "app-rest-client.ts", `import { RestClient } from "@povio/openapi-codegen";\n\nexport const AppRestClient = new RestClient({\n  config: {\n    baseURL: "${nativeData.baseUrl}"\n  },\n});\n`));
+		if (nativeData.renderedShared.domainErrors) files.push(outputFile(options, "domain-errors.ts", nativeData.renderedShared.domainErrors));
+	}
+	return files;
+}
+function supportsCompleteNativeRender(options) {
+	return options.splitByTags && (options.modelsInCommon && options.tsNamespaces || !options.modelsInCommon && !options.tsNamespaces) && !options.inlineEndpoints && !options.builderConfigs && (options.workspaceContext?.length ?? 0) === 0;
+}
+function taggedFile(options, tag, type, content) {
+	return outputFile(options, getTagFileName({
+		tag,
+		type,
+		options
+	}), content);
+}
+function outputFile(options, fileName, content) {
+	return {
+		fileName: getOutputFileName({
+			output: options.output,
+			fileName
+		}),
+		content
+	};
+}
+//#endregion
+//#region src/generators/run/generate.runner.ts
+async function runGenerate({ fileConfig, params, formatGeneratedFile, profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1") }) {
+	const config = profiler.runSync("config.resolve", () => resolveConfig({
+		fileConfig,
+		params: params ?? {}
+	}));
+	const useNative = shouldUseNativeCodegen();
+	const isJson = path.extname(new URL(config.input, "file://").pathname).toLowerCase() === ".json";
+	const useRawNativeInput = useNative && (isJson || typeof Bun === "undefined");
+	let nativeInput = useRawNativeInput ? await getRawOpenApiSource(config.input, profiler) : await getOpenApiSource(config.input, profiler);
+	if (useNative && !useRawNativeInput) {
+		const document = "document" in nativeInput ? nativeInput.document : void 0;
+		nativeInput = {
+			...nativeInput,
+			source: profiler.runSync("openapi.serialize", () => JSON.stringify(document)),
+			yaml: false
+		};
+	}
+	const openApiDoc = "document" in nativeInput ? nativeInput.document : {};
+	const outputExists = fs.existsSync(config.output);
+	const filesData = await profiler.runAsync("generate.total", async () => {
+		if (useNative) {
+			const nativeFiles = generateFilesFromNativeOpenAPI(nativeInput.source, nativeInput.yaml, config);
+			if (nativeFiles) return nativeFiles;
+		}
+		const { generateCodeFromOpenAPIDoc } = await import("./generateCodeFromOpenAPIDoc-CLQbTTwF.mjs").then((n) => n.n);
+		return generateCodeFromOpenAPIDoc(openApiDoc, config, profiler, {
+			source: nativeInput.source,
+			yaml: nativeInput.yaml
+		});
+	});
+	if (config.clearOutput) profiler.runSync("files.removeStaleGenerated", () => {
+		removeStaleGeneratedFiles({
+			output: config.output,
+			filesData,
+			options: config
+		});
+	});
+	await profiler.runAsync("files.write", async () => {
+		await writeGenerateFileData(filesData, {
+			formatGeneratedFile,
+			skipExistingCheck: !outputExists
+		});
+	});
+	return {
+		skipped: false,
+		config,
+		stats: getGenerateStats(filesData, config)
+	};
+}
+async function getOpenApiDoc(input, profiler = new Profiler(false)) {
+	return (await getOpenApiSource(input, profiler)).document;
+}
+async function getOpenApiSource(input, profiler = new Profiler(false)) {
+	const raw = await getRawOpenApiSource(input, profiler);
+	const { source } = raw;
+	const document = await profiler.runAsync("openapi.parse", () => parseOpenApiSource(input, source));
+	return {
+		...raw,
+		document
+	};
+}
+async function getRawOpenApiSource(input, profiler = new Profiler(false)) {
+	return {
+		source: await profiler.runAsync("openapi.read", () => readOpenApiSource(input)),
+		yaml: path.extname(new URL(input, "file://").pathname).toLowerCase() !== ".json"
+	};
+}
+async function readOpenApiSource(input) {
+	if (/^https?:\/\//i.test(input)) {
+		const response = await fetch(input);
+		if (!response.ok) throw new Error(`Unable to load OpenAPI document: ${response.status} ${response.statusText}`);
+		return response.text();
+	}
+	return fs.promises.readFile(input, "utf-8");
+}
+async function parseOpenApiSource(input, source) {
+	try {
+		return JSON.parse(source.charCodeAt(0) === 65279 ? source.slice(1) : source);
+	} catch (error) {
+		if (path.extname(new URL(input, "file://").pathname).toLowerCase() === ".json") throw error;
+		if (typeof Bun !== "undefined") return Bun.YAML.parse(source);
+		const { parse } = await import("yaml");
+		return parse(source);
+	}
+}
+function getGenerateStats(filesData, config) {
+	const generatedFilesCount = filesData.length;
+	if (generatedFilesCount === 0) return {
+		generatedFilesCount,
+		generatedModulesCount: 0
+	};
+	if (!config.splitByTags) return {
+		generatedFilesCount,
+		generatedModulesCount: 1
+	};
+	const moduleSuffixes = new Set(Object.values(config.configs).map((generateConfig) => generateConfig.outputFileNameSuffix).filter(Boolean));
+	const modules = /* @__PURE__ */ new Set();
+	for (const file of filesData) {
+		const segments = path.relative(config.output, file.fileName).split(path.sep).filter(Boolean);
+		if (segments.length < 2) continue;
+		const moduleName = segments[0];
+		const fileName = segments[segments.length - 1];
+		if (!fileName.startsWith(`${moduleName}.`)) continue;
+		const suffix = fileName.slice(moduleName.length + 1).replace(/\.tsx?$/, "");
+		if (moduleSuffixes.has(suffix)) modules.add(moduleName);
+	}
+	return {
+		generatedFilesCount,
+		generatedModulesCount: modules.size
+	};
+}
+//#endregion
+export { getImportedAbilityFunctionName as $, isParamMediaTypeAllowed as $t, getEndpointsImports as A, BODY_PARAMETER_NAME as An, getZodSchemaName as At, getPrefetchInfiniteQueryName as B, getMostCommonAdjacentCombinationSplit as Bn, QUERY_MODULE_ENUM as Bt, getAppRestClientImportPath as C, UUID_SCHEMA as Cn, isReadEndpoint as Ct, getTagFileName as D, AXIOS_IMPORT as Dn, getEnumZodSchemaName as Dt, getQueryTypesImportPath as E, AXIOS_DEFAULT_IMPORT_NAME as En, getBodyZodSchemaName as Et, mergeImports as F, isTagIncluded as Fn, APP_REST_CLIENT_NAME as Ft, getAbilityConditionType as G, autocorrectRef as Gt, getQueryName as H, removeWord as Hn, ZOD_EXTENDED as Ht, getImportedInfiniteQueryName as I, shouldInlineEndpointsForTag as In, BUILDERS_UTILS as It, getAbilityFunctionName as J, getSchemaNameByRef as Jt, getAbilityConditionsTypes as K, escapeControlCharacters as Kt, getImportedQueryName as L, camelToSpaceSeparated as Ln, DOMAIN_ERRORS_FILE as Lt, getInfiniteQueriesImports as M, formatTag as Mn, isEnumZodSchema as Mt, getModelsImports as N, getEndpointTag as Nn, isNamedZodSchema as Nt, getTagImportPath as O, AXIOS_REQUEST_CONFIG_NAME as On, getParamZodSchemaName as Ot, getQueriesImports as P, getOperationTag as Pn, APP_REST_CLIENT_FILE as Pt, getAppAbilitiesType as Q, isMediaTypeAllowed as Qt, getInfiniteQueryName as R, capitalize as Rn, MUTATION_EFFECTS as Rt, getTsTypeBase as S, URL_SCHEMA as Sn, isReadAllEndpoint as St, getQueryModulesImportPath as T, ZOD_IMPORT as Tn, invalidVariableNameCharactersToCamel as Tt, getQueryOptionsName as U, snakeToCamel as Un, PACKAGE_IMPORT_PATH as Ut, getPrefetchQueryName as V, kebabToCamel as Vn, QUERY_OPTIONS_TYPES as Vt, getAbilityAction as W, Profiler as Wn, getNamespaceName as Wt, getAbilitySubjectTypes as X, isErrorStatus as Xt, getAbilitySubject as Y, getSchemaRef as Yt, getAclData as Z, isMainResponseStatus as Zt, hasEndpointConfig as _, EMAIL_SCHEMA as _n, getPathSegments as _t, resolveConfig as a, replaceHyphenatedPath as an, getZodSchemaInferedTypeName as at, requiresBody as b, NUMBER_SCHEMA as bn, isDeleteEndpoint as bt, getDestructuredVariables as c, inferRequiredSchema as cn, getSchemaDescriptions as ct, isQuery as d, isSchemaObject as dn, DEFAULT_GENERATE_OPTIONS as dt, isPathExcluded as en, hasAbilityConditions as et, getEndpointBody as f, ALLOWED_METHODS as fn, ACL_APP_ABILITIES as ft, getImportedEndpointName as g, DATETIME_SCHEMA as gn, CASL_ABILITY_IMPORT as gt, getEndpointPath as h, BLOB_SCHEMA as hn, CASL_ABILITY_BINDING as ht, shouldUseNativeCodegen as i, pathToVariableName as in, getZodSchemaDescription as it, getImportPath as j, JSON_APPLICATION_FORMAT as jn, getZodSchemaOperationName as jt, getAclImports as k, AXIOS_REQUEST_CONFIG_TYPE as kn, getResponseZodSchemaName as kt, isInfiniteQuery as l, isArraySchemaObject as ln, iterateSchema as lt, getEndpointName as m, ANY_SCHEMA as mn, ACL_CHECK_HOOK as mt, runGenerate as n, isSortingParameterObject as nn, getImportedZodSchemaInferedTypeName as nt, getOutputFileName as o, unwrapQuotesIfNeeded as on, getZodSchemaPropertyDescriptions as ot, getEndpointConfig as p, ALLOWED_PATH_IN as pn, ACL_APP_ABILITY_FILE as pt, getAbilityDescription as q, getParameterEnumNames as qt, compileNativeData as r, pathParamToVariableName as rn, getImportedZodSchemaName as rt, pick as s, wrapWithQuotesIfNeeded as sn, getZodSchemaType as st, getOpenApiDoc as t, isPrimitiveType as tn, renderAclCheckCall as tt, isMutation as u, isReferenceObject as un, getUniqueArray as ut, mapEndpointParamsToFunctionParams as v, ENUM_SCHEMA as vn, isBulkDeleteEndpoint as vt, getFileNameWithExtension as w, VOID_SCHEMA as wn, isUpdateEndpoint as wt, getSchemaTsMetaType as x, STRING_SCHEMA as xn, isPathSegmentParam as xt, renderMediaUploadMutationBody as y, INT_SCHEMA as yn, isCreateEndpoint as yt, getInfiniteQueryOptionsName as z, decapitalize as zn, QUERY_MODULES_FILE as zt };