@orval/core 8.4.2 → 8.5.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as __export } from "./chunk-1-as6MWF.mjs";
+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";
@@ -9,7 +9,7 @@ import { pathToFileURL } from "node:url";
 import fs, { existsSync, readFileSync } from "node:fs";
 import { globby } from "globby";
 import readline from "node:readline";
-import chalk from "chalk";
+import { styleText } from "node:util";
 import { isDereferenced } from "@scalar/openapi-types/helpers";
 import fs$1 from "fs-extra";
 import { Parser } from "acorn";
@@ -195,10 +195,10 @@ const regexps = {
 	sentence: new RegExp(String.raw`(^\s*|[\?\!\.]+"?\s+"?|,\s+")([` + lowers + "])", "g"),
 	improper: new RegExp(String.raw`\b(` + impropers + String.raw`)\b`, "g"),
 	relax: new RegExp("([^" + uppers + "])([" + uppers + "]*)([" + uppers + "])(?=[^" + uppers + "]|$)", "g"),
-	upper: /* @__PURE__ */ new RegExp("^[^" + lowers + "]+$"),
+	upper: new RegExp("^[^" + lowers + "]+$"),
 	hole: /[^\s]\s[^\s]/,
 	apostrophe: /'/g,
-	room: /* @__PURE__ */ new RegExp("[" + symbols + "]")
+	room: new RegExp("[" + symbols + "]")
 };
 const deapostrophe = (s) => {
 	return s.replace(regexps.apostrophe, "");
@@ -350,11 +350,11 @@ function getFormDataFieldFileType(resolvedSchema, partContentType) {
 * filterByContentType(types, { exclude: ['text/xml'] });
 * ```
 */
-function filterByContentType(items, filter$1) {
-	if (!filter$1) return items;
+function filterByContentType(items, filter) {
+	if (!filter) return items;
 	return items.filter((item) => {
-		const shouldInclude = !filter$1.include || filter$1.include.includes(item.contentType);
-		const shouldExclude = filter$1.exclude?.includes(item.contentType) ?? false;
+		const shouldInclude = !filter.include || filter.include.includes(item.contentType);
+		const shouldExclude = filter.exclude?.includes(item.contentType) ?? false;
 		return shouldInclude && !shouldExclude;
 	});
 }
@@ -364,13 +364,13 @@ function filterByContentType(items, filter$1) {
 const filter = process.env.ORVAL_DEBUG_FILTER;
 const DEBUG = process.env.DEBUG;
 function createDebugger(ns, options = {}) {
-	const log$1 = debug(ns);
+	const log = debug(ns);
 	const { onlyWhenFocused } = options;
 	const focus = isString(onlyWhenFocused) ? onlyWhenFocused : ns;
 	return (msg, ...args) => {
 		if (filter && !msg.includes(filter)) return;
 		if (onlyWhenFocused && !DEBUG?.includes(focus)) return;
-		log$1(msg, ...args);
+		log(msg, ...args);
 	};
 }
 
@@ -381,13 +381,13 @@ const replacement = String.raw`*\/`;
 const regex$1 = new RegExp(search, "g");
 function jsDoc(schema, tryOneLine = false, context) {
 	if (context?.output.override.jsDoc) {
-		const { filter: filter$1 } = context.output.override.jsDoc;
-		if (filter$1) return keyValuePairsToJsDoc(filter$1(schema));
+		const { filter } = context.output.override.jsDoc;
+		if (filter) return keyValuePairsToJsDoc(filter(schema));
 	}
 	const { description, deprecated, summary, minLength, maxLength, minimum, maximum, exclusiveMinimum, exclusiveMaximum, minItems, maxItems, pattern } = schema;
 	const isNullable = schema.type === "null" || Array.isArray(schema.type) && schema.type.includes("null");
 	const lines = (Array.isArray(description) ? description.filter((d) => !d.includes("eslint-disable")) : [description ?? ""]).map((line) => line.replaceAll(regex$1, replacement));
-	const count$1 = [
+	const count = [
 		description,
 		deprecated,
 		summary,
@@ -402,8 +402,8 @@ function jsDoc(schema, tryOneLine = false, context) {
 		isNullable ? "null" : "",
 		pattern
 	].filter(Boolean).length;
-	if (!count$1) return "";
-	const oneLine = count$1 === 1 && tryOneLine;
+	if (!count) return "";
+	const oneLine = count === 1 && tryOneLine;
 	const eslintDisable = Array.isArray(description) ? description.find((d) => d.includes("eslint-disable"))?.replaceAll(regex$1, replacement) : void 0;
 	let doc = `${eslintDisable ? `/* ${eslintDisable} */\n` : ""}/**`;
 	if (description) {
@@ -474,8 +474,8 @@ async function dynamicImport(toImport, from = process.cwd(), takeDefault = true)
 
 //#endregion
 //#region src/utils/extension.ts
-function getExtension(path$2) {
-	return path$2.toLowerCase().includes(".yaml") || path$2.toLowerCase().includes(".yml") ? "yaml" : "json";
+function getExtension(path) {
+	return path.toLowerCase().includes(".yaml") || path.toLowerCase().includes(".yml") ? "yaml" : "json";
 }
 
 //#endregion
@@ -562,7 +562,7 @@ const logVerbose = (...args) => {
 	if (_verbose) log(...args);
 };
 function startMessage({ name, version, description }) {
-	return `🍻 ${chalk.cyan.bold(name)} ${chalk.green(`v${version}`)}${description ? ` - ${description}` : ""}`;
+	return `🍻 ${styleText(["cyan", "bold"], name)} ${styleText("green", `v${version}`)}${description ? ` - ${description}` : ""}`;
 }
 function logError(err, tag) {
 	let message = "";
@@ -573,17 +573,17 @@ function logError(err, tag) {
 			message += `\n  Cause: ${causeMsg}`;
 		}
 	} else message = String(err);
-	log(chalk.red([
+	log(styleText("red", [
 		"🛑",
 		tag ? `${tag} -` : void 0,
 		message
 	].filter(Boolean).join(" ")));
 }
 function mismatchArgsMessage(mismatchArgs) {
-	log(chalk.yellow(`${mismatchArgs.join(", ")} ${mismatchArgs.length === 1 ? "is" : "are"} not defined in your configuration!`));
+	log(styleText("yellow", `${mismatchArgs.join(", ")} ${mismatchArgs.length === 1 ? "is" : "are"} not defined in your configuration!`));
 }
 function createSuccessMessage(backend) {
-	log(`🎉 ${backend ? `${chalk.green(backend)} - ` : ""}Your OpenAPI spec has been converted into ready to use orval!`);
+	log(`🎉 ${backend ? `${styleText("green", backend)} - ` : ""}Your OpenAPI spec has been converted into ready to use orval!`);
 }
 const LogLevels = {
 	silent: 0,
@@ -605,24 +605,24 @@ function createLogger(level = "info", options = {}) {
 	const { prefix = "[vite]", allowClearScreen = true } = options;
 	const thresh = LogLevels[level];
 	const clear = allowClearScreen && process.stdout.isTTY && !process.env.CI ? clearScreen : () => {};
-	function output(type, msg, options$1 = {}) {
+	function output(type, msg, options = {}) {
 		if (thresh >= LogLevels[type]) {
 			const method = type === "info" ? "log" : type;
 			const format = () => {
-				if (options$1.timestamp) {
-					const tag = type === "info" ? chalk.cyan.bold(prefix) : type === "warn" ? chalk.yellow.bold(prefix) : chalk.red.bold(prefix);
-					return `${chalk.dim((/* @__PURE__ */ new Date()).toLocaleTimeString())} ${tag} ${msg}`;
+				if (options.timestamp) {
+					const tag = type === "info" ? styleText(["cyan", "bold"], prefix) : type === "warn" ? styleText(["yellow", "bold"], prefix) : styleText(["red", "bold"], prefix);
+					return `${styleText("dim", (/* @__PURE__ */ new Date()).toLocaleTimeString())} ${tag} ${msg}`;
 				} else return msg;
 			};
 			if (type === lastType && msg === lastMsg) {
 				sameCount++;
 				clear();
-				console[method](format(), chalk.yellow(`(x${sameCount + 1})`));
+				console[method](format(), styleText("yellow", `(x${sameCount + 1})`));
 			} else {
 				sameCount = 0;
 				lastMsg = msg;
 				lastType = type;
-				if (options$1.clear) clear();
+				if (options.clear) clear();
 				console[method](format());
 			}
 		}
@@ -677,7 +677,7 @@ function count(str = "", key) {
 
 //#endregion
 //#region src/utils/path.ts
-var path_exports = /* @__PURE__ */ __export({
+var path_exports = /* @__PURE__ */ __exportAll({
 	basename: () => basename,
 	dirname: () => dirname,
 	extname: () => extname,
@@ -704,8 +704,8 @@ const { join, resolve, extname, dirname, basename, isAbsolute } = path$1;
 function relativeSafe(from, to) {
 	return normalizeSafe(`.${separator}${path$1.relative(from, to)}`);
 }
-function getSchemaFileName(path$2) {
-	return path$2.replace(`.${getExtension(path$2)}`, "").slice(path$2.lastIndexOf("/") + 1);
+function getSchemaFileName(path) {
+	return path.replace(`.${getExtension(path)}`, "").slice(path.lastIndexOf("/") + 1);
 }
 const separator = "/";
 const toUnix = function(value) {
@@ -802,13 +802,13 @@ function stringify(data) {
 	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(", ")}]`;
