swagger-typescript-api 13.2.10 → 13.2.11

package/dist/{src-C5bMYV9w.cjs → src-D2FYrO2h.cjs}

@@ -5,11 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
+var __export = (all) => {
+	let target = {};
 	for (var name$1 in all) __defProp(target, name$1, {
 		get: all[name$1],
 		enumerable: true
 	});
+	return target;
 };
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -27,18 +29,30 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const consola = __toESM(require("consola"));
-const lodash = __toESM(require("lodash"));
-const typescript = __toESM(require("typescript"));
-const node_path = __toESM(require("node:path"));
-const __biomejs_js_api = __toESM(require("@biomejs/js-api"));
-const nanoid = __toESM(require("nanoid"));
-const js_yaml = __toESM(require("js-yaml"));
-const swagger2openapi = __toESM(require("swagger2openapi"));
-const node_module = __toESM(require("node:module"));
-const node_url = __toESM(require("node:url"));
-const eta = __toESM(require("eta"));
-const node_fs = __toESM(require("node:fs"));
+let consola = require("consola");
+consola = __toESM(consola);
+let lodash = require("lodash");
+lodash = __toESM(lodash);
+let typescript = require("typescript");
+typescript = __toESM(typescript);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let __biomejs_js_api = require("@biomejs/js-api");
+__biomejs_js_api = __toESM(__biomejs_js_api);
+let nanoid = require("nanoid");
+nanoid = __toESM(nanoid);
+let js_yaml = require("js-yaml");
+js_yaml = __toESM(js_yaml);
+let swagger2openapi = require("swagger2openapi");
+swagger2openapi = __toESM(swagger2openapi);
+let node_module = require("node:module");
+node_module = __toESM(node_module);
+let node_url = require("node:url");
+node_url = __toESM(node_url);
+let eta = require("eta");
+eta = __toESM(eta);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
 
 //#region src/code-formatter.ts
 var CodeFormatter = class {
@@ -49,8 +63,7 @@ var CodeFormatter = class {
 	removeUnusedImports = (content) => {
 		const tempFileName = "file.ts";
 		const host = new TsLanguageServiceHost(tempFileName, content);
-		const languageService = typescript.createLanguageService(host);
-		const fileTextChanges = languageService.organizeImports({
+		const fileTextChanges = typescript.createLanguageService(host).organizeImports({
 			type: "file",
 			fileName: tempFileName
 		}, { newLineCharacter: typescript.sys.newLine }, void 0)[0];
@@ -64,11 +77,10 @@ var CodeFormatter = class {
 			files: { maxSize: Number.MAX_SAFE_INTEGER },
 			formatter: { indentStyle: "space" }
 		});
-		const formatted = biome.formatContent(biomeProject.projectKey, content, { filePath: node_path.format({
+		return biome.formatContent(biomeProject.projectKey, content, { filePath: node_path.format({
 			name: nanoid.nanoid(),
 			ext: "ts"
-		}) });
-		return formatted.content;
+		}) }).content;
 	};
 	formatCode = async (code, { removeUnusedImports = true, format = true } = {}) => {
 		if (removeUnusedImports) code = this.removeUnusedImports(code);
@@ -204,7 +216,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.10";
+var version = "13.2.11";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 var homepage = "https://github.com/acacode/swagger-typescript-api";
 var bugs = "https://github.com/acacode/swagger-typescript-api/issues";
@@ -247,10 +259,10 @@ var dependencies = {
 	"@biomejs/js-api": "3.0.0",
 	"@biomejs/wasm-nodejs": "2.2.4",
 	"@types/swagger-schema-official": "^2.0.25",
-	"c12": "^3.2.0",
+	"c12": "^3.3.0",
 	"citty": "^0.1.6",
 	"consola": "^3.4.2",
-	"eta": "^2.2.0",
+	"eta": "^4.0.1",
 	"js-yaml": "^4.1.0",
 	"lodash": "^4.17.21",
 	"nanoid": "^5.1.5",
@@ -266,12 +278,12 @@ var devDependencies = {
 	"@tsconfig/strictest": "2.0.5",
 	"@types/js-yaml": "4.0.9",
 	"@types/lodash": "4.17.20",
-	"@types/node": "24.3.2",
+	"@types/node": "24.5.2",
 	"@types/swagger2openapi": "7.0.4",
-	"axios": "1.12.1",
+	"axios": "1.12.2",
 	"openapi-types": "12.1.3",
-	"tsdown": "0.15.1",
-	"typedoc": "0.28.12",
+	"tsdown": "0.15.2",
+	"typedoc": "0.28.13",
 	"vitest": "3.2.4"
 };
 var packageManager = "yarn@4.9.4";
@@ -313,8 +325,7 @@ var package_default = {
 
 //#endregion
 //#region src/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
+var constants_exports = /* @__PURE__ */ __export({
 	DEFAULT_BODY_ARG_NAME: () => DEFAULT_BODY_ARG_NAME,
 	FILE_PREFIX: () => FILE_PREFIX,
 	HTTP_CLIENT: () => HTTP_CLIENT,
@@ -764,9 +775,9 @@ var SchemaComponentsMap = class {
 	filter(...componentNames) {
 		return this._data.filter((it) => componentNames.some((componentName) => it.$ref.startsWith(`#/components/${componentName}`)));
 	}
-	get($ref) {
+	get = ($ref) => {
 		return this._data.find((c) => c.$ref === $ref) || null;
-	}
+	};
 	enumsFirst() {
 		this._data.sort((a, b) => {
 			if (Object.keys(a.rawTypeData || {}).includes("enum")) return -1;
@@ -774,6 +785,13 @@ var SchemaComponentsMap = class {
 			return 0;
 		});
 	}
+	discriminatorsFirst() {
+		this._data.sort((a, b) => {
+			if (Object.keys(a.rawTypeData || {}).includes("discriminator")) return -1;
+			if (Object.keys(b.rawTypeData || {}).includes("discriminator")) return 1;
+			return 0;
+		});
+	}
 };
 
 //#endregion
@@ -837,13 +855,11 @@ var SchemaFormatters = class {
 	};
 	formatSchema = (parsedSchema, formatType = "base") => {
 		const schemaType = lodash.default.get(parsedSchema, ["schemaType"]) || lodash.default.get(parsedSchema, ["$parsed", "schemaType"]);
-		const formatterFn = lodash.default.get(this, [formatType, schemaType]);
-		return formatterFn?.(parsedSchema) || parsedSchema;
+		return lodash.default.get(this, [formatType, schemaType])?.(parsedSchema) || parsedSchema;
 	};
 	formatDescription = (description$1, inline) => {
 		if (!description$1) return "";
-		const hasMultipleLines = description$1.includes("\n");
-		if (!hasMultipleLines) return description$1;
+		if (!description$1.includes("\n")) return description$1;
 		if (inline) return lodash.default._(description$1).split(/\n/g).map((part) => part.trim()).compact().join(" ").valueOf();
 		return description$1.replace(/\n$/g, "");
 	};
@@ -852,8 +868,7 @@ var SchemaFormatters = class {
 		for (const part of content) {
 			const extraSpace = "  ";
 			const result = `${extraSpace}${part.field},\n`;
-			const renderedJsDoc = this.templatesWorker.renderTemplate(this.config.templatesToRender.dataContractJsDoc, { data: part });
-			const routeNameFromTemplate = renderedJsDoc.split("\n").map((c) => `${extraSpace}${c}`).join("\n");
+			const routeNameFromTemplate = this.templatesWorker.renderTemplate(this.config.templatesToRender.dataContractJsDoc, { data: part }).split("\n").map((c) => `${extraSpace}${c}`).join("\n");
 			if (routeNameFromTemplate) fields.push(`${routeNameFromTemplate}${result}`);
 			else fields.push(`${result}`);
 		}
@@ -1013,7 +1028,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 				suffixes: this.config.extractingOptions.discriminatorMappingSuffix,
 				resolver: this.config.extractingOptions.discriminatorMappingNameResolver
 			});
-			const content$1 = ts.IntersectionType([ts.ObjectWrapper(ts.TypeField({
+			const content = ts.IntersectionType([ts.ObjectWrapper(ts.TypeField({
 				key: ts.StringValue(discriminator.propertyName),
 				value: "Key"
 			})), "Type"]);
@@ -1026,21 +1041,21 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 					internal: true
 				}
 			});
-			component.typeData.content = content$1;
+			component.typeData.content = content;
 			mappingTypeName = this.typeNameFormatter.format(component.typeName);
 		}
 		/** returns (GenericType<"mapping_key", MappingType>) or ({ discriminatorProperty: "mapping_key" } & MappingType) */
 		const createMappingContent = (mappingSchema, mappingKey) => {
-			const content$1 = this.schemaParserFabric.createSchemaParser({
+			const content = this.schemaParserFabric.createSchemaParser({
 				schema: mappingSchema,
 				schemaPath: this.schemaPath
 			}).getInlineParseContent();
 			const mappingUsageKey = mappingPropertySchemaEnumKeysMap[mappingKey] || ts.StringValue(mappingKey);
-			if (ableToCreateMappingType) return ts.TypeWithGeneric(mappingTypeName, [mappingUsageKey, content$1]);
+			if (ableToCreateMappingType) return ts.TypeWithGeneric(mappingTypeName, [mappingUsageKey, content]);
 			return ts.ExpressionGroup(ts.IntersectionType([ts.ObjectWrapper(ts.TypeField({
 				key: discriminator.propertyName,
 				value: mappingUsageKey
-			})), content$1]));
+			})), content]));
 		};
 		for (const [mappingKey, schema] of mappingEntries) {
 			const mappingSchema = typeof schema === "string" ? { $ref: schema } : schema;
@@ -1054,8 +1069,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 			mappingContents.push(createMappingContent(mappingSchema, mappingKey));
 		}
 		if (skipMappingType) return null;
-		const content = ts.ExpressionGroup(ts.UnionType(mappingContents));
-		return { content };
+		return { content: ts.ExpressionGroup(ts.UnionType(mappingContents)) };
 	};
 	createMappingPropertySchemaEnumKeys = ({ abstractSchemaStruct, discPropertyName }) => {
 		const ts = this.config.Ts;
@@ -1093,8 +1107,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 		const complexSchemaKeys = lodash.default.keys(this.schemaParser._complexSchemaParsers);
 		const schema = lodash.default.omit(structuredClone(noDiscriminatorSchema), complexSchemaKeys);
 		const schemaIsAny = this.schemaParserFabric.getInlineParseContent(structuredClone(schema)) === this.config.Ts.Keyword.Any;
-		const schemaIsEmpty = !lodash.default.keys(schema).length;
-		if (schemaIsEmpty || schemaIsAny) return null;
+		if (!lodash.default.keys(schema).length || schemaIsAny) return null;
 		const typeName = this.schemaUtils.resolveTypeName(this.typeName, {
 			prefixes: this.config.extractingOptions.discriminatorAbstractPrefix,
 			resolver: this.config.extractingOptions.discriminatorAbstractResolver
@@ -1423,56 +1436,36 @@ var SchemaParser = class {
 	}
 	_complexSchemaParsers = {
 		[SCHEMA_TYPES$1.COMPLEX_ONE_OF]: (schema) => {
-			const SchemaParser$1 = this.config.schemaParsers.complexOneOf || OneOfSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, null, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.complexOneOf || OneOfSchemaParser)(this, schema, null, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.COMPLEX_ALL_OF]: (schema) => {
-			const SchemaParser$1 = this.config.schemaParsers.complexAllOf || AllOfSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, null, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.complexAllOf || AllOfSchemaParser)(this, schema, null, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.COMPLEX_ANY_OF]: (schema) => {
-			const SchemaParser$1 = this.config.schemaParsers.complexAnyOf || AnyOfSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, null, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.complexAnyOf || AnyOfSchemaParser)(this, schema, null, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.COMPLEX_NOT]: (schema) => {
-			const SchemaParser$1 = this.config.schemaParsers.complexNot || NotSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, null, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.complexNot || NotSchemaParser)(this, schema, null, this.schemaPath).parse();
 		}
 	};
 	_baseSchemaParsers = {
 		[SCHEMA_TYPES$1.ENUM]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.enum || EnumSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.enum || EnumSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.OBJECT]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.object || ObjectSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.object || ObjectSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.COMPLEX]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.complex || ComplexSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.complex || ComplexSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.PRIMITIVE]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.primitive || PrimitiveSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.primitive || PrimitiveSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.DISCRIMINATOR]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.discriminator || DiscriminatorSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.discriminator || DiscriminatorSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
 		[SCHEMA_TYPES$1.ARRAY]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.array || ArraySchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+			return new (this.config.schemaParsers.array || ArraySchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		}
 	};
 	parseSchema = () => {
@@ -1509,13 +1502,11 @@ var SchemaParser = class {
 	};
 	getInlineParseContent = () => {
 		const parsedSchema = this.parseSchema();
-		const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "inline");
-		return formattedSchema.content;
+		return this.schemaFormatters.formatSchema(parsedSchema, "inline").content;
 	};
 	getParseContent = () => {
 		const parsedSchema = this.parseSchema();
-		const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "base");
-		return formattedSchema.content;
+		return this.schemaFormatters.formatSchema(parsedSchema, "base").content;
 	};
 	extractSchemaFromResponseStruct = (responseStruct) => {
 		const { content,...extras } = responseStruct;
@@ -1613,8 +1604,7 @@ var SchemaUtils = class {
 		const required = lodash.default.uniq([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
 		const refData = this.getSchemaRefType(childSchema);
 		if (refData) {
-			const refObjectProperties = lodash.default.keys(refData.rawTypeData?.properties || {});
-			const existedRequiredKeys = refObjectProperties.filter((key) => required.includes(key));
+			const existedRequiredKeys = lodash.default.keys(refData.rawTypeData?.properties || {}).filter((key) => required.includes(key));
 			if (!existedRequiredKeys.length) return childSchema;
 			return {
 				...childSchema,
@@ -1622,8 +1612,7 @@ var SchemaUtils = class {
 			};
 		}
 		if (childSchema.properties) {
-			const childSchemaProperties = lodash.default.keys(childSchema.properties);
-			const existedRequiredKeys = childSchemaProperties.filter((key) => required.includes(key));
+			const existedRequiredKeys = lodash.default.keys(childSchema.properties).filter((key) => required.includes(key));
 			if (!existedRequiredKeys.length) return childSchema;
 			return {
 				required: lodash.default.uniq([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
@@ -1742,28 +1731,25 @@ var SchemaParserFabric = class {
 		return customComponent;
 	};
 	parseSchema = (schema, typeName = null, schemaPath = []) => {
-		const schemaParser = this.createSchemaParser({
+		return this.createSchemaParser({
 			schema,
 			typeName,
 			schemaPath
-		});
-		return schemaParser.parseSchema();
+		}).parseSchema();
 	};
 	getInlineParseContent = (schema, typeName, schemaPath) => {
-		const parser = this.createSchemaParser({
+		return this.createSchemaParser({
 			schema,
 			typeName,
 			schemaPath
-		});
-		return parser.getInlineParseContent();
+		}).getInlineParseContent();
 	};
 	getParseContent = (schema, typeName, schemaPath) => {
-		const parser = this.createSchemaParser({
+		return this.createSchemaParser({
 			schema,
 			typeName,
 			schemaPath
-		});
-		return parser.getParseContent();
+		}).getParseContent();
 	};
 };
 
@@ -1916,14 +1902,8 @@ var SchemaRoutes = class {
 			}
 			if (routeParam) routeParams[routeParam.in].push(routeParam);
 		});
-		for (const pathParam of pathParamsFromRouteName) {
-			const alreadyExist = routeParams.path.some((parameter) => parameter.name === pathParam.name);
-			if (!alreadyExist) routeParams.path.push(pathParam);
-		}
-		for (const queryParam of queryParamsFromRouteName) {
-			const alreadyExist = routeParams.query.some((parameter) => parameter.name === queryParam.name);
-			if (!alreadyExist) routeParams.query.push(queryParam);
-		}
+		for (const pathParam of pathParamsFromRouteName) if (!routeParams.path.some((parameter) => parameter.name === pathParam.name)) routeParams.path.push(pathParam);
+		for (const queryParam of queryParamsFromRouteName) if (!routeParams.query.some((parameter) => parameter.name === queryParam.name)) routeParams.query.push(queryParam);
 		return routeParams;
 	};
 	getContentTypes = (requestInfo, extraContentTypes) => lodash.default.uniq(lodash.default.compact([...extraContentTypes || [], ...lodash.default.flatten(lodash.default.map(requestInfo, (requestInfoData) => requestInfoData && lodash.default.keys(requestInfoData.content)))]));
@@ -2001,8 +1981,7 @@ var SchemaRoutes = class {
 			const headerTypes = Object.fromEntries(Object.entries(src).map(([k, v]) => {
 				return [k, this.schemaUtils.getSchemaType(v)];
 			}));
-			const r = `headers: { ${Object.entries(headerTypes).map(([k, v]) => `"${k}": ${v}`).join(",")} },`;
-			return r;
+			return `headers: { ${Object.entries(headerTypes).map(([k, v]) => `"${k}": ${v}`).join(",")} },`;
 		};
 		return {
 			contentTypes,
@@ -2414,8 +2393,7 @@ var Request = class {
 		if (authToken) requestOptions.headers = { Authorization: authToken };
 		lodash.default.merge(requestOptions, options, this.config.requestOptions);
 		try {
-			const response = await fetch(url$1, requestOptions);
-			return await response.text();
+			return await (await fetch(url$1, requestOptions)).text();
 		} catch (error) {
 			const message = `error while fetching data from URL "${url$1}"`;
 			consola.consola.error(message, error);
@@ -2506,8 +2484,7 @@ var SwaggerSchemaResolver = class {
 					usageRouteInfo.produces = lodash.default.uniq(lodash.default.compact([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
 				}
 				lodash.default.each(originalRouteParams, (originalRouteParam) => {
-					const existUsageParam = usageRouteParams.find((param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name);
-					if (!existUsageParam) usageRouteParams.push(originalRouteParam);
+					if (!usageRouteParams.find((param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name)) usageRouteParams.push(originalRouteParam);
 				});
 			});
 		});
@@ -2517,6 +2494,7 @@ var SwaggerSchemaResolver = class {
 //#endregion
 //#region src/templates-worker.ts
 const require$1 = node_module.createRequire(require("url").pathToFileURL(__filename).href);
+const eta$1 = new eta.Eta({ functionHeader: "const includeFile = options.includeFile;" });
 var TemplatesWorker = class {
 	config;
 	fileSystem;
@@ -2546,12 +2524,10 @@ var TemplatesWorker = class {
 	cropExtension = (path$1) => this.config.templateExtensions.reduce((path$2, ext) => path$2.endsWith(ext) ? path$2.replace(ext, "") : path$2, path$1);
 	getTemplateFullPath = (path_, fileName) => {
 		const raw = node_path.resolve(path_, "./", this.cropExtension(fileName));
-		const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
-		return pathVariants.find((variant) => !!this.fileSystem.pathIsExist(variant));
+		return this.config.templateExtensions.map((extension) => `${raw}${extension}`).find((variant) => !!this.fileSystem.pathIsExist(variant));
 	};
 	requireFnFromTemplate = (packageOrPath) => {
-		const isPath = packageOrPath.startsWith("./") || packageOrPath.startsWith("../");
-		if (isPath) return require$1(node_path.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
+		if (packageOrPath.startsWith("./") || packageOrPath.startsWith("../")) return require$1(node_path.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
 		return require$1(packageOrPath);
 	};
 	getTemplate = (name$1, fileName, path$1) => {
@@ -2581,8 +2557,7 @@ var TemplatesWorker = class {
 	};
 	findTemplateWithExt = (path$1) => {
 		const raw = this.cropExtension(path$1);
-		const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
-		return pathVariants.find((variant) => this.fileSystem.pathIsExist(variant));
+		return this.config.templateExtensions.map((extension) => `${raw}${extension}`).find((variant) => this.fileSystem.pathIsExist(variant));
 	};
 	getTemplateContent = (path_) => {
 		const foundTemplatePathKey = lodash.default.keys(this.config.templatePaths).find((key) => path_.startsWith(`@${key}`));
@@ -2597,18 +2572,12 @@ var TemplatesWorker = class {
 		if (originalPath) return this.fileSystem.getFileContent(originalPath);
 		return "";
 	};
-	renderTemplate = (template, configuration, options = {}) => {
+	renderTemplate = (template, configuration) => {
 		if (!template) return "";
-		return eta.render(template, {
+		return eta$1.render(eta$1.compile(template, { async: false }), {
 			...this.getRenderTemplateData(),
 			...configuration
-		}, {
-			async: false,
-			...options,
-			includeFile: (path$1, configuration$1, options$1 = {}) => {
-				return this.renderTemplate(this.getTemplateContent(path$1), configuration$1, options$1);
-			}
-		});
+		}, { includeFile: (path$1, configuration$1) => this.renderTemplate(this.getTemplateContent(path$1), configuration$1) });
 	};
 };
 
@@ -2699,10 +2668,7 @@ var TypeNameFormatter = class {
 	isValidName = (name$1) => /^([A-Za-z$_]{1,})$/g.test(name$1);
 	fixModelName = (name$1, options) => {
 		if (!this.isValidName(name$1)) {
-			if (!/^[a-zA-Z_$]/g.test(name$1)) {
-				const fixPrefix = options.type === "enum-key" ? this.config.fixInvalidEnumKeyPrefix : this.config.fixInvalidTypeNamePrefix;
-				return `${fixPrefix} ${name$1}`;
-			}
+			if (!/^[a-zA-Z_$]/g.test(name$1)) return `${options.type === "enum-key" ? this.config.fixInvalidEnumKeyPrefix : this.config.fixInvalidTypeNamePrefix} ${name$1}`;
 			if (name$1.includes(".")) return name$1.replace(/Exclude_keyof[A-Za-z]+/g, () => "ExcludeKeys").replace(/%22~AND~%22/g, "And").replace(/%22~OR~%22/g, "Or").replace(/(\.?%22)|\./g, "_").replace(/__+$/, "");
 			if (name$1.includes("-")) return lodash.default.startCase(name$1).replace(/ /g, "");
 		}
@@ -2722,8 +2688,7 @@ var FileSystem = class {
 	pathIsDir = (path$1) => {
 		if (!path$1) return false;
 		try {
-			const stat = node_fs.statSync(path$1);
-			return stat.isDirectory();
+			return node_fs.statSync(path$1).isDirectory();
 		} catch (e) {
 			return false;
 		}
@@ -2822,9 +2787,9 @@ var CodeGenProcess = class {
 				typeName
 			]), rawTypeData);
 		}));
+		this.schemaComponentsMap.discriminatorsFirst();
 		this.schemaComponentsMap.enumsFirst();
-		const componentsToParse = this.schemaComponentsMap.filter(lodash.default.compact(["schemas", this.config.extractResponses && "responses"]));
-		const parsedSchemas = componentsToParse.map((schemaComponent) => {
+		const parsedSchemas = this.schemaComponentsMap.filter(lodash.default.compact(["schemas", this.config.extractResponses && "responses"])).map((schemaComponent) => {
 			const parsed = this.schemaParserFabric.parseSchema(schemaComponent.rawTypeData, schemaComponent.typeName);
 			schemaComponent.typeData = parsed;
 			return parsed;
@@ -2859,8 +2824,7 @@ var CodeGenProcess = class {
 			this.fileSystem.createDir(this.config.output);
 		}
 		const files$1 = await this.generateOutputFiles({ configuration });
-		const isDirPath = this.fileSystem.pathIsDir(this.config.output);
-		if (isDirPath) for (const file of files$1) {
+		if (this.fileSystem.pathIsDir(this.config.output)) for (const file of files$1) {
 			this.fileSystem.createFile({
 				path: this.config.output,
 				fileName: `${file.fileName}${file.fileExtension}`,
@@ -3141,8 +3105,7 @@ var TemplatesGenProcess = class {
 				const templateEtaPath = node_path.default.resolve(outputPath, `${templateName}.eta`);
 				const templateEjsPathExist = this.fileSystem.pathIsExist(templateEjsPath);
 				const templateEtaPathExist = this.fileSystem.pathIsExist(templateEtaPath);
-				const templateNotExist = !templateEjsPathExist && !templateEtaPathExist;
-				if (templateNotExist) this.fileSystem.createFile({
+				if (!templateEjsPathExist && !templateEtaPathExist) this.fileSystem.createFile({
 					path: outputPath,
 					fileName: template.name,
 					content: template.content,
@@ -3212,8 +3175,7 @@ var TemplatesGenProcess = class {
 async function generateTemplates(config) {
 	if (config.debug) consola.consola.level = Number.MAX_SAFE_INTEGER;
 	if (config.silent) consola.consola.level = 0;
-	const codeGenProcess = new TemplatesGenProcess(config);
-	return await codeGenProcess.start();
+	return await new TemplatesGenProcess(config).start();
 }
 
 //#endregion
@@ -3221,8 +3183,7 @@ async function generateTemplates(config) {
 async function generateApi(config) {
 	if (config.debug) consola.consola.level = Number.MAX_SAFE_INTEGER;
 	if (config.silent) consola.consola.level = 0;
-	const codeGenProcess = new CodeGenProcess(config);
-	return await codeGenProcess.start();
+	return await new CodeGenProcess(config).start();
 }
 
 //#endregion
@@ -3286,4 +3247,4 @@ Object.defineProperty(exports, 'package_default', {
     return package_default;
   }
 });
-//# sourceMappingURL=src-C5bMYV9w.cjs.map
+//# sourceMappingURL=src-D2FYrO2h.cjs.map