@povio/openapi-codegen-cli 3.1.1-rc.1 → 3.2.0-rc.10

package/dist/native-bindings-BTQGSGhU.mjs

@@ -0,0 +1,1480 @@
+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 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/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";
+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/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/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/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.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/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
+//#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);",
+		"  }",
+		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/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/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
+export { getImportedAbilityFunctionName as $, isPrimitiveType as $t, getEndpointsImports as A, NATIVE_RESPONSE_TYPE as An, APP_REST_CLIENT_NAME as At, getPrefetchInfiniteQueryName as B, getMostCommonAdjacentCombinationSplit as Bn, PACKAGE_IMPORT_PATH as Bt, getAppRestClientImportPath as C, ZOD_IMPORT as Cn, getParamZodSchemaName as Ct, getTagFileName as D, AXIOS_REQUEST_CONFIG_TYPE as Dn, isEnumZodSchema as Dt, getQueryTypesImportPath as E, AXIOS_REQUEST_CONFIG_NAME as En, getZodSchemaOperationName as Et, mergeImports as F, isTagIncluded as Fn, QUERY_MODULE_ENUM as Ft, getAbilityConditionType as G, getParameterEnumNames as Gt, getQueryName as H, removeWord as Hn, getNamespaceName as Ht, getImportedInfiniteQueryName as I, shouldInlineEndpointsForTag as In, QUERY_OPTIONS_TYPES as It, getAbilityFunctionName as J, isErrorStatus as Jt, getAbilityConditionsTypes as K, getSchemaNameByRef as Kt, getImportedQueryName as L, camelToSpaceSeparated as Ln, ZOD_EXTENDED as Lt, getInfiniteQueriesImports as M, formatTag as Mn, DOMAIN_ERRORS_FILE as Mt, getModelsImports as N, getEndpointTag as Nn, MUTATION_EFFECTS as Nt, getTagImportPath as O, BODY_PARAMETER_NAME as On, isNamedZodSchema as Ot, getQueriesImports as P, getOperationTag as Pn, QUERY_MODULES_FILE as Pt, getAppAbilitiesType as Q, isPathExcluded as Qt, getInfiniteQueryName as R, capitalize as Rn, CONFIG_PACKAGE_IMPORT_PATH as Rt, getTsTypeBase as S, VOID_SCHEMA as Sn, getEnumZodSchemaName as St, getQueryModulesImportPath as T, AXIOS_IMPORT as Tn, getZodSchemaName as Tt, getQueryOptionsName as U, snakeToCamel as Un, autocorrectRef as Ut, getPrefetchQueryName as V, kebabToCamel as Vn, REST_PACKAGE_IMPORT_PATH as Vt, getAbilityAction as W, Profiler as Wn, escapeControlCharacters as Wt, getAbilitySubjectTypes as X, isMediaTypeAllowed as Xt, getAbilitySubject as Y, isMainResponseStatus as Yt, getAclData as Z, isParamMediaTypeAllowed as Zt, hasEndpointConfig as _, INT_SCHEMA as _n, isReadAllEndpoint as _t, writeGenerateFileData as a, wrapWithQuotesIfNeeded as an, getZodSchemaInferedTypeName as at, requiresBody as b, URL_SCHEMA as bn, invalidVariableNameCharactersToCamel as bt, getDestructuredVariables as c, isReferenceObject as cn, getSchemaDescriptions as ct, isQuery as d, ALLOWED_PATH_IN as dn, DEFAULT_GENERATE_OPTIONS as dt, isSortingParameterObject as en, hasAbilityConditions as et, getEndpointBody as f, ANY_SCHEMA as fn, getPathSegments as ft, getImportedEndpointName as g, ENUM_SCHEMA as gn, isPathSegmentParam as gt, getEndpointPath as h, EMAIL_SCHEMA as hn, isDeleteEndpoint as ht, removeStaleGeneratedFiles as i, unwrapQuotesIfNeeded as in, getZodSchemaDescription as it, getImportPath as j, getRequestConfigTypeName as jn, BUILDERS_UTILS as jt, getAclImports as k, JSON_APPLICATION_FORMAT as kn, APP_REST_CLIENT_FILE as kt, isInfiniteQuery as l, isSchemaObject as ln, iterateSchema as lt, getEndpointName as m, DATETIME_SCHEMA as mn, isCreateEndpoint as mt, shouldUseNativeCodegen as n, pathToVariableName as nn, getImportedZodSchemaInferedTypeName as nt, deepMerge as o, inferRequiredSchema as on, getZodSchemaPropertyDescriptions as ot, getEndpointConfig as p, BLOB_SCHEMA as pn, isBulkDeleteEndpoint as pt, getAbilityDescription as q, getSchemaRef as qt, getOutputFileName as r, replaceHyphenatedPath as rn, getImportedZodSchemaName as rt, pick as s, isArraySchemaObject as sn, getZodSchemaType as st, compileNativeData as t, pathParamToVariableName as tn, renderAclCheckCall as tt, isMutation as u, ALLOWED_METHODS as un, getUniqueArray as ut, mapEndpointParamsToFunctionParams as v, NUMBER_SCHEMA as vn, isReadEndpoint as vt, getFileNameWithExtension as w, AXIOS_DEFAULT_IMPORT_NAME as wn, getResponseZodSchemaName as wt, getSchemaTsMetaType as x, UUID_SCHEMA as xn, getBodyZodSchemaName as xt, renderMediaUploadMutationBody as y, STRING_SCHEMA as yn, isUpdateEndpoint as yt, getInfiniteQueryOptionsName as z, decapitalize as zn, NATIVE_PACKAGE_IMPORT_PATH as zt };