@orval/core 8.5.2 → 8.6.0

package/dist/index.mjs

@@ -2,10 +2,11 @@ import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
 import { createRequire } from "node:module";
 import { entries, groupBy, isArray, isBoolean, isBoolean as isBoolean$1, isEmptyish, isFunction, isNullish, isNullish as isNullish$1, isNumber, isString, isString as isString$1, prop, unique, uniqueBy, uniqueWith } from "remeda";
 import { keyword } from "esutils";
-import path from "node:path";
+import nodePath from "node:path";
 import { compare } from "compare-versions";
 import debug from "debug";
 import { pathToFileURL } from "node:url";
+import { createJiti } from "jiti";
 import fs, { existsSync, readFileSync } from "node:fs";
 import { globby } from "globby";
 import readline from "node:readline";
@@ -134,7 +135,7 @@ function isReference(obj) {
 	return !isNullish$1(obj) && Object.hasOwn(obj, "$ref");
 }
 function isDirectory(pathValue) {
-	return !path.extname(pathValue);
+	return !nodePath.extname(pathValue);
 }
 function isObject(x) {
 	return Object.prototype.toString.call(x) === "[object Object]";
@@ -245,10 +246,10 @@ function camel(s = "") {
 	const camelString = decap(pascal(s), isStartWithUnderscore ? 1 : 0);
 	return isStartWithUnderscore ? `_${camelString}` : camelString;
 }
-function snake(s) {
+function snake(s = "") {
 	return lower(s, "_", true);
 }
-function kebab(s) {
+function kebab(s = "") {
 	return lower(s, "-", true);
 }
 function upper(s, fillWith, isDeapostrophe) {
@@ -457,18 +458,32 @@ function keyValuePairsToJsDoc(keyValues) {
 
 //#endregion
 //#region src/utils/dynamic-import.ts
+const TS_MODULE_EXTENSIONS = new Set([
+	".ts",
+	".mts",
+	".cts",
+	".tsx",
+	".jsx"
+]);
 async function dynamicImport(toImport, from = process.cwd(), takeDefault = true) {
 	if (!toImport) return toImport;
 	try {
 		if (isString(toImport)) {
-			const fileUrl = pathToFileURL(path.resolve(from, toImport));
-			const data = path.extname(fileUrl.href) === ".json" ? await import(fileUrl.href, { with: { type: "json" } }) : await import(fileUrl.href);
+			const filePath = nodePath.resolve(from, toImport);
+			const extension = nodePath.extname(filePath);
+			if (TS_MODULE_EXTENSIONS.has(extension)) {
+				const data = await createJiti(from, { interopDefault: true }).import(filePath);
+				if (takeDefault && (isObject(data) || isModule(data)) && data.default) return data.default;
+				return data;
+			}
+			const fileUrl = pathToFileURL(filePath);
+			const data = extension === ".json" ? await import(fileUrl.href, { with: { type: "json" } }) : await import(fileUrl.href);
 			if (takeDefault && (isObject(data) || isModule(data)) && data.default) return data.default;
 			return data;
 		}
 		return toImport;
 	} catch (error) {
-		throw new Error(`Oups... 🍻. Path: ${String(toImport)} => ${String(error)}`);
+		throw new Error(`Oups... 🍻. Path: ${String(toImport)} => ${String(error)}`, { cause: error });
 	}
 }
 
@@ -482,14 +497,14 @@ function getExtension(path) {
 //#region src/utils/file.ts
 function getFileInfo(target = "", { backupFilename = "filename", extension = ".ts" } = {}) {
 	const isDir = isDirectory(target);
-	const filePath = isDir ? path.join(target, backupFilename + extension) : target;
+	const filePath = isDir ? nodePath.join(target, backupFilename + extension) : target;
 	return {
 		path: filePath,
 		pathWithoutExtension: filePath.replace(/\.[^/.]+$/, ""),
 		extension,
 		isDirectory: isDir,
-		dirname: path.dirname(filePath),
-		filename: path.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
+		dirname: nodePath.dirname(filePath),
+		filename: nodePath.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
 	};
 }
 async function removeFilesAndEmptyFolders(patterns, dir) {
@@ -565,7 +580,7 @@ function startMessage({ name, version, description }) {
 	return `🍻 ${styleText(["cyan", "bold"], name)} ${styleText("green", `v${version}`)}${description ? ` - ${description}` : ""}`;
 }
 function logError(err, tag) {
-	let message = "";
+	let message;
 	if (err instanceof Error) {
 		message = (err.message || err.stack) ?? "Unknown error";
 		if (err.cause) {
@@ -693,13 +708,13 @@ function toUnix(value) {
 	return value;
 }
 function join(...args) {
-	return toUnix(path.join(...args.map((a) => toUnix(a))));
+	return toUnix(nodePath.join(...args.map((a) => toUnix(a))));
 }
 /**
 * Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
 */
 function relativeSafe(from, to) {
-	return normalizeSafe(`.${separator}${toUnix(path.relative(toUnix(from), toUnix(to)))}`);
+	return normalizeSafe(`.${separator}${toUnix(nodePath.relative(toUnix(from), toUnix(to)))}`);
 }
 function getSchemaFileName(path) {
 	return path.replace(`.${getExtension(path)}`, "").slice(path.lastIndexOf("/") + 1);
@@ -708,13 +723,13 @@ const separator = "/";
 function normalizeSafe(value) {
 	let result;
 	value = toUnix(value);
-	result = toUnix(path.normalize(value));
+	result = toUnix(nodePath.normalize(value));
 	if (value.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
 	else if (value.startsWith("//") && !result.startsWith("//")) result = value.startsWith("//./") ? "//." + result : "/" + result;
 	return result;
 }
 function joinSafe(...values) {
-	let result = toUnix(path.join(...values.map((v) => toUnix(v))));
+	let result = toUnix(nodePath.join(...values.map((v) => toUnix(v))));
 	if (values.length > 0) {
 		const firstValue = toUnix(values[0]);
 		if (firstValue.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
@@ -745,14 +760,14 @@ function joinSafe(...values) {
 * @returns The relative import path string.
 */
 function getRelativeImportPath(importerFilePath, exporterFilePath, includeFileExtension = false) {
-	if (!path.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
-	if (!path.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
-	const importerDir = path.dirname(importerFilePath);
-	const relativePath = path.relative(importerDir, exporterFilePath);
-	let posixPath = path.posix.join(...relativePath.split(path.sep));
+	if (!nodePath.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
+	if (!nodePath.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
+	const importerDir = nodePath.dirname(importerFilePath);
+	const relativePath = nodePath.relative(importerDir, exporterFilePath);
+	let posixPath = nodePath.posix.join(...relativePath.split(nodePath.sep));
 	if (!posixPath.startsWith("./") && !posixPath.startsWith("../")) posixPath = `./${posixPath}`;
 	if (!includeFileExtension) {
-		const ext = path.extname(posixPath);
+		const ext = nodePath.extname(posixPath);
 		if (ext && posixPath.endsWith(ext)) posixPath = posixPath.slice(0, -ext.length);
 	}
 	return posixPath;
@@ -762,20 +777,20 @@ function getRelativeImportPath(importerFilePath, exporterFilePath, includeFileEx
 //#region src/utils/resolve-version.ts
 function resolveInstalledVersion(packageName, fromDir) {
 	try {
-		const require = createRequire(path.join(fromDir, "noop.js"));
+		const require = createRequire(nodePath.join(fromDir, "noop.js"));
 		try {
 			return require(`${packageName}/package.json`).version;
 		} catch (directError) {
 			if (directError instanceof Error && "code" in directError && directError.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
 				const entryPath = require.resolve(packageName);
-				let dir = path.dirname(entryPath);
-				while (dir !== path.parse(dir).root) {
-					const pkgPath = path.join(dir, "package.json");
+				let dir = nodePath.dirname(entryPath);
+				while (dir !== nodePath.parse(dir).root) {
+					const pkgPath = nodePath.join(dir, "package.json");
 					if (existsSync(pkgPath)) {
 						const pkgData = JSON.parse(readFileSync(pkgPath, "utf8"));
 						if (pkgData.name === packageName) return pkgData.version;
 					}
-					dir = path.dirname(dir);
+					dir = nodePath.dirname(dir);
 				}
 				return;
 			}
@@ -817,7 +832,7 @@ const sortByPriority = (arr) => arr.toSorted((a, b) => {
 * Handles strings, numbers, booleans, functions, arrays, and objects.
 *
 * @param data - The data to stringify. Can be a string, array, object, number, boolean, function, null, or undefined.
-* @returns A string representation of the data, or undefined if data is null or undefined.
+* @returns A string representation of the data, `null` for null, or undefined if data is undefined.
 * @example
 * stringify('hello') // returns "'hello'"
 * stringify(42) // returns "42"
@@ -825,7 +840,8 @@ const sortByPriority = (arr) => arr.toSorted((a, b) => {
 * stringify({ a: 1, b: 'test' }) // returns "{ a: 1, b: 'test', }"
 */
 function stringify(data) {
-	if (isNullish$1(data)) return;
+	if (data === void 0) return;
+	if (data === null) return "null";
 	if (isString(data)) return `'${data.replaceAll("'", String.raw`\'`)}'`;
 	if (isNumber(data) || isBoolean(data) || isFunction(data)) return String(data);
 	if (Array.isArray(data)) return `[${data.map((item) => stringify(item)).join(", ")}]`;
@@ -918,17 +934,31 @@ function getNumberWord(num) {
 	return [...num.toString()].reduce((acc, n) => acc + NUMBERS[n], "");
 }
 /**
-* Escapes a specific character in a string by prefixing it with a backslash.
+* Escapes a specific character in a string by prefixing all of its occurrences with a backslash.
 *
 * @param str - The string to escape, or null.
 * @param char - The character to escape. Defaults to single quote (').
 * @returns The escaped string, or null if the input is null.
 * @example
 * escape("don't") // returns "don\'t"
+* escape("it's John's") // returns "it\'s John\'s"
 * escape('say "hello"', '"') // returns 'say \\"hello\\"'
+* escape("a'''b", "'") // returns "a\'\'\'b"
 */
 function escape(str, char = "'") {
-	return str?.replace(char, `\\${char}`);
+	return str?.replaceAll(char, `\\${char}`);
+}
+/**
+* Escapes regular expression metacharacters in a string so it can be safely
+* embedded inside a RegExp pattern.
+*
+* @param value - The raw string value to escape for regex usage.
+* @returns The escaped string.
+* @example
+* escapeRegExp('foo$bar') // returns 'foo\\$bar'
+*/
+function escapeRegExp(value) {
+	return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
 }
 /**
 * Escape all characters not included in SingleStringCharacters and
@@ -996,6 +1026,38 @@ function isSyntheticDefaultImportsAllow(config) {
 
 //#endregion
 //#region src/getters/enum.ts
+/**
+* Map of special characters to semantic word replacements.
+*
+* Applied before naming convention transforms (PascalCase, camelCase, …) so
+* that characters which would otherwise be stripped still contribute a unique
+* segment to the generated key.  Without this, values like "created_at" and
+* "-created_at" both PascalCase to "CreatedAt", silently overwriting one
+* another in the generated const/enum object.
+*
+* Only characters that appear as leading/trailing modifiers in real-world
+* OpenAPI enums are mapped — the list is intentionally conservative to avoid
+* changing output for schemas that don't hit collisions.
+*/
+const ENUM_SPECIAL_CHARACTER_MAP = {
+	"-": "minus",
+	"+": "plus"
+};
+/**
+* Replace special characters with semantic words (plus an underscore separator)
+* so that naming convention transforms (PascalCase, etc.) produce unique keys.
+*
+* The trailing underscore acts as a word boundary so that PascalCase treats the
+* replacement as a separate word: "-created_at" → "minus_created_at" → "MinusCreatedAt".
+*/
+function replaceSpecialCharacters(key) {
+	let result = "";
+	for (const char of key) {
+		const replacement = ENUM_SPECIAL_CHARACTER_MAP[char];
+		result += replacement ? replacement + "_" : char;
+	}
+	return result;
+}
 function getEnumNames(schemaObject) {
 	const names = schemaObject?.["x-enumNames"] ?? schemaObject?.["x-enumnames"] ?? schemaObject?.["x-enum-varnames"];
 	if (!names) return;
@@ -1023,9 +1085,33 @@ const getTypeConstEnum = (value, enumName, names, descriptions, enumNamingConven
 	enumValue += `export const ${enumName} = {\n${implementation}} as const;\n`;
 	return enumValue;
 };
+/**
+* Derive the object/enum key for a single enum value.
+*
+* Handles numeric prefixes, sanitization, and optional naming convention
+* transforms.  When `disambiguate` is true, special characters (-/+) are
+* replaced with semantic words before the convention transform to prevent
+* key collisions.
+*/
+function deriveEnumKey(val, enumNamingConvention, disambiguate = false) {
+	let key = val.startsWith("'") ? val.slice(1, -1) : val;
+	if (isNumeric(key)) key = toNumberKey(key);
+	if (key.length > 1) key = sanitize(key, {
+		whitespace: "_",
+		underscore: true,
+		dash: true,
+		special: true
+	});
+	if (enumNamingConvention) {
+		if (disambiguate) key = replaceSpecialCharacters(key);
+		key = conventionName(key, enumNamingConvention);
+	}
+	return key;
+}
 function getEnumImplementation(value, names, descriptions, enumNamingConvention) {
 	if (value === "") return "";
 	const uniqueValues = [...new Set(value.split(" | "))];
+	const disambiguate = !!enumNamingConvention && new Set(uniqueValues.map((v) => deriveEnumKey(v, enumNamingConvention))).size < uniqueValues.length;
 	let result = "";
 	for (const [index, val] of uniqueValues.entries()) {
 		const name = names?.[index];
@@ -1035,15 +1121,7 @@ function getEnumImplementation(value, names, descriptions, enumNamingConvention)
 			result += comment + `  ${keyword.isIdentifierNameES5(name) ? name : `'${name}'`}: ${val},\n`;
 			continue;
 		}
-		let key = val.startsWith("'") ? val.slice(1, -1) : val;
-		if (isNumeric(key)) key = toNumberKey(key);
-		if (key.length > 1) key = sanitize(key, {
-			whitespace: "_",
-			underscore: true,
-			dash: true,
-			special: true
-		});
-		if (enumNamingConvention) key = conventionName(key, enumNamingConvention);
+		const key = deriveEnumKey(val, enumNamingConvention, disambiguate);
 		result += comment + `  ${keyword.isIdentifierNameES5(key) ? key : `'${key}'`}: ${val},\n`;
 	}
 	return result;
@@ -1054,6 +1132,7 @@ const getNativeEnum = (value, enumName, names, enumNamingConvention) => {
 const getNativeEnumItems = (value, names, enumNamingConvention) => {
 	if (value === "") return "";
 	const uniqueValues = [...new Set(value.split(" | "))];
+	const disambiguate = !!enumNamingConvention && new Set(uniqueValues.map((v) => deriveEnumKey(v, enumNamingConvention))).size < uniqueValues.length;
 	let result = "";
 	for (const [index, val] of uniqueValues.entries()) {
 		const name = names?.[index];
@@ -1061,15 +1140,7 @@ const getNativeEnumItems = (value, names, enumNamingConvention) => {
 			result += `  ${keyword.isIdentifierNameES5(name) ? name : `'${name}'`}= ${val},\n`;
 			continue;
 		}
-		let key = val.startsWith("'") ? val.slice(1, -1) : val;
-		if (isNumeric(key)) key = toNumberKey(key);
-		if (key.length > 1) key = sanitize(key, {
-			whitespace: "_",
-			underscore: true,
-			dash: true,
-			special: true
-		});
-		if (enumNamingConvention) key = conventionName(key, enumNamingConvention);
+		const key = deriveEnumKey(val, enumNamingConvention, disambiguate);
 		result += `  ${keyword.isIdentifierNameES5(key) ? key : `'${key}'`}= ${val},\n`;
 	}
 	return result;
@@ -1176,7 +1247,7 @@ function getRefInfo($ref, context) {
 		return firstLevel[paths[1]]?.suffix ?? "";
 	};
 	const suffix = getOverrideSuffix(context.output.override, refPaths);
-	const originalName = ref ? refPaths[refPaths.length - 1] : getSchemaFileName(pathname);
+	const originalName = ref ? refPaths.at(-1) ?? "" : getSchemaFileName(pathname);
 	if (!pathname) return {
 		name: sanitize(pascal(originalName) + suffix, {
 			es5keyword: true,
@@ -1263,10 +1334,9 @@ function getSchema$1(schema, context) {
 	if (!schema.$ref) throw new Error(`${REF_NOT_FOUND_PREFIX}: missing $ref`);
 	const refInfo = getRefInfo(schema.$ref, context);
 	const { refPaths } = refInfo;
-	let schemaByRefPaths = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
-	schemaByRefPaths ??= context.spec;
-	if (isReference(schemaByRefPaths)) return getSchema$1(schemaByRefPaths, context);
-	let currentSchema = schemaByRefPaths || context.spec;
+	const schemaByRefPaths = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
+	if (isObject(schemaByRefPaths) && isReference(schemaByRefPaths)) return getSchema$1(schemaByRefPaths, context);
+	let currentSchema = schemaByRefPaths;
 	if (isObject(currentSchema) && "nullable" in schema) {
 		const nullable = schema.nullable;
 		currentSchema = {
@@ -1503,7 +1573,7 @@ function getArray({ schema, name, context, formDataContext }) {
 			example: schemaExample,
 			examples: resolveExampleRefs(schemaExamples, context)
 		};
-	} else if (compareVersions(context.spec.openapi, "3.1", ">=")) return {
+	} else if (compareVersions(context.spec.openapi ?? "3.0.0", "3.1", ">=")) return {
 		value: "unknown[]",
 		imports: [],
 		schemas: [],
@@ -1561,11 +1631,12 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				isEnum: false,
 				isRef: true,
 				hasReadonlyProps: false,
+				dependencies: [name],
 				originalSchema: void 0,
 				example: void 0,
 				examples: void 0,
 				key,
-				contentType: void 0
+				contentType: ""
 			}];
 			const [contentType, mediaType] = firstEntry;
 			const isFormData = formDataContentTypes.has(contentType);
@@ -1581,6 +1652,7 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				isEnum: false,
 				isRef: true,
 				hasReadonlyProps: false,
+				dependencies: [name],
 				originalSchema: mediaType.schema,
 				example: mediaType.example,
 				examples: resolveExampleRefs(mediaType.examples, context),
@@ -1618,6 +1690,7 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				type: "unknown",
 				isEnum: false,
 				hasReadonlyProps: false,
+				dependencies: [name],
 				formData,
 				formUrlEncoded,
 				isRef: true,
@@ -1662,6 +1735,7 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 			if (!isFormData && !isFormUrlEncoded || !effectivePropName || !mediaType.schema) return {
 				...resolvedValue,
 				imports: resolvedValue.imports,
+				dependencies: resolvedValue.dependencies,
 				contentType,
 				example: mediaType.example,
 				examples: resolveExampleRefs(mediaType.examples, context)
@@ -1716,6 +1790,7 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 			schemas: [],
 			type: defaultType,
 			isEnum: false,
+			dependencies: [],
 			key,
 			isRef: false,
 			hasReadonlyProps: false,
@@ -1927,7 +2002,7 @@ function getBody({ requestBody, operationName, context, contentType }) {
 	const imports = filteredBodyTypes.flatMap(({ imports }) => imports);
 	const schemas = filteredBodyTypes.flatMap(({ schemas }) => schemas);
 	const definition = filteredBodyTypes.map(({ value }) => value).join(" | ");
-	const nonReadonlyDefinition = filteredBodyTypes.some((x) => x.hasReadonlyProps) && definition ? `NonReadonly<${definition}>` : definition;
+	const nonReadonlyDefinition = filteredBodyTypes.some((x) => x.hasReadonlyProps) && definition && context.output.override.preserveReadonlyRequestBodies !== "preserve" ? `NonReadonly<${definition}>` : definition;
 	let implementation = generalJSTypesWithArray.includes(definition.toLowerCase()) || filteredBodyTypes.length > 1 ? camel(operationName) + context.output.override.components.requestBodies.suffix : camel(definition);
 	let isOptional = false;
 	if (implementation) {
@@ -2037,17 +2112,22 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			examples: resolveExampleRefs(item.examples, context)
 		};
 	}
-	if (item.allOf || item.oneOf || item.anyOf) return combineSchemas({
-		schema: item,
+	const schemaItem = item;
+	const itemAllOf = schemaItem.allOf;
+	const itemOneOf = schemaItem.oneOf;
+	const itemAnyOf = schemaItem.anyOf;
+	const itemType = schemaItem.type;
+	if (itemAllOf || itemOneOf || itemAnyOf) return combineSchemas({
+		schema: schemaItem,
 		name,
-		separator: item.allOf ? "allOf" : item.oneOf ? "oneOf" : "anyOf",
+		separator: itemAllOf ? "allOf" : itemOneOf ? "oneOf" : "anyOf",
 		context,
 		nullable,
 		formDataContext
 	});
-	if (Array.isArray(item.type)) {
-		const typeArray = item.type;
-		const baseItem = item;
+	if (Array.isArray(itemType)) {
+		const typeArray = itemType;
+		const baseItem = schemaItem;
 		return combineSchemas({
 			schema: { anyOf: typeArray.map((type) => ({
 				...baseItem,
@@ -2059,7 +2139,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			nullable
 		});
 	}
-	const itemProperties = item.properties;
+	const itemProperties = schemaItem.properties;
 	if (itemProperties && Object.entries(itemProperties).length > 0) {
 		const entries = Object.entries(itemProperties);
 		if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries.sort((a, b) => {
@@ -2072,14 +2152,13 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			isEnum: false,
 			type: "object",
 			isRef: false,
-			schema: {},
 			hasReadonlyProps: false,
 			useTypeAlias: false,
 			dependencies: [],
-			example: item.example,
-			examples: resolveExampleRefs(item.examples, context)
+			example: schemaItem.example,
+			examples: resolveExampleRefs(schemaItem.examples, context)
 		};
-		const itemRequired = item.required;
+		const itemRequired = schemaItem.required;
 		for (const [index, [key, schema]] of entries.entries()) {
 			const isRequired = (Array.isArray(itemRequired) ? itemRequired : []).includes(key);
 			let propName = "";
@@ -2099,10 +2178,11 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 				context,
 				formDataContext: propertyFormDataContext
 			});
-			const isReadOnly = item.readOnly ?? schema.readOnly;
+			const isReadOnly = Boolean(schemaItem.readOnly) || Boolean(schema.readOnly);
 			if (!index) acc.value += "{";
 			const doc = jsDoc(schema, true, context);
-			if (isReadOnly ?? false) acc.hasReadonlyProps = true;
+			const propertyDoc = doc ? `${doc.trimEnd().split("\n").map((line) => `  ${line}`).join("\n")}\n` : "";
+			if (isReadOnly) acc.hasReadonlyProps = true;
 			const constValue = "const" in schema ? schema.const : void 0;
 			const hasConst = constValue !== void 0;
 			let constLiteral;
@@ -2110,6 +2190,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			else if (isString(constValue)) constLiteral = `'${escape(constValue)}'`;
 			else constLiteral = JSON.stringify(constValue);
 			const needsValueImport = hasConst && (resolvedValue.isEnum || resolvedValue.type === "enum");
+			const usedResolvedValue = !hasConst || needsValueImport;
 			const aliasedImports = needsValueImport ? resolvedValue.imports.map((imp) => ({
 				...imp,
 				isConstant: true
@@ -2126,19 +2207,21 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			});
 			const propValue = needsValueImport ? alias : constLiteral ?? alias;
 			const finalPropValue = isRequired ? propValue : context.output.override.useNullForOptional === true ? `${propValue} | null` : propValue;
-			acc.value += `\n  ${doc ? `${doc}  ` : ""}${isReadOnly && !context.output.override.suppressReadonlyModifier ? "readonly " : ""}${getKey(key)}${isRequired ? "" : "?"}: ${finalPropValue};`;
-			acc.schemas.push(...resolvedValue.schemas);
-			acc.dependencies.push(...resolvedValue.dependencies);
+			acc.value += `\n${propertyDoc}${isReadOnly && !context.output.override.suppressReadonlyModifier ? "  readonly " : "  "}${getKey(key)}${isRequired ? "" : "?"}: ${finalPropValue};`;
+			if (usedResolvedValue) {
+				acc.schemas.push(...resolvedValue.schemas);
+				acc.dependencies.push(...resolvedValue.dependencies);
+			}
 			if (entries.length - 1 === index) {
-				const additionalProps = item.additionalProperties;
-				if (additionalProps) if (isBoolean(additionalProps)) {
-					const recordType = getPropertyNamesRecordType(item, "unknown");
+				const additionalProps = schemaItem.additionalProperties;
+				if (additionalProps) if (additionalProps === true) {
+					const recordType = getPropertyNamesRecordType(schemaItem, "unknown");
 					if (recordType) {
 						acc.value += "\n}";
 						acc.value += ` & ${recordType}`;
 						acc.useTypeAlias = true;
 					} else {
-						const keyType = getIndexSignatureKey(item);
+						const keyType = getIndexSignatureKey(schemaItem);
 						acc.value += `\n  [key: ${keyType}]: unknown;\n }`;
 					}
 				} else {
@@ -2147,13 +2230,13 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 						name,
 						context
 					});
-					const recordType = getPropertyNamesRecordType(item, resolvedValue.value);
+					const recordType = getPropertyNamesRecordType(schemaItem, resolvedValue.value);
 					if (recordType) {
 						acc.value += "\n}";
 						acc.value += ` & ${recordType}`;
 						acc.useTypeAlias = true;
 					} else {
-						const keyType = getIndexSignatureKey(item);
+						const keyType = getIndexSignatureKey(schemaItem);
 						acc.value += `\n  [key: ${keyType}]: ${resolvedValue.value};\n}`;
 					}
 					acc.dependencies.push(...resolvedValue.dependencies);
@@ -2164,11 +2247,11 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 		}
 		return acc;
 	}
-	const outerAdditionalProps = item.additionalProperties;
-	const readOnlyFlag = item.readOnly;
+	const outerAdditionalProps = schemaItem.additionalProperties;
+	const readOnlyFlag = schemaItem.readOnly;
 	if (outerAdditionalProps) {
-		if (isBoolean(outerAdditionalProps)) {
-			const recordType = getPropertyNamesRecordType(item, "unknown");
+		if (outerAdditionalProps === true) {
+			const recordType = getPropertyNamesRecordType(schemaItem, "unknown");
 			if (recordType) return {
 				value: recordType + nullable,
 				imports: [],
@@ -2181,7 +2264,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 				dependencies: []
 			};
 			return {
-				value: `{ [key: ${getIndexSignatureKey(item)}]: unknown }` + nullable,
+				value: `{ [key: ${getIndexSignatureKey(schemaItem)}]: unknown }` + nullable,
 				imports: [],
 				schemas: [],
 				isEnum: false,
@@ -2197,7 +2280,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			name,
 			context
 		});
-		const recordType = getPropertyNamesRecordType(item, resolvedValue.value);
+		const recordType = getPropertyNamesRecordType(schemaItem, resolvedValue.value);
 		if (recordType) return {
 			value: recordType + nullable,
 			imports: resolvedValue.imports,
@@ -2210,7 +2293,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			dependencies: resolvedValue.dependencies
 		};
 		return {
-			value: `{[key: ${getIndexSignatureKey(item)}]: ${resolvedValue.value}}` + nullable,
+			value: `{[key: ${getIndexSignatureKey(schemaItem)}]: ${resolvedValue.value}}` + nullable,
 			imports: resolvedValue.imports,
 			schemas: resolvedValue.schemas,
 			isEnum: false,
@@ -2221,20 +2304,29 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			dependencies: resolvedValue.dependencies
 		};
 	}
-	const constValue = item.const;
-	if (constValue) return {
-		value: `'${constValue}'`,
-		imports: [],
-		schemas: [],
-		isEnum: false,
-		type: "string",
-		isRef: false,
-		hasReadonlyProps: readOnlyFlag ?? false,
-		dependencies: []
-	};
-	const keyType = item.type === "object" ? getIndexSignatureKey(item) : "string";
-	const recordType = getPropertyNamesRecordType(item, "unknown");
-	if (item.type === "object" && recordType) return {
+	const constValue = schemaItem.const;
+	if (constValue !== void 0) {
+		let type;
+		if (Array.isArray(constValue)) type = "array";
+		else if (constValue === null) type = "null";
+		else if (typeof constValue === "string") type = "string";
+		else if (typeof constValue === "number") type = "number";
+		else if (typeof constValue === "boolean") type = "boolean";
+		else type = "object";
+		return {
+			value: typeof constValue === "string" ? `'${escape(constValue)}'` : JSON.stringify(constValue),
+			imports: [],
+			schemas: [],
+			isEnum: false,
+			type,
+			isRef: false,
+			hasReadonlyProps: readOnlyFlag ?? false,
+			dependencies: []
+		};
+	}
+	const keyType = itemType === "object" ? getIndexSignatureKey(schemaItem) : "string";
+	const recordType = getPropertyNamesRecordType(schemaItem, "unknown");
+	if (itemType === "object" && recordType) return {
 		value: recordType + nullable,
 		imports: [],
 		schemas: [],
@@ -2246,7 +2338,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 		dependencies: []
 	};
 	return {
-		value: (item.type === "object" ? `{ [key: ${keyType}]: unknown }` : "unknown") + nullable,
+		value: (itemType === "object" ? `{ [key: ${keyType}]: unknown }` : "unknown") + nullable,
 		imports: [],
 		schemas: [],
 		isEnum: false,
@@ -2434,7 +2526,7 @@ function normalizeAllOfSchema(schema) {
 	let didMerge = false;
 	const schemaProperties = schema.properties;
 	const schemaRequired = schema.required;
-	const mergedProperties = { ...schemaProperties };
+	const mergedProperties = schemaProperties ? { ...schemaProperties } : {};
 	const mergedRequired = new Set(schemaRequired);
 	const remainingAllOf = [];
 	for (const subSchema of schemaAllOf) {
@@ -2581,15 +2673,18 @@ function combineSchemas({ name, schema, separator, context, nullable, formDataCo
 		};
 	}
 	let resolvedValue;
-	if (normalizedSchema.properties) resolvedValue = getScalar({
+	const normalizedProperties = normalizedSchema.properties;
+	const schemaOneOf = schema.oneOf;
+	const schemaAnyOf = schema.anyOf;
+	if (normalizedProperties) resolvedValue = getScalar({
 		item: Object.fromEntries(Object.entries(normalizedSchema).filter(([key]) => key !== separator)),
 		name,
 		context,
 		formDataContext
 	});
-	else if (separator === "allOf" && (schema.oneOf || schema.anyOf)) {
-		const siblingCombiner = schema.oneOf ? "oneOf" : "anyOf";
-		const siblingSchemas = schema[siblingCombiner];
+	else if (separator === "allOf" && (schemaOneOf || schemaAnyOf)) {
+		const siblingCombiner = schemaOneOf ? "oneOf" : "anyOf";
+		const siblingSchemas = schemaOneOf ?? schemaAnyOf;
 		resolvedValue = combineSchemas({
 			schema: { [siblingCombiner]: siblingSchemas },
 			name,
@@ -2783,8 +2878,8 @@ function getProps({ body, queryParams, params, operationName, headers, context }
 		const parameterTypeName = `${pascal(operationName)}PathParameters`;
 		const name = "pathParams";
 		const namedParametersTypeDefinition = `export type ${parameterTypeName} = {\n ${params.map((property) => property.definition).join(",\n    ")},\n }`;
-		const isOptional = context.output.optionsParamRequired || params.every((param) => param.default);
-		const implementation = `{ ${params.map((property) => property.default ? `${property.name} = ${property.default}` : property.name).join(", ")} }: ${parameterTypeName}${isOptional ? " = {}" : ""}`;
+		const isOptional = context.output.optionsParamRequired || params.every((param) => param.default !== void 0);
+		const implementation = `{ ${params.map((property) => property.default === void 0 ? property.name : `${property.name} = ${stringify(property.default)}`).join(", ")} }: ${parameterTypeName}${isOptional ? " = {}" : ""}`;
 		const destructured = `{ ${params.map((property) => property.name).join(", ")} }`;
 		paramGetterProps = [{
 			type: GetterPropType.NAMED_PATH_PARAMS,
@@ -2949,13 +3044,15 @@ const getRoutePath = (path) => {
 	const matches = /([^{]*){?([\w*_-]*)}?(.*)/.exec(path);
 	if (!matches?.length) return path;
 	const prev = matches[1];
-	const param = sanitize(camel(matches[2]), {
+	const rawParam = matches[2];
+	const rest = matches[3];
+	const param = sanitize(camel(rawParam), {
 		es5keyword: true,
 		underscore: true,
 		dash: true,
 		dot: true
 	});
-	const next = hasParam(matches[3]) ? getRoutePath(matches[3]) : matches[3];
+	const next = hasParam(rest) ? getRoutePath(rest) : rest;
 	return hasParam(path) ? `${prev}\${${param}}${next}` : `${prev}${param}${next}`;
 };
 function getRoute(route) {
@@ -2975,13 +3072,14 @@ function getFullRoute(route, servers, baseUrl) {
 			if (!servers) throw new Error("Orval is configured to use baseUrl from the specifications 'servers' field, but there exist no servers in the specification.");
 			const server = servers.at(Math.min(baseUrl.index ?? 0, servers.length - 1));
 			if (!server) return "";
-			if (!server.variables) return server.url;
-			let url = server.url;
+			const serverUrl = server.url ?? "";
+			if (!server.variables) return serverUrl;
+			let url = serverUrl;
 			const variables = baseUrl.variables;
 			for (const variableKey of Object.keys(server.variables)) {
 				const variable = server.variables[variableKey];
 				if (variables?.[variableKey]) {
-					if (variable.enum && !variable.enum.some((e) => e == variables[variableKey])) throw new Error(`Invalid variable value '${variables[variableKey]}' for variable '${variableKey}' when resolving ${server.url}. Valid values are: ${variable.enum.join(", ")}.`);
+					if (variable.enum && !variable.enum.some((e) => e == variables[variableKey])) throw new Error(`Invalid variable value '${variables[variableKey]}' for variable '${variableKey}' when resolving ${serverUrl}. Valid values are: ${variable.enum.join(", ")}.`);
 					url = url.replaceAll(`{${variableKey}}`, variables[variableKey]);
 				} else url = url.replaceAll(`{${variableKey}}`, String(variable.default));
 			}
@@ -3081,7 +3179,8 @@ function generateDependency({ deps, isAllowSyntheticDefaultImports, dependency,
 }
 function addDependency({ implementation, exports, dependency, projectName, isAllowSyntheticDefaultImports }) {
 	const toAdds = exports.filter((e) => {
-		const searchWords = [e.alias, e.name].filter((p) => p?.length).join("|");
+		const searchWords = [e.alias, e.name].filter((p) => Boolean(p?.length)).map((part) => escapeRegExp(part)).join("|");
+		if (!searchWords) return false;
 		const pattern = new RegExp(String.raw`\b(${searchWords})\b`, "g");
 		return implementation.match(pattern);
 	});
@@ -3124,8 +3223,7 @@ function addDependency({ implementation, exports, dependency, projectName, isAll
 	}).join("\n") + "\n";
 }
 function getLibName(code) {
-	const splitString = code.split(" from ");
-	return splitString[splitString.length - 1].split(";")[0].trim();
+	return (code.split(" from ").at(-1) ?? "").split(";")[0].trim();
 }
 function generateDependencyImports(implementation, imports, projectName, hasSchemaDir, isAllowSyntheticDefaultImports) {
 	const dependencies = imports.map((dep) => addDependency({
@@ -3170,7 +3268,7 @@ function generateModelInline(acc, model) {
 	return acc + `${model}\n`;
 }
 function generateModelsInline(obj) {
-	const schemas = Object.values(obj).flat();
+	const schemas = Array.isArray(obj) ? obj : Object.values(obj).flat();
 	let result = "";
 	for (const { model } of schemas) result = generateModelInline(result, model);
 	return result;
@@ -3334,9 +3432,14 @@ function removeComments(file) {
 * (e.g. observe-mode branches), prefer getAngularFilteredParamsCallExpression +
 * getAngularFilteredParamsHelperBody instead.
 */
-const getAngularFilteredParamsExpression = (paramsExpression, requiredNullableParamKeys = []) => `(() => {
+const getAngularFilteredParamsExpression = (paramsExpression, requiredNullableParamKeys = [], preserveRequiredNullables = false) => {
+	const filteredParamValueType = `string | number | boolean${preserveRequiredNullables ? " | null" : ""} | Array<string | number | boolean>`;
+	const preserveNullableBranch = preserveRequiredNullables ? `    } else if (value === null && requiredNullableParamKeys.has(key)) {
+      filteredParams[key] = value;
+` : "";
+	return `(() => {
   const requiredNullableParamKeys = new Set<string>(${JSON.stringify(requiredNullableParamKeys)});
-  const filteredParams = {} as Record<string, string | number | boolean | null | Array<string | number | boolean>>;
+  const filteredParams: Record<string, ${filteredParamValueType}> = {};
   for (const [key, value] of Object.entries(${paramsExpression})) {
     if (Array.isArray(value)) {
       const filtered = value.filter(
@@ -3345,33 +3448,46 @@ const getAngularFilteredParamsExpression = (paramsExpression, requiredNullablePa
           (typeof item === 'string' ||
             typeof item === 'number' ||
             typeof item === 'boolean'),
-          ) as Array<string | number | boolean>;
+      ) as Array<string | number | boolean>;
       if (filtered.length) {
         filteredParams[key] = filtered;
       }
-    } else if (value === null && requiredNullableParamKeys.has(key)) {
-      filteredParams[key] = value;
-    } else if (
+${preserveNullableBranch}    } else if (
       value != null &&
       (typeof value === 'string' ||
         typeof value === 'number' ||
         typeof value === 'boolean')
     ) {
-      filteredParams[key] = value as string | number | boolean;
+      filteredParams[key] = value;
     }
   }
-  return filteredParams as unknown as Record<string, string | number | boolean | Array<string | number | boolean>>;
+  return filteredParams;
 })()`;
+};
 /**
 * Returns the body of a standalone `filterParams` helper function
 * to be emitted once in the generated file header, replacing the
 * inline IIFE that was previously duplicated in every method.
 */
-const getAngularFilteredParamsHelperBody = () => `function filterParams(
+const getAngularFilteredParamsHelperBody = () => `type AngularHttpParamValue = string | number | boolean | Array<string | number | boolean>;
+type AngularHttpParamValueWithNullable = AngularHttpParamValue | null;
+
+function filterParams(
+  params: Record<string, unknown>,
+  requiredNullableKeys?: ReadonlySet<string>,
+  preserveRequiredNullables?: false,
+): Record<string, AngularHttpParamValue>;
+function filterParams(
   params: Record<string, unknown>,
-  requiredNullableKeys: Set<string> = new Set(),
-): Record<string, string | number | boolean | Array<string | number | boolean>> {
-  const filteredParams: Record<string, string | number | boolean | null | Array<string | number | boolean>> = {};
+  requiredNullableKeys: ReadonlySet<string> | undefined,
+  preserveRequiredNullables: true,
+): Record<string, AngularHttpParamValueWithNullable>;
+function filterParams(
+  params: Record<string, unknown>,
+  requiredNullableKeys: ReadonlySet<string> = new Set(),
+  preserveRequiredNullables = false,
+): Record<string, AngularHttpParamValueWithNullable> {
+  const filteredParams: Record<string, AngularHttpParamValueWithNullable> = {};
   for (const [key, value] of Object.entries(params)) {
     if (Array.isArray(value)) {
       const filtered = value.filter(
@@ -3384,7 +3500,11 @@ const getAngularFilteredParamsHelperBody = () => `function filterParams(
       if (filtered.length) {
         filteredParams[key] = filtered;
       }
-    } else if (value === null && requiredNullableKeys.has(key)) {
+    } else if (
+      preserveRequiredNullables &&
+      value === null &&
+      requiredNullableKeys.has(key)
+    ) {
       filteredParams[key] = value;
     } else if (
       value != null &&
@@ -3392,15 +3512,15 @@ const getAngularFilteredParamsHelperBody = () => `function filterParams(
         typeof value === 'number' ||
         typeof value === 'boolean')
     ) {
-      filteredParams[key] = value as string | number | boolean;
+      filteredParams[key] = value;
     }
   }
-  return filteredParams as Record<string, string | number | boolean | Array<string | number | boolean>>;
+  return filteredParams;
 }`;
 /**
 * Returns a call expression to the `filterParams` helper function.
 */
-const getAngularFilteredParamsCallExpression = (paramsExpression, requiredNullableParamKeys = []) => `filterParams(${paramsExpression}, new Set<string>(${JSON.stringify(requiredNullableParamKeys)}))`;
+const getAngularFilteredParamsCallExpression = (paramsExpression, requiredNullableParamKeys = [], preserveRequiredNullables = false) => `filterParams(${paramsExpression}, new Set<string>(${JSON.stringify(requiredNullableParamKeys)})${preserveRequiredNullables ? ", true" : ""})`;
 function generateBodyOptions(body, isFormData, isFormUrlEncoded) {
 	if (isFormData && body.formData) return "\n      formData,";
 	if (isFormUrlEncoded && body.formUrlEncoded) return "\n      formUrlEncoded,";
@@ -3422,7 +3542,7 @@ function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularO
 	let value = "";
 	if (!isRequestOptions) {
 		if (queryParams) if (isAngular) {
-			const iifeExpr = getAngularFilteredParamsExpression("params ?? {}", requiredNullableQueryParamKeys);
+			const iifeExpr = getAngularFilteredParamsExpression("params ?? {}", requiredNullableQueryParamKeys, !!paramsSerializer);
 			value += paramsSerializer ? `\n        params: ${paramsSerializer.name}(${iifeExpr}),` : `\n        params: ${iifeExpr},`;
 		} else value += "\n        params,";
 		if (headers) value += "\n        headers,";
@@ -3439,7 +3559,7 @@ function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularO
 		if (queryParams) if (isVue) value += "\n        params: {...unref(params), ...options?.params},";
 		else if (isAngular && angularParamsRef) value += `\n        params: ${angularParamsRef},`;
 		else if (isAngular && paramsSerializer) {
-			const callExpr = getAngularFilteredParamsCallExpression("{...params, ...options?.params}", requiredNullableQueryParamKeys);
+			const callExpr = getAngularFilteredParamsCallExpression("{...params, ...options?.params}", requiredNullableQueryParamKeys, true);
 			value += `\n        params: ${paramsSerializer.name}(${callExpr}),`;
 		} else if (isAngular) value += `\n        params: ${getAngularFilteredParamsCallExpression("{...params, ...options?.params}", requiredNullableQueryParamKeys)},`;
 		else value += "\n        params: {...params, ...options?.params},";
@@ -3887,6 +4007,20 @@ function _filteredVerbs(verbs, filters) {
 	});
 }
 
+//#endregion
+//#region src/writers/file.ts
+const TRAILING_WHITESPACE_RE = /[^\S\r\n]+$/gm;
+/**
+* Write generated code to a file, stripping trailing whitespace from each line.
+*
+* Template literals in code generators can produce lines with only whitespace
+* when conditional expressions evaluate to empty strings. This function
+* ensures the output is always clean regardless of generator implementation.
+*/
+async function writeGeneratedFile(filePath, content) {
+	await fs$1.outputFile(filePath, content.replaceAll(TRAILING_WHITESPACE_RE, ""));
+}
+
 //#endregion
 //#region src/writers/schemas.ts
 /**
@@ -3969,19 +4103,26 @@ function getSchemaGroups(schemaPath, schemas, namingConvention, fileExtension) {
 }
 function getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtension) {
 	const canonicalPathMap = /* @__PURE__ */ new Map();
+	const canonicalNameMap = /* @__PURE__ */ new Map();
 	for (const [key, groupSchemas] of Object.entries(schemaGroups)) {
-		const canonicalPath = getPath(schemaPath, conventionName(groupSchemas[0].name, namingConvention), fileExtension);
-		canonicalPathMap.set(key, {
-			importPath: canonicalPath,
+		const canonicalInfo = {
+			importPath: getPath(schemaPath, conventionName(groupSchemas[0].name, namingConvention), fileExtension),
 			name: groupSchemas[0].name
-		});
+		};
+		canonicalPathMap.set(key, canonicalInfo);
+		for (const schema of groupSchemas) canonicalNameMap.set(schema.name, canonicalInfo);
 	}
-	return canonicalPathMap;
+	return {
+		canonicalPathMap,
+		canonicalNameMap
+	};
 }
-function normalizeCanonicalImportPaths(schemas, canonicalPathMap, schemaPath, namingConvention, fileExtension) {
+function normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension) {
 	for (const schema of schemas) schema.imports = schema.imports.map((imp) => {
+		const canonicalByName = canonicalNameMap.get(imp.name);
 		const resolvedImportKey = resolveImportKey(schemaPath, imp.importPath ?? `./${conventionName(imp.name, namingConvention)}`, fileExtension);
-		const canonical = canonicalPathMap.get(resolvedImportKey);
+		const canonicalByPath = canonicalPathMap.get(resolvedImportKey);
+		const canonical = canonicalByName ?? canonicalByPath;
 		if (!canonical?.importPath) return imp;
 		const importPath = removeFileExtension(relativeSafe(schemaPath, canonical.importPath.replaceAll("\\", "/")), fileExtension);
 		return {
@@ -4009,19 +4150,18 @@ function resolveImportKey(schemaPath, importPath, fileExtension) {
 function removeFileExtension(path, fileExtension) {
 	return path.endsWith(fileExtension) ? path.slice(0, path.length - fileExtension.length) : path;
 }
-function getSchema({ schema: { imports, model }, target, header, namingConvention = NamingConvention.CAMEL_CASE }) {
+function getSchema({ schema: { imports, model }, header, namingConvention = NamingConvention.CAMEL_CASE }) {
 	let file = header;
 	file += generateImports({
 		imports: imports.filter((imp) => !model.includes(`type ${imp.alias ?? imp.name} =`) && !model.includes(`interface ${imp.alias ?? imp.name} {`)),
-		target,
 		namingConvention
 	});
 	file += imports.length > 0 ? "\n\n" : "\n";
 	file += model;
 	return file;
 }
-function getPath(path$1, name, fileExtension) {
-	return path.join(path$1, `${name}${fileExtension}`);
+function getPath(path, name, fileExtension) {
+	return nodePath.join(path, `${name}${fileExtension}`);
 }
 function writeModelInline(acc, model) {
 	return acc + `${model}\n`;
@@ -4034,19 +4174,20 @@ function writeModelsInline(array) {
 async function writeSchema({ path, schema, target, namingConvention, fileExtension, header }) {
 	const name = conventionName(schema.name, namingConvention);
 	try {
-		await fs$1.outputFile(getPath(path, name, fileExtension), getSchema({
+		await writeGeneratedFile(getPath(path, name, fileExtension), getSchema({
 			schema,
 			target,
 			header,
 			namingConvention
 		}));
 	} catch (error) {
-		throw new Error(`Oups... 🍻. An Error occurred while writing schema ${name} => ${String(error)}`);
+		throw new Error(`Oups... 🍻. An Error occurred while writing schema ${name} => ${String(error)}`, { cause: error });
 	}
 }
 async function writeSchemas({ schemaPath, schemas, target, namingConvention, fileExtension, header, indexFiles }) {
 	const schemaGroups = getSchemaGroups(schemaPath, schemas, namingConvention, fileExtension);
-	normalizeCanonicalImportPaths(schemas, getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtension), schemaPath, namingConvention, fileExtension);
+	const { canonicalPathMap, canonicalNameMap } = getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtension);
+	normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension);
 	for (const groupSchemas of Object.values(schemaGroups)) {
 		if (groupSchemas.length === 1) {
 			await writeSchema({
@@ -4069,21 +4210,14 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		});
 	}
 	if (indexFiles) {
-		const schemaFilePath = path.join(schemaPath, `index${fileExtension}`);
+		const schemaFilePath = nodePath.join(schemaPath, `index${fileExtension}`);
 		await fs$1.ensureFile(schemaFilePath);
 		const ext = fileExtension.endsWith(".ts") ? fileExtension.slice(0, -3) : fileExtension;
 		const conventionNamesSet = new Set(Object.values(schemaGroups).map((group) => conventionName(group[0].name, namingConvention)));
 		try {
-			const currentExports = [...conventionNamesSet].map((schemaName) => `export * from './${schemaName}${ext}';`).toSorted((a, b) => a.localeCompare(b));
-			const existingExports = (await fs$1.readFile(schemaFilePath, "utf8")).match(/export\s+\*\s+from\s+['"][^'"]+['"]/g)?.map((statement) => {
-				const match = /export\s+\*\s+from\s+['"]([^'"]+)['"]/.exec(statement);
-				if (!match) return;
-				return `export * from '${match[1]}';`;
-			}).filter(Boolean) ?? [];
-			const fileContent = `${header}\n${[...new Set([...existingExports, ...currentExports])].toSorted((a, b) => a.localeCompare(b)).join("\n")}`;
-			await fs$1.writeFile(schemaFilePath, fileContent, { encoding: "utf8" });
+			await writeGeneratedFile(schemaFilePath, `${header}\n${[...conventionNamesSet].map((schemaName) => `export * from './${schemaName}${ext}';`).toSorted((a, b) => a.localeCompare(b)).join("\n")}\n`);
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while writing schema index file ${schemaFilePath} => ${String(error)}`);
+			throw new Error(`Oups... 🍻. An Error occurred while writing schema index file ${schemaFilePath} => ${String(error)}`, { cause: error });
 		}
 	}
 }
@@ -4092,7 +4226,7 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 //#region src/writers/generate-imports-for-builder.ts
 function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 	const isZodSchemaOutput = isObject(output.schemas) && output.schemas.type === "zod";
-	let schemaImports = [];
+	let schemaImports;
 	if (output.indexFiles) schemaImports = isZodSchemaOutput ? [{
 		exports: imports.filter((i) => !i.importPath),
 		dependency: joinSafe(relativeSchemasPath, "index.zod")
@@ -4100,15 +4234,21 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 		exports: imports.filter((i) => !i.importPath),
 		dependency: relativeSchemasPath
 	}];
-	else schemaImports = uniqueBy(imports.filter((i) => !i.importPath), (x) => x.name).map((i) => {
-		const name = conventionName(isZodSchemaOutput ? i.name : i.schemaName ?? i.name, output.namingConvention);
-		const suffix = isZodSchemaOutput ? ".zod" : "";
-		const importExtension = output.fileExtension.replace(/\.ts$/, "") || "";
-		return {
-			exports: [i],
-			dependency: joinSafe(relativeSchemasPath, `${name}${suffix}${importExtension}`)
-		};
-	});
+	else {
+		const importsByDependency = /* @__PURE__ */ new Map();
+		for (const schemaImport of imports.filter((i) => !i.importPath)) {
+			const normalizedName = conventionName(isZodSchemaOutput ? schemaImport.name : schemaImport.schemaName ?? schemaImport.name, output.namingConvention);
+			const suffix = isZodSchemaOutput ? ".zod" : "";
+			const importExtension = output.fileExtension.replace(/\.ts$/, "") || "";
+			const dependency = joinSafe(relativeSchemasPath, `${normalizedName}${suffix}${importExtension}`);
+			if (!importsByDependency.has(dependency)) importsByDependency.set(dependency, []);
+			importsByDependency.get(dependency)?.push(schemaImport);
+		}
+		schemaImports = [...importsByDependency.entries()].map(([dependency, dependencyImports]) => ({
+			dependency,
+			exports: uniqueBy(dependencyImports, (entry) => `${entry.name}|${entry.alias ?? ""}|${String(entry.values)}|${String(entry.default)}`)
+		}));
+	}
 	const otherImports = uniqueBy(imports.filter((i) => !!i.importPath), (x) => x.name + x.importPath).map((i) => {
 		return {
 			exports: [i],
@@ -4239,14 +4379,24 @@ interface TypedResponse<T> extends Response {
 async function writeSingleMode({ builder, output, projectName, header, needSchema }) {
 	try {
 		const { path } = getFileInfo(output.target, {
-			backupFilename: conventionName(builder.info.title, output.namingConvention),
+			backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
 			extension: output.fileExtension
 		});
 		const { imports, importsMock, implementation, implementationMock, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, fetchReviver } = generateTarget(builder, output);
 		let data = header;
 		const schemasPath = output.schemas ? getRelativeImportPath(path, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
-		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, imports.filter((imp) => !importsMock.some((impMock) => imp.name === impMock.name)), schemasPath) : [];
+		const normalizedImports = imports.filter((imp) => {
+			const searchWords = [imp.alias, imp.name].filter((part) => Boolean(part?.length)).map((part) => escapeRegExp(part)).join("|");
+			if (!searchWords) return false;
+			return new RegExp(String.raw`\b(${searchWords})\b`, "g").test(implementation);
+		}).map((imp) => ({ ...imp }));
+		for (const mockImport of importsMock) {
+			const matchingImport = normalizedImports.find((imp) => imp.name === mockImport.name && (imp.alias ?? "") === (mockImport.alias ?? ""));
+			if (!matchingImport) continue;
+			if (!!mockImport.values || !!mockImport.isConstant || !!mockImport.default || !!mockImport.namespaceImport || !!mockImport.syntheticDefaultImport) matchingImport.values = true;
+		}
+		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, normalizedImports, schemasPath) : [];
 		data += builder.imports({
 			client: output.client,
 			implementation,
@@ -4261,7 +4411,7 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 			output
 		});
 		if (output.mock) {
-			const importsMockForBuilder = schemasPath ? generateImportsForBuilder(output, importsMock, schemasPath) : [];
+			const importsMockForBuilder = schemasPath ? generateImportsForBuilder(output, importsMock.filter((impMock) => !normalizedImports.some((imp) => imp.name === impMock.name && (imp.alias ?? "") === (impMock.alias ?? ""))), schemasPath) : [];
 			data += builder.importsMock({
 				implementation: implementationMock,
 				imports: importsMockForBuilder,
@@ -4294,11 +4444,11 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 			data += "\n\n";
 			data += implementationMock;
 		}
-		await fs$1.outputFile(path, data);
+		await writeGeneratedFile(path, data);
 		return [path];
 	} catch (error) {
 		const errorMsg = error instanceof Error ? error.message : "unknown error";
-		throw new Error(`Oups... 🍻. An Error occurred while writing file => ${errorMsg}`);
+		throw new Error(`Oups... 🍻. An Error occurred while writing file => ${errorMsg}`, { cause: error });
 	}
 }
 
@@ -4307,7 +4457,7 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 async function writeSplitMode({ builder, output, projectName, header, needSchema }) {
 	try {
 		const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
-			backupFilename: conventionName(builder.info.title, output.namingConvention),
+			backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
 			extension: output.fileExtension
 		});
 		const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, fetchReviver } = generateTarget(builder, output);
@@ -4338,11 +4488,8 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			isAllowSyntheticDefaultImports,
 			options: isFunction(output.mock) ? void 0 : output.mock
 		});
-		const schemasPath = output.schemas ? void 0 : path.join(dirname, filename + ".schemas" + extension);
-		if (schemasPath && needSchema) {
-			const schemasData = header + generateModelsInline(builder.schemas);
-			await fs$1.outputFile(schemasPath, schemasData);
-		}
+		const schemasPath = output.schemas ? void 0 : nodePath.join(dirname, filename + ".schemas" + extension);
+		if (schemasPath && needSchema) await writeGeneratedFile(schemasPath, header + generateModelsInline(builder.schemas));
 		if (mutators) implementationData += generateMutatorImports({
 			mutators,
 			implementation
@@ -4363,17 +4510,17 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		implementationData += `\n${implementation}`;
 		mockData += `\n${implementationMock}`;
 		const implementationFilename = filename + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-		const implementationPath = path.join(dirname, implementationFilename);
-		await fs$1.outputFile(implementationPath, implementationData);
-		const mockPath = output.mock ? path.join(dirname, filename + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
-		if (mockPath) await fs$1.outputFile(mockPath, mockData);
+		const implementationPath = nodePath.join(dirname, implementationFilename);
+		await writeGeneratedFile(implementationPath, implementationData);
+		const mockPath = output.mock ? nodePath.join(dirname, filename + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
+		if (mockPath) await writeGeneratedFile(mockPath, mockData);
 		return [
 			implementationPath,
 			...schemasPath ? [schemasPath] : [],
 			...mockPath ? [mockPath] : []
 		];
 	} catch (error) {
-		throw new Error(`Oups... 🍻. An Error occurred while splitting => ${String(error)}`);
+		throw new Error(`Oups... 🍻. An Error occurred while splitting => ${String(error)}`, { cause: error });
 	}
 }
 
@@ -4496,13 +4643,13 @@ function generateTargetForTags(builder, options) {
 //#region src/writers/split-tags-mode.ts
 async function writeSplitTagsMode({ builder, output, projectName, header, needSchema }) {
 	const { filename, dirname, extension } = getFileInfo(output.target, {
-		backupFilename: conventionName(builder.info.title, output.namingConvention),
+		backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
 		extension: output.fileExtension
 	});
 	const target = generateTargetForTags(builder, output);
 	const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 	const mockOption = output.mock && !isFunction(output.mock) ? output.mock : void 0;
-	const indexFilePath = mockOption?.indexMockFiles ? path.join(dirname, "index." + getMockFileExtensionByTypeName(mockOption) + extension) : void 0;
+	const indexFilePath = mockOption?.indexMockFiles ? nodePath.join(dirname, "index." + getMockFileExtensionByTypeName(mockOption) + extension) : void 0;
 	if (indexFilePath) await fs$1.outputFile(indexFilePath, "");
 	const tagEntries = Object.entries(target);
 	const generatedFilePathsArray = await Promise.all(tagEntries.map(async ([tag, target]) => {
@@ -4510,7 +4657,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, fetchReviver, formUrlEncoded, paramsSerializer } = target;
 			let implementationData = header;
 			let mockData = header;
-			const importerPath = path.join(dirname, tag, tag + extension);
+			const importerPath = nodePath.join(dirname, tag, tag + extension);
 			const relativeSchemasPath = output.schemas ? getRelativeImportPath(importerPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas";
 			const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 			implementationData += builder.imports({
@@ -4535,11 +4682,8 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				isAllowSyntheticDefaultImports,
 				options: isFunction(output.mock) ? void 0 : output.mock
 			});
-			const schemasPath = output.schemas ? void 0 : path.join(dirname, filename + ".schemas" + extension);
-			if (schemasPath && needSchema) {
-				const schemasData = header + generateModelsInline(builder.schemas);
-				await fs$1.outputFile(schemasPath, schemasData);
-			}
+			const schemasPath = output.schemas ? void 0 : nodePath.join(dirname, filename + ".schemas" + extension);
+			if (schemasPath && needSchema) await writeGeneratedFile(schemasPath, header + generateModelsInline(builder.schemas));
 			if (mutators) implementationData += generateMutatorImports({
 				mutators,
 				implementation,
@@ -4576,17 +4720,17 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			implementationData += `\n${implementation}`;
 			mockData += `\n${implementationMock}`;
 			const implementationFilename = tag + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-			const implementationPath = path.join(dirname, tag, implementationFilename);
-			await fs$1.outputFile(implementationPath, implementationData);
-			const mockPath = output.mock ? path.join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
-			if (mockPath) await fs$1.outputFile(mockPath, mockData);
+			const implementationPath = nodePath.join(dirname, tag, implementationFilename);
+			await writeGeneratedFile(implementationPath, implementationData);
+			const mockPath = output.mock ? nodePath.join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
+			if (mockPath) await writeGeneratedFile(mockPath, mockData);
 			return [
 				implementationPath,
 				...schemasPath ? [schemasPath] : [],
 				...mockPath ? [mockPath] : []
 			];
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while splitting tag ${tag} => ${String(error)}`);
+			throw new Error(`Oups... 🍻. An Error occurred while splitting tag ${tag} => ${String(error)}`, { cause: error });
 		}
 	}));
 	if (indexFilePath && mockOption) {
@@ -4596,14 +4740,14 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 		}).join("");
 		await fs$1.appendFile(indexFilePath, indexContent);
 	}
-	return [...indexFilePath ? [indexFilePath] : [], ...generatedFilePathsArray.flat()];
+	return [...new Set([...indexFilePath ? [indexFilePath] : [], ...generatedFilePathsArray.flat()])];
 }
 
 //#endregion
 //#region src/writers/tags-mode.ts
 async function writeTagsMode({ builder, output, projectName, header, needSchema }) {
 	const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
-		backupFilename: conventionName(builder.info.title, output.namingConvention),
+		backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
 		extension: output.fileExtension
 	});
 	const target = generateTargetForTags(builder, output);
@@ -4613,7 +4757,17 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, fetchReviver, paramsSerializer } = target;
 			let data = header;
 			const schemasPathRelative = output.schemas ? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
-			const importsForBuilder = generateImportsForBuilder(output, imports.filter((imp) => !importsMock.some((impMock) => imp.name === impMock.name)), schemasPathRelative);
+			const normalizedImports = imports.filter((imp) => {
+				const searchWords = [imp.alias, imp.name].filter((part) => Boolean(part?.length)).map((part) => escapeRegExp(part)).join("|");
+				if (!searchWords) return false;
+				return new RegExp(String.raw`\b(${searchWords})\b`, "g").test(implementation);
+			}).map((imp) => ({ ...imp }));
+			for (const mockImport of importsMock) {
+				const matchingImport = normalizedImports.find((imp) => imp.name === mockImport.name && (imp.alias ?? "") === (mockImport.alias ?? ""));
+				if (!matchingImport) continue;
+				if (!!mockImport.values || !!mockImport.isConstant || !!mockImport.default || !!mockImport.namespaceImport || !!mockImport.syntheticDefaultImport) matchingImport.values = true;
+			}
+			const importsForBuilder = generateImportsForBuilder(output, normalizedImports, schemasPathRelative);
 			data += builder.imports({
 				client: output.client,
 				implementation,
@@ -4628,7 +4782,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 				output
 			});
 			if (output.mock) {
-				const importsMockForBuilder = generateImportsForBuilder(output, importsMock, schemasPathRelative);
+				const importsMockForBuilder = generateImportsForBuilder(output, importsMock.filter((impMock) => !normalizedImports.some((imp) => imp.name === impMock.name && (imp.alias ?? "") === (impMock.alias ?? ""))), schemasPathRelative);
 				data += builder.importsMock({
 					implementation: implementationMock,
 					imports: importsMockForBuilder,
@@ -4638,11 +4792,8 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 					options: isFunction(output.mock) ? void 0 : output.mock
 				});
 			}
-			const schemasPath = output.schemas ? void 0 : path.join(dirname, filename + ".schemas" + extension);
-			if (schemasPath && needSchema) {
-				const schemasData = header + generateModelsInline(builder.schemas);
-				await fs$1.outputFile(schemasPath, schemasData);
-			}
+			const schemasPath = output.schemas ? void 0 : nodePath.join(dirname, filename + ".schemas" + extension);
+			if (schemasPath && needSchema) await writeGeneratedFile(schemasPath, header + generateModelsInline(builder.schemas));
 			if (mutators) data += generateMutatorImports({
 				mutators,
 				implementation
@@ -4666,15 +4817,15 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 				data += "\n\n";
 				data += implementationMock;
 			}
-			const implementationPath = path.join(dirname, `${kebab(tag)}${extension}`);
-			await fs$1.outputFile(implementationPath, data);
+			const implementationPath = nodePath.join(dirname, `${kebab(tag)}${extension}`);
+			await writeGeneratedFile(implementationPath, data);
 			return [implementationPath, ...schemasPath ? [schemasPath] : []];
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${String(error)}`);
+			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${String(error)}`, { cause: error });
 		}
 	}))).flat();
 }
 
 //#endregion
-export { BODY_TYPE_NAME, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, filterByContentType, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getAngularFilteredParamsCallExpression, getAngularFilteredParamsExpression, getAngularFilteredParamsHelperBody, getArray, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSuccessResponseType, getTypedResponse, isBinaryContentType, isBoolean, isDirectory, isFunction, isModule, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, isVerbose, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, logVerbose, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, setVerbose, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
+export { BODY_TYPE_NAME, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, escapeRegExp, filterByContentType, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getAngularFilteredParamsCallExpression, getAngularFilteredParamsExpression, getAngularFilteredParamsHelperBody, getArray, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSuccessResponseType, getTypedResponse, isBinaryContentType, isBoolean, isDirectory, isFunction, isModule, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, isVerbose, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, logVerbose, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, setVerbose, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
 //# sourceMappingURL=index.mjs.map