-	const entries$1 = Object.entries(data);
+	const entries = Object.entries(data);
 	let result = "";
-	for (const [index, [key, value]] of entries$1.entries()) {
+	for (const [index, [key, value]] of entries.entries()) {
 		const strValue = stringify(value);
-		if (entries$1.length === 1) result = `{ ${key}: ${strValue}, }`;
+		if (entries.length === 1) result = `{ ${key}: ${strValue}, }`;
 		else if (!index) result = `{ ${key}: ${strValue}, `;
-		else if (entries$1.length - 1 === index) result += `${key}: ${strValue}, }`;
+		else if (entries.length - 1 === index) result += `${key}: ${strValue}, }`;
 		else result += `${key}: ${strValue}, `;
 	}
 	return result;
@@ -858,11 +858,11 @@ function sanitize(value, options) {
 * toObjectString(['a', 'b', 'c'])
 * // returns "a,\n    b,\n    c,"
 */
-function toObjectString(props, path$2) {
+function toObjectString(props, path) {
 	if (props.length === 0) return "";
-	return (isString(path$2) ? props.map((prop$1) => {
-		let obj = prop$1;
-		for (const key of path$2.split(".")) obj = obj && (isObject(obj) || Array.isArray(obj)) ? obj[key] : void 0;
+	return (isString(path) ? props.map((prop) => {
+		let obj = prop;
+		for (const key of path.split(".")) obj = obj && (isObject(obj) || Array.isArray(obj)) ? obj[key] : void 0;
 		return obj;
 	}) : props).join(",\n    ") + ",";
 }
@@ -1134,7 +1134,7 @@ const RefComponentSuffix = {
 	parameters: "Parameter",
 	requestBodies: "Body"
 };
-const regex = new RegExp("~1", "g");
+const regex = /* @__PURE__ */ new RegExp("~1", "g");
 /**
 * Return the output type from the $ref
 *
@@ -1488,12 +1488,12 @@ function getResReqContentTypes({ mediaType, propName, context, isFormData, conte
 function getResReqTypes(responsesOrRequests, name, context, defaultType = "unknown", uniqueKey = (item) => item.value) {
 	return uniqueBy(responsesOrRequests.filter(([, res]) => Boolean(res)).map(([key, res]) => {
 		if (isReference(res)) {
-			const { schema: bodySchema, imports: [{ name: name$1, schemaName }] } = resolveRef(res, context);
+			const { schema: bodySchema, imports: [{ name, schemaName }] } = resolveRef(res, context);
 			const firstEntry = Object.entries(bodySchema.content ?? {}).at(0);
 			if (!firstEntry) return [{
-				value: name$1,
+				value: name,
 				imports: [{
-					name: name$1,
+					name,
 					schemaName
 				}],
 				schemas: [],
@@ -1511,9 +1511,9 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 			const isFormData = formDataContentTypes.has(contentType);
 			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
 			if (!isFormData && !isFormUrlEncoded || !mediaType.schema) return [{
-				value: name$1,
+				value: name,
 				imports: [{
-					name: name$1,
+					name,
 					schemaName
 				}],
 				schemas: [],
@@ -1528,7 +1528,7 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				contentType
 			}];
 			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
-				name: name$1,
+				name,
 				schemaObject: mediaType.schema,
 				context,
 				isRequestBodyOptional: "required" in bodySchema && bodySchema.required === false,
@@ -1536,7 +1536,7 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				encoding: mediaType.encoding
 			}) : void 0;
 			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
-				name: name$1,
+				name,
 				schemaObject: mediaType.schema,
 				context,
 				isRequestBodyOptional: "required" in bodySchema && bodySchema.required === false,
@@ -1549,9 +1549,9 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				context
 			});
 			return [{
-				value: name$1,
+				value: name,
 				imports: [{
-					name: name$1,
+					name,
 					schemaName
 				}, ...additionalImports],
 				schemas: [],
@@ -1718,13 +1718,13 @@ function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequest
 		if (combinedSchemas) {
 			const shouldCast = !!getSchemaOneOf(schema) || !!getSchemaAnyOf(schema);
 			const combinedSchemasFormData = combinedSchemas.map((subSchema) => {
-				const { schema: combinedSchema, imports: imports$1 } = resolveRef(subSchema, context);
+				const { schema: combinedSchema, imports } = resolveRef(subSchema, context);
 				let newPropName = propName;
 				let newPropDefinition = "";
-				if (shouldCast && imports$1[0]) {
-					additionalImports.push(imports$1[0]);
-					newPropName = `${propName}${pascal(imports$1[0].name)}`;
-					newPropDefinition = `const ${newPropName} = (${propName} as ${imports$1[0].name}${isRequestBodyOptional ? " | undefined" : ""});\n`;
+				if (shouldCast && imports[0]) {
+					additionalImports.push(imports[0]);
+					newPropName = `${propName}${pascal(imports[0].name)}`;
+					newPropDefinition = `const ${newPropName} = (${propName} as ${imports[0].name}${isRequestBodyOptional ? " | undefined" : ""});\n`;
 				}
 				return newPropDefinition + resolveSchemaPropertiesToFormData({
 					schema: combinedSchema,
@@ -1818,8 +1818,8 @@ function resolveSchemaPropertiesToFormData({ schema, variableName, propName, con
 				if (!hasNonPrimitiveChild) formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => ${variableName}.append(\`${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}]\`, ${valueStr}));\n`;
 			} else formDataValue = `${valueKey}.forEach(value => ${variableName}.append(\`${keyPrefix}${key}${context.output.override.formData.arrayHandling === FormDataArrayHandling.SERIALIZE_WITH_BRACKETS ? "[]" : ""}\`, ${valueStr}));\n`;
 		} else if ((() => {
-			const propType$1 = getSchemaType(property);
-			return propType$1 === "number" || Array.isArray(propType$1) && propType$1.includes("number") || propType$1 === "integer" || Array.isArray(propType$1) && propType$1.includes("integer") || propType$1 === "boolean" || Array.isArray(propType$1) && propType$1.includes("boolean");
+			const propType = getSchemaType(property);
+			return propType === "number" || Array.isArray(propType) && propType.includes("number") || propType === "integer" || Array.isArray(propType) && propType.includes("integer") || propType === "boolean" || Array.isArray(propType) && propType.includes("boolean");
 		})()) formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey}.toString())\n`;
 		else formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
 		let existSubSchemaNullable = false;
@@ -1864,8 +1864,8 @@ function resolveSchemaPropertiesToFormData({ schema, variableName, propName, con
 //#region src/getters/body.ts
 function getBody({ requestBody, operationName, context, contentType }) {
 	const filteredBodyTypes = filterByContentType(getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context), contentType);
-	const imports = filteredBodyTypes.flatMap(({ imports: imports$1 }) => imports$1);
-	const schemas = filteredBodyTypes.flatMap(({ schemas: schemas$1 }) => schemas$1);
+	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;
 	let implementation = generalJSTypesWithArray.includes(definition.toLowerCase()) || filteredBodyTypes.length > 1 ? camel(operationName) + context.output.override.components.requestBodies.suffix : camel(definition);
@@ -1963,16 +1963,16 @@ function getPropertyNamesRecordType(item, valueType) {
 */
 function getObject({ item, name, context, nullable, formDataContext }) {
 	if (isReference(item)) {
-		const { name: name$1 } = getRefInfo(item.$ref, context);
+		const { name } = getRefInfo(item.$ref, context);
 		return {
-			value: name$1 + nullable,
-			imports: [{ name: name$1 }],
+			value: name + nullable,
+			imports: [{ name }],
 			schemas: [],
 			isEnum: false,
 			type: "object",
 			isRef: true,
 			hasReadonlyProps: item.readOnly ?? false,
-			dependencies: [name$1],
+			dependencies: [name],
 			example: item.example,
 			examples: resolveExampleRefs(item.examples, context)
 		};
@@ -2001,8 +2001,8 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 	}
 	const itemProperties = item.properties;
 	if (itemProperties && Object.entries(itemProperties).length > 0) {
-		const entries$1 = Object.entries(itemProperties);
-		if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries$1.sort((a, b) => {
+		const entries = Object.entries(itemProperties);
+		if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries.sort((a, b) => {
 			return a[0].localeCompare(b[0]);
 		});
 		const acc = {
@@ -2020,7 +2020,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			examples: resolveExampleRefs(item.examples, context)
 		};
 		const itemRequired = item.required;
-		for (const [index, [key, schema]] of entries$1.entries()) {
+		for (const [index, [key, schema]] of entries.entries()) {
 			const isRequired = (Array.isArray(itemRequired) ? itemRequired : []).includes(key);
 			let propName = "";
 			if (name) {
@@ -2043,12 +2043,12 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			if (!index) acc.value += "{";
 			const doc = jsDoc(schema, true, context);
 			if (isReadOnly ?? false) acc.hasReadonlyProps = true;
-			const constValue$1 = "const" in schema ? schema.const : void 0;
-			const hasConst = constValue$1 !== void 0;
+			const constValue = "const" in schema ? schema.const : void 0;
+			const hasConst = constValue !== void 0;
 			let constLiteral;
 			if (!hasConst) constLiteral = void 0;
-			else if (isString(constValue$1)) constLiteral = `'${escape(constValue$1)}'`;
-			else constLiteral = JSON.stringify(constValue$1);
+			else if (isString(constValue)) constLiteral = `'${escape(constValue)}'`;
+			else constLiteral = JSON.stringify(constValue);
 			const needsValueImport = hasConst && (resolvedValue.isEnum || resolvedValue.type === "enum");
 			const aliasedImports = needsValueImport ? resolvedValue.imports.map((imp) => ({
 				...imp,
@@ -2069,34 +2069,34 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			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);
-			if (entries$1.length - 1 === index) {
+			if (entries.length - 1 === index) {
 				const additionalProps = item.additionalProperties;
 				if (additionalProps) if (isBoolean(additionalProps)) {
-					const recordType$1 = getPropertyNamesRecordType(item, "unknown");
-					if (recordType$1) {
+					const recordType = getPropertyNamesRecordType(item, "unknown");
+					if (recordType) {
 						acc.value += "\n}";
-						acc.value += ` & ${recordType$1}`;
+						acc.value += ` & ${recordType}`;
 						acc.useTypeAlias = true;
 					} else {
-						const keyType$1 = getIndexSignatureKey(item);
-						acc.value += `\n  [key: ${keyType$1}]: unknown;\n }`;
+						const keyType = getIndexSignatureKey(item);
+						acc.value += `\n  [key: ${keyType}]: unknown;\n }`;
 					}
 				} else {
-					const resolvedValue$1 = resolveValue({
+					const resolvedValue = resolveValue({
 						schema: additionalProps,
 						name,
 						context
 					});
-					const recordType$1 = getPropertyNamesRecordType(item, resolvedValue$1.value);
-					if (recordType$1) {
+					const recordType = getPropertyNamesRecordType(item, resolvedValue.value);
+					if (recordType) {
 						acc.value += "\n}";
-						acc.value += ` & ${recordType$1}`;
+						acc.value += ` & ${recordType}`;
 						acc.useTypeAlias = true;
 					} else {
-						const keyType$1 = getIndexSignatureKey(item);
-						acc.value += `\n  [key: ${keyType$1}]: ${resolvedValue$1.value};\n}`;
+						const keyType = getIndexSignatureKey(item);
+						acc.value += `\n  [key: ${keyType}]: ${resolvedValue.value};\n}`;
 					}
-					acc.dependencies.push(...resolvedValue$1.dependencies);
+					acc.dependencies.push(...resolvedValue.dependencies);
 				}
 				else acc.value += "\n}";
 				acc.value += nullable;
@@ -2108,9 +2108,9 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 	const readOnlyFlag = item.readOnly;
 	if (outerAdditionalProps) {
 		if (isBoolean(outerAdditionalProps)) {
-			const recordType$2 = getPropertyNamesRecordType(item, "unknown");
-			if (recordType$2) return {
-				value: recordType$2 + nullable,
+			const recordType = getPropertyNamesRecordType(item, "unknown");
+			if (recordType) return {
+				value: recordType + nullable,
 				imports: [],
 				schemas: [],
 				isEnum: false,
@@ -2137,9 +2137,9 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			name,
 			context
 		});
-		const recordType$1 = getPropertyNamesRecordType(item, resolvedValue.value);
-		if (recordType$1) return {
-			value: recordType$1 + nullable,
+		const recordType = getPropertyNamesRecordType(item, resolvedValue.value);
+		if (recordType) return {
+			value: recordType + nullable,
 			imports: resolvedValue.imports,
 			schemas: resolvedValue.schemas,
 			isEnum: false,
@@ -2215,6 +2215,8 @@ function getScalar({ item, name, context, formDataContext }) {
 	const schemaConst = item.const;
 	const schemaFormat = item.format;
 	const schemaNullable = item.nullable;
+	const schemaContentMediaType = item.contentMediaType;
+	const schemaContentEncoding = item.contentEncoding;
 	const nullable = isArray(schemaType) && schemaType.includes("null") || schemaNullable === true ? " | null" : "";
 	const enumItems = schemaEnum?.filter((enumItem) => enumItem !== null);
 	let itemType = schemaType;
@@ -2290,7 +2292,7 @@ function getScalar({ item, name, context, formDataContext }) {
 			else if (formDataContext?.atPart) {
 				const fileType = getFormDataFieldFileType(item, formDataContext.partContentType);
 				if (fileType) value = fileType === "binary" ? "Blob" : "Blob | string";
-			}
+			} else if (schemaContentMediaType === "application/octet-stream" && !schemaContentEncoding) value = "Blob";
 			if (context.output.override.useDates && (schemaFormat === "date" || schemaFormat === "date-time")) value = "Date";
 			value += nullable;
 			if (schemaConst) value = `'${schemaConst}'`;
@@ -2380,7 +2382,7 @@ function normalizeAllOfSchema(schema) {
 			didMerge = true;
 			if (subSchema.properties) Object.assign(mergedProperties, subSchema.properties);
 			const subRequired = subSchema.required;
-			if (subRequired) for (const prop$1 of subRequired) mergedRequired.add(prop$1);
+			if (subRequired) for (const prop of subRequired) mergedRequired.add(prop);
 			continue;
 		}
 		remainingAllOf.push(subSchema);
@@ -2393,9 +2395,9 @@ function normalizeAllOfSchema(schema) {
 		...remainingAllOf.length > 0 && { allOf: remainingAllOf }
 	};
 }
-function combineValues({ resolvedData, resolvedValue, separator: separator$1, context, parentSchema }) {
+function combineValues({ resolvedData, resolvedValue, separator, context, parentSchema }) {
 	if (resolvedData.isEnum.every(Boolean)) return `${resolvedData.values.join(` | `)}${resolvedValue ? ` | ${resolvedValue.value}` : ""}`;
-	if (separator$1 === "allOf") {
+	if (separator === "allOf") {
 		let resolvedDataValue = resolvedData.values.map((v) => v.includes(" | ") ? `(${v})` : v).join(` & `);
 		if (resolvedData.originalSchema.length > 0 && resolvedValue) {
 			const discriminatedPropertySchemas = resolvedData.originalSchema.filter((s) => {
@@ -2406,14 +2408,14 @@ function combineValues({ resolvedData, resolvedValue, separator: separator$1, co
 		}
 		const resolvedValueStr = resolvedValue?.value.includes(" | ") ? `(${resolvedValue.value})` : resolvedValue?.value;
 		const joined = `${resolvedDataValue}${resolvedValue ? ` & ${resolvedValueStr}` : ""}`;
-		const overrideRequiredProperties = resolvedData.requiredProperties.filter((prop$1) => !resolvedData.originalSchema.some((schema) => {
+		const overrideRequiredProperties = resolvedData.requiredProperties.filter((prop) => !resolvedData.originalSchema.some((schema) => {
 			const props = schema?.properties;
 			const req = schema?.required;
-			return props?.[prop$1] && req?.includes(prop$1);
+			return props?.[prop] && req?.includes(prop);
 		}) && !(() => {
 			const parentProps = parentSchema?.properties;
 			const parentReq = parentSchema?.required;
-			return !!(parentProps?.[prop$1] && parentReq?.includes(prop$1));
+			return !!(parentProps?.[prop] && parentReq?.includes(prop));
 		})());
 		if (overrideRequiredProperties.length > 0) return `${joined} & Required<Pick<${joined}, '${overrideRequiredProperties.join("' | '")}'>>`;
 		return joined;
@@ -2435,9 +2437,9 @@ function combineValues({ resolvedData, resolvedValue, separator: separator$1, co
 	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
 	return values.join(" | ");
 }
-function combineSchemas({ name, schema, separator: separator$1, context, nullable, formDataContext }) {
-	const normalizedSchema = separator$1 === "allOf" && !context.output.override.aliasCombinedTypes && !schema.oneOf && !schema.anyOf ? normalizeAllOfSchema(schema) : schema;
-	const items = normalizedSchema[separator$1] ?? [];
+function combineSchemas({ name, schema, separator, context, nullable, formDataContext }) {
+	const normalizedSchema = separator === "allOf" && !context.output.override.aliasCombinedTypes && !schema.oneOf && !schema.anyOf ? normalizeAllOfSchema(schema) : schema;
+	const items = normalizedSchema[separator] ?? [];
 	const resolvedData = {
 		values: [],
 		imports: [],
@@ -2451,16 +2453,16 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 		hasReadonlyProps: false,
 		example: schema.example,
 		examples: resolveExampleRefs(schema.examples, context),
-		requiredProperties: separator$1 === "allOf" ? schema.required ?? [] : []
+		requiredProperties: separator === "allOf" ? schema.required ?? [] : []
 	};
 	for (const subSchema of items) {
 		let propName;
 		if (context.output.override.aliasCombinedTypes) {
-			propName = name ? name + pascal(separator$1) : void 0;
+			propName = name ? name + pascal(separator) : void 0;
 			if (propName && resolvedData.schemas.length > 0) propName = propName + pascal(getNumberWord(resolvedData.schemas.length + 1));
 		}
-		if (separator$1 === "allOf" && isSchema(subSchema) && subSchema.required) resolvedData.requiredProperties.push(...subSchema.required);
-		const resolvedValue$1 = resolveObject({
+		if (separator === "allOf" && isSchema(subSchema) && subSchema.required) resolvedData.requiredProperties.push(...subSchema.required);
+		const resolvedValue = resolveObject({
 			schema: subSchema,
 			propName,
 			combined: true,
@@ -2470,24 +2472,24 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 		const aliasedImports = getAliasedImports({
 			context,
 			name,
-			resolvedValue: resolvedValue$1
+			resolvedValue
 		});
 		const value = getImportAliasForRefOrValue({
 			context,
-			resolvedValue: resolvedValue$1,
+			resolvedValue,
 			imports: aliasedImports
 		});
 		resolvedData.values.push(value);
 		resolvedData.imports.push(...aliasedImports);
-		resolvedData.schemas.push(...resolvedValue$1.schemas);
-		resolvedData.dependencies.push(...resolvedValue$1.dependencies);
-		resolvedData.isEnum.push(resolvedValue$1.isEnum);
-		resolvedData.types.push(resolvedValue$1.type);
-		resolvedData.isRef.push(resolvedValue$1.isRef);
-		resolvedData.originalSchema.push(resolvedValue$1.originalSchema);
-		if (resolvedValue$1.hasReadonlyProps) resolvedData.hasReadonlyProps = true;
-		const originalProps = resolvedValue$1.originalSchema.properties;
-		if (resolvedValue$1.type === "object" && originalProps) resolvedData.allProperties.push(...Object.keys(originalProps));
+		resolvedData.schemas.push(...resolvedValue.schemas);
+		resolvedData.dependencies.push(...resolvedValue.dependencies);
+		resolvedData.isEnum.push(resolvedValue.isEnum);
+		resolvedData.types.push(resolvedValue.type);
+		resolvedData.isRef.push(resolvedValue.isRef);
+		resolvedData.originalSchema.push(resolvedValue.originalSchema);
+		if (resolvedValue.hasReadonlyProps) resolvedData.hasReadonlyProps = true;
+		const originalProps = resolvedValue.originalSchema.properties;
+		if (resolvedValue.type === "object" && originalProps) resolvedData.allProperties.push(...Object.keys(originalProps));
 	}
 	if (resolvedData.isEnum.every(Boolean) && name && items.length > 1 && context.output.override.enumGenerationType !== EnumGeneration.UNION) {
 		const { value: combinedEnumValue, valueImports, hasNull } = getCombinedEnumValue(resolvedData.values.map((value, index) => ({
@@ -2520,12 +2522,12 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 	}
 	let resolvedValue;
 	if (normalizedSchema.properties) resolvedValue = getScalar({
-		item: Object.fromEntries(Object.entries(normalizedSchema).filter(([key]) => key !== separator$1)),
+		item: Object.fromEntries(Object.entries(normalizedSchema).filter(([key]) => key !== separator)),
 		name,
 		context,
 		formDataContext
 	});
-	else if (separator$1 === "allOf" && (schema.oneOf || schema.anyOf)) {
+	else if (separator === "allOf" && (schema.oneOf || schema.anyOf)) {
 		const siblingCombiner = schema.oneOf ? "oneOf" : "anyOf";
 		const siblingSchemas = schema[siblingCombiner];
 		resolvedValue = combineSchemas({
@@ -2539,7 +2541,7 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 	return {
 		value: dedupeUnionType(combineValues({
 			resolvedData,
-			separator: separator$1,
+			separator,
 			resolvedValue,
 			context,
 			parentSchema: normalizedSchema
@@ -2644,11 +2646,11 @@ function getParameters({ parameters, context }) {
 * ```
 * @param path
 */
-function getParamsInPath(path$2) {
+function getParamsInPath(path) {
 	let n;
 	const output = [];
 	const templatePathRegex = /\{(.*?)\}/g;
-	while ((n = templatePathRegex.exec(path$2)) !== null) output.push(n[1]);
+	while ((n = templatePathRegex.exec(path)) !== null) output.push(n[1]);
 	return output;
 }
 function getParams({ route, pathParams = [], operationId, context, output }) {
@@ -2831,12 +2833,12 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 function getQueryParams({ queryParams, operationName, context, suffix = "params" }) {
 	if (queryParams.length === 0) return;
 	const types = getQueryParamsTypes(queryParams, operationName, context);
-	const imports = types.flatMap(({ imports: imports$1 }) => imports$1);
-	const schemas = types.flatMap(({ schemas: schemas$1 }) => schemas$1);
+	const imports = types.flatMap(({ imports }) => imports);
+	const schemas = types.flatMap(({ schemas }) => schemas);
 	const name = `${pascal(operationName)}${pascal(suffix)}`;
 	const type = types.map(({ definition }) => definition).join("\n");
 	const allOptional = queryParams.every(({ parameter }) => !parameter.required);
-	const requiredNullableKeys = types.filter(({ required, originalSchema }) => required && isSchemaNullable(originalSchema)).map(({ name: name$1 }) => name$1);
+	const requiredNullableKeys = types.filter(({ required, originalSchema }) => required && isSchemaNullable(originalSchema)).map(({ name }) => name);
 	return {
 		schema: {
 			name,
@@ -2853,9 +2855,9 @@ function getQueryParams({ queryParams, operationName, context, suffix = "params"
 //#region src/getters/response.ts
 function getResponse({ responses, operationName, context, contentType }) {
 	const filteredTypes = filterByContentType(getResReqTypes(Object.entries(responses), operationName, context, "void", (type) => `${type.key}-${type.value}-${type.contentType}`), contentType);
-	const imports = filteredTypes.flatMap(({ imports: imports$1 }) => imports$1);
-	const schemas = filteredTypes.flatMap(({ schemas: schemas$1 }) => schemas$1);
-	const contentTypes = [...new Set(filteredTypes.map(({ contentType: contentType$1 }) => contentType$1))];
+	const imports = filteredTypes.flatMap(({ imports }) => imports);
+	const schemas = filteredTypes.flatMap(({ schemas }) => schemas);
+	const contentTypes = [...new Set(filteredTypes.map(({ contentType }) => contentType))];
 	const groupedByStatus = {
 		success: [],
 		errors: []
@@ -2882,10 +2884,10 @@ function getResponse({ responses, operationName, context, contentType }) {
 //#endregion
 //#region src/getters/route.ts
 const TEMPLATE_TAG_IN_PATH_REGEX = /\/([\w]+)(?:\$\{)/g;
-const hasParam = (path$2) => /[^{]*{[\w*_-]*}.*/.test(path$2);
-const getRoutePath = (path$2) => {
-	const matches = /([^{]*){?([\w*_-]*)}?(.*)/.exec(path$2);
-	if (!matches?.length) return path$2;
+const hasParam = (path) => /[^{]*{[\w*_-]*}.*/.test(path);
+const getRoutePath = (path) => {
+	const matches = /([^{]*){?([\w*_-]*)}?(.*)/.exec(path);
+	if (!matches?.length) return path;
 	const prev = matches[1];
 	const param = sanitize(camel(matches[2]), {
 		es5keyword: true,
@@ -2894,14 +2896,14 @@ const getRoutePath = (path$2) => {
 		dot: true
 	});
 	const next = hasParam(matches[3]) ? getRoutePath(matches[3]) : matches[3];
-	return hasParam(path$2) ? `${prev}\${${param}}${next}` : `${prev}${param}${next}`;
+	return hasParam(path) ? `${prev}\${${param}}${next}` : `${prev}${param}${next}`;
 };
 function getRoute(route) {
 	const splittedRoute = route.split("/");
 	let result = "";
-	for (const [i, path$2] of splittedRoute.entries()) {
-		if (!path$2 && !i) continue;
-		result += path$2.includes("{") ? `/${getRoutePath(path$2)}` : `/${path$2}`;
+	for (const [i, path] of splittedRoute.entries()) {
+		if (!path && !i) continue;
+		result += path.includes("{") ? `/${getRoutePath(path)}` : `/${path}`;
 	}
 	return result;
 }
@@ -2946,8 +2948,8 @@ function generateComponentDefinition(responses = {}, context, suffix) {
 	const generatorSchemas = [];
 	for (const [name, response] of entries(responses)) {
 		const allResponseTypes = getResReqTypes([[suffix, response]], name, context, "void");
-		const imports = allResponseTypes.flatMap(({ imports: imports$1 }) => imports$1);
-		const schemas = allResponseTypes.flatMap(({ schemas: schemas$1 }) => schemas$1);
+		const imports = allResponseTypes.flatMap(({ imports }) => imports);
+		const schemas = allResponseTypes.flatMap(({ schemas }) => schemas);
 		const type = allResponseTypes.map(({ value }) => value).join(" | ");
 		const modelName = sanitize(`${pascal(name)}${suffix}`, {
 			underscore: "_",
@@ -2977,7 +2979,7 @@ function generateImports({ imports, namingConvention = NamingConvention.CAMEL_CA
 	})), (imp) => !imp.default && !imp.namespaceImport && !imp.syntheticDefaultImport && !imp.values && !imp.isConstant ? `aggregate|${imp.importPath}` : `single|${imp.importPath}|${imp.name}|${imp.alias ?? ""}|${String(imp.default)}|${String(imp.namespaceImport)}|${String(imp.syntheticDefaultImport)}|${String(imp.values)}|${String(imp.isConstant)}`);
 	return Object.entries(grouped).toSorted(([a], [b]) => a.localeCompare(b)).map(([, group]) => {
 		const sample = group[0];
-		if (!sample.default && !sample.namespaceImport && !sample.syntheticDefaultImport && !sample.values && !sample.isConstant) return `import type { ${[...new Set(group.map(({ name: name$1, alias: alias$1 }) => `${name$1}${alias$1 ? ` as ${alias$1}` : ""}`))].toSorted().join(", ")} } from '${sample.importPath}';`;
+		if (!sample.default && !sample.namespaceImport && !sample.syntheticDefaultImport && !sample.values && !sample.isConstant) return `import type { ${[...new Set(group.map(({ name, alias }) => `${name}${alias ? ` as ${alias}` : ""}`))].toSorted().join(", ")} } from '${sample.importPath}';`;
 		const { name, values, alias, isConstant, importPath } = sample;
 		return `import ${!values && !isConstant ? "type " : ""}{ ${name}${alias ? ` as ${alias}` : ""} } from '${importPath}';`;
 	}).join("\n");
@@ -2985,9 +2987,9 @@ function generateImports({ imports, namingConvention = NamingConvention.CAMEL_CA
 function generateMutatorImports({ mutators, implementation, oneMore }) {
 	let imports = "";
 	for (const mutator of uniqueWith(mutators, (a, b) => a.name === b.name && a.default === b.default)) {
-		const path$2 = `${oneMore ? "../" : ""}${mutator.path}`;
+		const path = `${oneMore ? "../" : ""}${mutator.path}`;
 		const importDefault = mutator.default ? mutator.name : `{ ${mutator.name} }`;
-		imports += `import ${importDefault} from '${path$2}';`;
+		imports += `import ${importDefault} from '${path}';`;
 		imports += "\n";
 		if (implementation && (mutator.hasErrorType || mutator.bodyTypeName)) {
 			let errorImportName = "";
@@ -2997,7 +2999,7 @@ function generateMutatorImports({ mutators, implementation, oneMore }) {
 			const targetBodyImportName = mutator.default ? `BodyType as ${mutator.bodyTypeName}` : mutator.bodyTypeName;
 			if (mutator.bodyTypeName && implementation.includes(mutator.bodyTypeName) && !imports.includes(` ${targetBodyImportName} }`)) bodyImportName = targetBodyImportName ?? "";
 			if (bodyImportName || errorImportName) {
-				imports += `import type { ${errorImportName}${errorImportName && bodyImportName ? " , " : ""}${bodyImportName} } from '${path$2}';`;
+				imports += `import type { ${errorImportName}${errorImportName && bodyImportName ? " , " : ""}${bodyImportName} } from '${path}';`;
 				imports += "\n";
 			}
 		}
@@ -3085,7 +3087,7 @@ function generateVerbImports({ response, body, queryParams, props, headers, para
 	return [
 		...response.imports,
 		...body.imports,
-		...props.flatMap((prop$1) => prop$1.type === GetterPropType.NAMED_PATH_PARAMS ? [{ name: prop$1.schema.name }] : []),
+		...props.flatMap((prop) => prop.type === GetterPropType.NAMED_PATH_PARAMS ? [{ name: prop.schema.name }] : []),
 		...queryParams ? [{ name: queryParams.schema.name }] : [],
 		...headers ? [{ name: headers.schema.name }] : [],
 		...params.flatMap(({ imports }) => imports)
@@ -3226,7 +3228,7 @@ async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 	const importName = mutator.name ?? `${name}Mutator`;
 	const importPath = mutator.path;
 	const mutatorInfoName = isDefault ? "default" : mutator.name;
-	if (mutatorInfoName === void 0) throw new Error(chalk.red(`Mutator ${importPath} must have a named or default export.`));
+	if (mutatorInfoName === void 0) throw new Error(styleText("red", `Mutator ${importPath} must have a named or default export.`));
 	let rawFile = await fs$1.readFile(importPath, "utf8");
 	rawFile = removeComments(rawFile);
 	const hasErrorType = rawFile.includes("export type ErrorType") || rawFile.includes("export interface ErrorType");
@@ -3240,7 +3242,7 @@ async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 		external: mutator.external,
 		tsconfig
 	});
-	if (!mutatorInfo) throw new Error(chalk.red(`Your mutator file doesn't have the ${mutatorInfoName} exported function`));
+	if (!mutatorInfo) throw new Error(styleText("red", `Your mutator file doesn't have the ${mutatorInfoName} exported function`));
 	const importStatementPath = getImport(output, mutator);
 	const isHook = mutator.name ? mutator.name.startsWith("use") && !mutatorInfo.numberOfParams : !mutatorInfo.numberOfParams;
 	return {
@@ -3557,7 +3559,7 @@ function generateSchemasDefinition(schemas = {}, context, suffix, filters) {
 		const schemasFilters = filters.schemas;
 		const mode = filters.mode ?? "include";
 		generateSchemas = generateSchemas.filter(([schemaName]) => {
-			const isMatch = schemasFilters.some((filter$1) => isString(filter$1) ? filter$1 === schemaName : filter$1.test(schemaName));
+			const isMatch = schemasFilters.some((filter) => isString(filter) ? filter === schemaName : filter.test(schemaName));
 			return mode === "include" ? isMatch : !isMatch;
 		});
 	}
@@ -3643,23 +3645,23 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 	else if (sanitizedSchemaName === resolvedValue.value && resolvedValue.isRef) {
 		const { schema: referredSchema } = resolveRef(schema, context);
 		if (!shouldCreateInterface(referredSchema)) {
-			const imp = resolvedValue.imports.find((imp$1) => imp$1.name === sanitizedSchemaName);
+			const imp = resolvedValue.imports.find((imp) => imp.name === sanitizedSchemaName);
 			if (imp) {
 				const alias = `${resolvedValue.value}Bis`;
 				output += `export type ${sanitizedSchemaName} = ${alias};\n`;
-				imports = imports.map((imp$1) => imp$1.name === sanitizedSchemaName ? {
-					...imp$1,
+				imports = imports.map((imp) => imp.name === sanitizedSchemaName ? {
+					...imp,
 					alias
-				} : imp$1);
+				} : imp);
 				resolvedValue.dependencies = [imp.name];
 			} else output += `export type ${sanitizedSchemaName} = ${resolvedValue.value};\n`;
 		}
 	} else {
-		resolvedValue.schemas = resolvedValue.schemas.filter((schema$1) => {
-			if (schema$1.name !== sanitizedSchemaName) return true;
-			output += `${schema$1.model}\n`;
-			imports = [...imports, ...schema$1.imports];
-			resolvedValue.dependencies.push(...schema$1.dependencies ?? []);
+		resolvedValue.schemas = resolvedValue.schemas.filter((schema) => {
+			if (schema.name !== sanitizedSchemaName) return true;
+			output += `${schema.model}\n`;
+			imports = [...imports, ...schema.imports];
+			resolvedValue.dependencies.push(...schema.dependencies ?? []);
 			return false;
 		});
 		output += `export type ${sanitizedSchemaName} = ${resolvedValue.value};\n`;
@@ -3946,8 +3948,8 @@ function mergeSchemaGroup(schemas) {
 function resolveImportKey(schemaPath, importPath, fileExtension) {
 	return join(schemaPath, `${importPath}${fileExtension}`).toLowerCase().replaceAll("\\", "/");
 }
-function removeFileExtension(path$2, fileExtension) {
-	return path$2.endsWith(fileExtension) ? path$2.slice(0, path$2.length - fileExtension.length) : path$2;
+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 }) {
 	let file = header;
@@ -3960,8 +3962,8 @@ function getSchema({ schema: { imports, model }, target, header, namingConventio
 	file += model;
 	return file;
 }
-function getPath(path$2, name, fileExtension) {
-	return join(path$2, `/${name}${fileExtension}`);
+function getPath(path, name, fileExtension) {
+	return join(path, `/${name}${fileExtension}`);
 }
 function writeModelInline(acc, model) {
 	return acc + `${model}\n`;
@@ -3971,10 +3973,10 @@ function writeModelsInline(array) {
 	for (const { model } of array) acc = writeModelInline(acc, model);
 	return acc;
 }
-async function writeSchema({ path: path$2, schema, target, namingConvention, fileExtension, header }) {
+async function writeSchema({ path, schema, target, namingConvention, fileExtension, header }) {
 	const name = conventionName(schema.name, namingConvention);
 	try {
-		await fs$1.outputFile(getPath(path$2, name, fileExtension), getSchema({
+		await fs$1.outputFile(getPath(path, name, fileExtension), getSchema({
 			schema,
 			target,
 			header,
@@ -4178,13 +4180,13 @@ interface TypedResponse<T> extends Response {
 //#region src/writers/single-mode.ts
 async function writeSingleMode({ builder, output, projectName, header, needSchema }) {
 	try {
-		const { path: path$2, dirname: dirname$1 } = getFileInfo(output.target, {
+		const { path, dirname } = getFileInfo(output.target, {
 			backupFilename: conventionName(builder.info.title, 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 ? relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
+		const schemasPath = output.schemas ? relativeSafe(dirname, 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) : [];
 		data += builder.imports({
@@ -4234,8 +4236,8 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 			data += "\n\n";
 			data += implementationMock;
 		}
-		await fs$1.outputFile(path$2, data);
-		return [path$2];
+		await fs$1.outputFile(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}`);
@@ -4246,14 +4248,14 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 //#region src/writers/split-mode.ts
 async function writeSplitMode({ builder, output, projectName, header, needSchema }) {
 	try {
-		const { filename, dirname: dirname$1, extension } = getFileInfo(output.target, {
+		const { filename, dirname, extension } = getFileInfo(output.target, {
 			backupFilename: conventionName(builder.info.title, output.namingConvention),
 			extension: output.fileExtension
 		});
 		const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, fetchReviver } = generateTarget(builder, output);
 		let implementationData = header;
 		let mockData = header;
-		const relativeSchemasPath = output.schemas ? relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
+		const relativeSchemasPath = output.schemas ? relativeSafe(dirname, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 		const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 		implementationData += builder.imports({
@@ -4278,10 +4280,10 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			isAllowSyntheticDefaultImports,
 			options: isFunction(output.mock) ? void 0 : output.mock
 		});
-		const schemasPath = output.schemas ? void 0 : join(dirname$1, filename + ".schemas" + extension);
+		const schemasPath = output.schemas ? void 0 : join(dirname, filename + ".schemas" + extension);
 		if (schemasPath && needSchema) {
 			const schemasData = header + generateModelsInline(builder.schemas);
-			await fs$1.outputFile(join(dirname$1, filename + ".schemas" + extension), schemasData);
+			await fs$1.outputFile(join(dirname, filename + ".schemas" + extension), schemasData);
 		}
 		if (mutators) implementationData += generateMutatorImports({
 			mutators,
@@ -4303,9 +4305,9 @@ 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 = join(dirname$1, implementationFilename);
-		await fs$1.outputFile(join(dirname$1, implementationFilename), implementationData);
-		const mockPath = output.mock ? join(dirname$1, filename + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
+		const implementationPath = join(dirname, implementationFilename);
+		await fs$1.outputFile(join(dirname, implementationFilename), implementationData);
+		const mockPath = output.mock ? join(dirname, filename + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
 		if (mockPath) await fs$1.outputFile(mockPath, mockData);
 		return [
 			implementationPath,
@@ -4375,7 +4377,7 @@ function generateTargetForTags(builder, options) {
 			const transformed = {};
 			for (const [tag, target] of Object.entries(allTargetTags)) {
 				const isMutator = !!target.mutators?.some((mutator) => isAngularClient ? mutator.hasThirdArg : mutator.hasSecondArg);
-				const operationNames = Object.values(builder.operations).filter(({ tags }) => tags.map((tag$1) => kebab(tag$1)).indexOf(kebab(tag)) === 0).map(({ operationName }) => operationName);
+				const operationNames = Object.values(builder.operations).filter(({ tags }) => tags.map((tag) => kebab(tag)).indexOf(kebab(tag)) === 0).map(({ operationName }) => operationName);
 				const hasAwaitedType = compareVersions(options.packageJson?.dependencies?.typescript ?? options.packageJson?.devDependencies?.typescript ?? "4.4.0", "4.5.0");
 				const titles = builder.title({
 					outputClient: options.client,
@@ -4435,22 +4437,22 @@ function generateTargetForTags(builder, options) {
 //#endregion
 //#region src/writers/split-tags-mode.ts
 async function writeSplitTagsMode({ builder, output, projectName, header, needSchema }) {
-	const { filename, dirname: dirname$1, extension } = getFileInfo(output.target, {
+	const { filename, dirname, extension } = getFileInfo(output.target, {
 		backupFilename: conventionName(builder.info.title, 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 ? join(dirname$1, "index." + getMockFileExtensionByTypeName(mockOption) + extension) : void 0;
+	const indexFilePath = mockOption?.indexMockFiles ? 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$1]) => {
+	const generatedFilePathsArray = await Promise.all(tagEntries.map(async ([tag, target]) => {
 		try {
-			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, fetchReviver, formUrlEncoded, paramsSerializer } = target$1;
+			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, fetchReviver, formUrlEncoded, paramsSerializer } = target;
 			let implementationData = header;
 			let mockData = header;
-			const relativeSchemasPath = output.schemas ? "../" + relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas";
+			const relativeSchemasPath = output.schemas ? "../" + relativeSafe(dirname, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas";
 			const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 			implementationData += builder.imports({
 				client: output.client,
@@ -4460,7 +4462,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				hasSchemaDir: !!output.schemas,
 				isAllowSyntheticDefaultImports,
 				hasGlobalMutator: !!output.override.mutator,
-				hasTagsMutator: Object.values(output.override.tags).some((tag$1) => !!tag$1?.mutator),
+				hasTagsMutator: Object.values(output.override.tags).some((tag) => !!tag?.mutator),
 				hasParamsSerializerOptions: !!output.override.paramsSerializerOptions,
 				packageJson: output.packageJson,
 				output
@@ -4474,7 +4476,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				isAllowSyntheticDefaultImports,
 				options: isFunction(output.mock) ? void 0 : output.mock
 			});
-			const schemasPath = output.schemas ? void 0 : join(dirname$1, filename + ".schemas" + extension);
+			const schemasPath = output.schemas ? void 0 : join(dirname, filename + ".schemas" + extension);
 			if (schemasPath && needSchema) {
 				const schemasData = header + generateModelsInline(builder.schemas);
 				await fs$1.outputFile(schemasPath, schemasData);
@@ -4515,9 +4517,9 @@ 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 = join(dirname$1, tag, implementationFilename);
+			const implementationPath = join(dirname, tag, implementationFilename);
 			await fs$1.outputFile(implementationPath, implementationData);
-			const mockPath = output.mock ? join(dirname$1, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
+			const mockPath = output.mock ? join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
 			if (mockPath) await fs$1.outputFile(mockPath, mockData);
 			return [
 				implementationPath,
@@ -4541,17 +4543,17 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 //#endregion
 //#region src/writers/tags-mode.ts
 async function writeTagsMode({ builder, output, projectName, header, needSchema }) {
-	const { filename, dirname: dirname$1, extension } = getFileInfo(output.target, {
+	const { filename, dirname, extension } = getFileInfo(output.target, {
 		backupFilename: conventionName(builder.info.title, output.namingConvention),
 		extension: output.fileExtension
 	});
 	const target = generateTargetForTags(builder, output);
 	const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
-	return (await Promise.all(Object.entries(target).map(async ([tag, target$1]) => {
+	return (await Promise.all(Object.entries(target).map(async ([tag, target]) => {
 		try {
-			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, fetchReviver, paramsSerializer } = target$1;
+			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, fetchReviver, paramsSerializer } = target;
 			let data = header;
-			const schemasPathRelative = output.schemas ? relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
+			const schemasPathRelative = output.schemas ? relativeSafe(dirname, 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);
 			data += builder.imports({
 				client: output.client,
@@ -4561,7 +4563,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 				hasSchemaDir: !!output.schemas,
 				isAllowSyntheticDefaultImports,
 				hasGlobalMutator: !!output.override.mutator,
-				hasTagsMutator: Object.values(output.override.tags).some((tag$1) => !!tag$1?.mutator),
+				hasTagsMutator: Object.values(output.override.tags).some((tag) => !!tag?.mutator),
 				hasParamsSerializerOptions: !!output.override.paramsSerializerOptions,
 				packageJson: output.packageJson,
 				output
@@ -4577,7 +4579,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 					options: isFunction(output.mock) ? void 0 : output.mock
 				});
 			}
-			const schemasPath = output.schemas ? void 0 : join(dirname$1, filename + ".schemas" + extension);
+			const schemasPath = output.schemas ? void 0 : join(dirname, filename + ".schemas" + extension);
 			if (schemasPath && needSchema) {
 				const schemasData = header + generateModelsInline(builder.schemas);
 				await fs$1.outputFile(schemasPath, schemasData);
@@ -4605,7 +4607,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 				data += "\n\n";
 				data += implementationMock;
 			}
-			const implementationPath = join(dirname$1, `${kebab(tag)}${extension}`);
+			const implementationPath = join(dirname, `${kebab(tag)}${extension}`);
 			await fs$1.outputFile(implementationPath, data);
 			return [implementationPath, ...schemasPath ? [schemasPath] : []];
 		} catch (error) {