swagger-typescript-api 13.2.10 → 13.2.12

package/dist/{src-s8addnrG.js → src-LjX9fiRq.js}

@@ -1,4 +1,4 @@
-import { __export } from "./chunk-Cl8Af3a2.js";
+import { __export } from "./chunk-CTAAG5j7.js";
 import * as module from "node:module";
 import { consola } from "consola";
 import lodash from "lodash";
@@ -11,7 +11,7 @@ import * as yaml from "js-yaml";
 import * as swagger2openapi from "swagger2openapi";
 import * as url$1 from "node:url";
 import url from "node:url";
-import * as Eta from "eta";
+import { Eta } from "eta";
 import * as fs from "node:fs";
 
 //#region src/code-formatter.ts
@@ -23,8 +23,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];
@@ -38,11 +37,10 @@ var CodeFormatter = class {
 			files: { maxSize: Number.MAX_SAFE_INTEGER },
 			formatter: { indentStyle: "space" }
 		});
-		const formatted = biome.formatContent(biomeProject.projectKey, content, { filePath: path$1.format({
+		return biome.formatContent(biomeProject.projectKey, content, { filePath: path$1.format({
 			name: nanoid.nanoid(),
 			ext: "ts"
-		}) });
-		return formatted.content;
+		}) }).content;
 	};
 	formatCode = async (code, { removeUnusedImports = true, format = true } = {}) => {
 		if (removeUnusedImports) code = this.removeUnusedImports(code);
@@ -178,7 +176,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.10";
+var version = "13.2.12";
 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";
@@ -220,14 +218,16 @@ var scripts = {
 var dependencies = {
 	"@biomejs/js-api": "3.0.0",
 	"@biomejs/wasm-nodejs": "2.2.4",
+	"@types/lodash": "^4.17.20",
 	"@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",
+	"openapi-types": "^12.1.3",
 	"swagger-schema-official": "2.0.0-bab6bed",
 	"swagger2openapi": "^7.0.8",
 	"typescript": "~5.9.2"
@@ -239,16 +239,14 @@ var devDependencies = {
 	"@tsconfig/node20": "20.1.6",
 	"@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",
-	"openapi-types": "12.1.3",
-	"tsdown": "0.15.1",
-	"typedoc": "0.28.12",
+	"axios": "1.12.2",
+	"tsdown": "0.15.2",
+	"typedoc": "0.28.13",
 	"vitest": "3.2.4"
 };
-var packageManager = "yarn@4.9.4";
+var packageManager = "yarn@4.10.2";
 var engines = { "node": ">=20" };
 var publishConfig = {
 	"access": "public",
@@ -287,8 +285,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,
@@ -738,9 +735,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;
@@ -748,6 +745,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
@@ -811,13 +815,11 @@ var SchemaFormatters = class {
 	};
 	formatSchema = (parsedSchema, formatType = "base") => {
 		const schemaType = lodash.get(parsedSchema, ["schemaType"]) || lodash.get(parsedSchema, ["$parsed", "schemaType"]);
-		const formatterFn = lodash.get(this, [formatType, schemaType]);
-		return formatterFn?.(parsedSchema) || parsedSchema;
+		return lodash.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._(description$1).split(/\n/g).map((part) => part.trim()).compact().join(" ").valueOf();
 		return description$1.replace(/\n$/g, "");
 	};
@@ -826,8 +828,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}`);
 		}
@@ -987,7 +988,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"]);
@@ -1000,21 +1001,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;
@@ -1028,8 +1029,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;
@@ -1067,8 +1067,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 		const complexSchemaKeys = lodash.keys(this.schemaParser._complexSchemaParsers);
 		const schema = lodash.omit(structuredClone(noDiscriminatorSchema), complexSchemaKeys);
 		const schemaIsAny = this.schemaParserFabric.getInlineParseContent(structuredClone(schema)) === this.config.Ts.Keyword.Any;
-		const schemaIsEmpty = !lodash.keys(schema).length;
-		if (schemaIsEmpty || schemaIsAny) return null;
+		if (!lodash.keys(schema).length || schemaIsAny) return null;
 		const typeName = this.schemaUtils.resolveTypeName(this.typeName, {
 			prefixes: this.config.extractingOptions.discriminatorAbstractPrefix,
 			resolver: this.config.extractingOptions.discriminatorAbstractResolver
@@ -1397,56 +1396,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 = () => {
@@ -1483,13 +1462,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;
@@ -1587,8 +1564,7 @@ var SchemaUtils = class {
 		const required = lodash.uniq([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
 		const refData = this.getSchemaRefType(childSchema);
 		if (refData) {
-			const refObjectProperties = lodash.keys(refData.rawTypeData?.properties || {});
-			const existedRequiredKeys = refObjectProperties.filter((key) => required.includes(key));
+			const existedRequiredKeys = lodash.keys(refData.rawTypeData?.properties || {}).filter((key) => required.includes(key));
 			if (!existedRequiredKeys.length) return childSchema;
 			return {
 				...childSchema,
@@ -1596,8 +1572,7 @@ var SchemaUtils = class {
 			};
 		}
 		if (childSchema.properties) {
-			const childSchemaProperties = lodash.keys(childSchema.properties);
-			const existedRequiredKeys = childSchemaProperties.filter((key) => required.includes(key));
+			const existedRequiredKeys = lodash.keys(childSchema.properties).filter((key) => required.includes(key));
 			if (!existedRequiredKeys.length) return childSchema;
 			return {
 				required: lodash.uniq([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
@@ -1716,28 +1691,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();
 	};
 };
 
@@ -1890,14 +1862,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.uniq(lodash.compact([...extraContentTypes || [], ...lodash.flatten(lodash.map(requestInfo, (requestInfoData) => requestInfoData && lodash.keys(requestInfoData.content)))]));
@@ -1975,8 +1941,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,
@@ -2388,8 +2353,7 @@ var Request = class {
 		if (authToken) requestOptions.headers = { Authorization: authToken };
 		lodash.merge(requestOptions, options, this.config.requestOptions);
 		try {
-			const response = await fetch(url$2, requestOptions);
-			return await response.text();
+			return await (await fetch(url$2, requestOptions)).text();
 		} catch (error) {
 			const message = `error while fetching data from URL "${url$2}"`;
 			consola.error(message, error);
@@ -2480,8 +2444,7 @@ var SwaggerSchemaResolver = class {
 					usageRouteInfo.produces = lodash.uniq(lodash.compact([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
 				}
 				lodash.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);
 				});
 			});
 		});
@@ -2491,6 +2454,7 @@ var SwaggerSchemaResolver = class {
 //#endregion
 //#region src/templates-worker.ts
 const require = module.createRequire(import.meta.url);
+const eta = new Eta({ functionHeader: "const includeFile = options.includeFile;" });
 var TemplatesWorker = class {
 	config;
 	fileSystem;
@@ -2520,12 +2484,10 @@ var TemplatesWorker = class {
 	cropExtension = (path$2) => this.config.templateExtensions.reduce((path$3, ext) => path$3.endsWith(ext) ? path$3.replace(ext, "") : path$3, path$2);
 	getTemplateFullPath = (path_, fileName) => {
 		const raw = path$1.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(path$1.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
+		if (packageOrPath.startsWith("./") || packageOrPath.startsWith("../")) return require(path$1.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
 		return require(packageOrPath);
 	};
 	getTemplate = (name$1, fileName, path$2) => {
@@ -2555,8 +2517,7 @@ var TemplatesWorker = class {
 	};
 	findTemplateWithExt = (path$2) => {
 		const raw = this.cropExtension(path$2);
-		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.keys(this.config.templatePaths).find((key) => path_.startsWith(`@${key}`));
@@ -2571,18 +2532,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.render(eta.compile(template, { async: false }), {
 			...this.getRenderTemplateData(),
 			...configuration
-		}, {
-			async: false,
-			...options,
-			includeFile: (path$2, configuration$1, options$1 = {}) => {
-				return this.renderTemplate(this.getTemplateContent(path$2), configuration$1, options$1);
-			}
-		});
+		}, { includeFile: (path$2, configuration$1) => this.renderTemplate(this.getTemplateContent(path$2), configuration$1) });
 	};
 };
 
@@ -2673,10 +2628,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.startCase(name$1).replace(/ /g, "");
 		}
@@ -2696,8 +2648,7 @@ var FileSystem = class {
 	pathIsDir = (path$2) => {
 		if (!path$2) return false;
 		try {
-			const stat = fs.statSync(path$2);
-			return stat.isDirectory();
+			return fs.statSync(path$2).isDirectory();
 		} catch (e) {
 			return false;
 		}
@@ -2796,9 +2747,9 @@ var CodeGenProcess = class {
 				typeName
 			]), rawTypeData);
 		}));
+		this.schemaComponentsMap.discriminatorsFirst();
 		this.schemaComponentsMap.enumsFirst();
-		const componentsToParse = this.schemaComponentsMap.filter(lodash.compact(["schemas", this.config.extractResponses && "responses"]));
-		const parsedSchemas = componentsToParse.map((schemaComponent) => {
+		const parsedSchemas = this.schemaComponentsMap.filter(lodash.compact(["schemas", this.config.extractResponses && "responses"])).map((schemaComponent) => {
 			const parsed = this.schemaParserFabric.parseSchema(schemaComponent.rawTypeData, schemaComponent.typeName);
 			schemaComponent.typeData = parsed;
 			return parsed;
@@ -2833,8 +2784,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}`,
@@ -3115,8 +3065,7 @@ var TemplatesGenProcess = class {
 				const templateEtaPath = path.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,
@@ -3186,8 +3135,7 @@ var TemplatesGenProcess = class {
 async function generateTemplates(config) {
 	if (config.debug) consola.level = Number.MAX_SAFE_INTEGER;
 	if (config.silent) consola.level = 0;
-	const codeGenProcess = new TemplatesGenProcess(config);
-	return await codeGenProcess.start();
+	return await new TemplatesGenProcess(config).start();
 }
 
 //#endregion
@@ -3195,10 +3143,9 @@ async function generateTemplates(config) {
 async function generateApi(config) {
 	if (config.debug) consola.level = Number.MAX_SAFE_INTEGER;
 	if (config.silent) consola.level = 0;
-	const codeGenProcess = new CodeGenProcess(config);
-	return await codeGenProcess.start();
+	return await new CodeGenProcess(config).start();
 }
 
 //#endregion
 export { CodeGenConfig, HTTP_CLIENT, RequestContentKind, SCHEMA_TYPES, TemplatesGenConfig, constants_exports, generateApi, generateTemplates, package_default };
-//# sourceMappingURL=src-s8addnrG.js.map
+//# sourceMappingURL=src-LjX9fiRq.js.map