swagger-typescript-api 13.2.9 → 13.2.11

package/dist/{src-B-cU8h_Y.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.9";
+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";
@@ -245,12 +257,12 @@ var scripts = {
 };
 var dependencies = {
 	"@biomejs/js-api": "3.0.0",
-	"@biomejs/wasm-nodejs": "2.2.2",
+	"@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",
@@ -259,19 +271,19 @@ var dependencies = {
 	"typescript": "~5.9.2"
 };
 var devDependencies = {
-	"@biomejs/biome": "2.2.2",
+	"@biomejs/biome": "2.2.4",
 	"@changesets/changelog-github": "0.5.1",
-	"@changesets/cli": "2.29.6",
-	"@tsconfig/node18": "18.2.4",
+	"@changesets/cli": "2.29.7",
+	"@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.0",
+	"@types/node": "24.5.2",
 	"@types/swagger2openapi": "7.0.4",
-	"axios": "1.11.0",
+	"axios": "1.12.2",
 	"openapi-types": "12.1.3",
-	"tsdown": "0.14.2",
-	"typedoc": "0.28.11",
+	"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,
@@ -324,7 +335,7 @@ __export(constants_exports, {
 	RESERVED_PATH_ARG_NAMES: () => RESERVED_PATH_ARG_NAMES,
 	RESERVED_QUERY_ARG_NAMES: () => RESERVED_QUERY_ARG_NAMES,
 	RESERVED_REQ_PARAMS_ARG_NAMES: () => RESERVED_REQ_PARAMS_ARG_NAMES,
-	SCHEMA_TYPES: () => SCHEMA_TYPES
+	SCHEMA_TYPES: () => SCHEMA_TYPES$1
 });
 const DEFAULT_BODY_ARG_NAME = "data";
 const FILE_PREFIX = `/* eslint-disable */
@@ -363,7 +374,7 @@ const RESERVED_REQ_PARAMS_ARG_NAMES = [
 	"reqParams",
 	"httpParams"
 ];
-const SCHEMA_TYPES = {
+const SCHEMA_TYPES$1 = {
 	ARRAY: "array",
 	OBJECT: "object",
 	ENUM: "enum",
@@ -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
@@ -788,7 +806,7 @@ var SchemaFormatters = class {
 		this.templatesWorker = schemaParser.templatesWorker;
 	}
 	base = {
-		[SCHEMA_TYPES.ENUM]: (parsedSchema) => {
+		[SCHEMA_TYPES$1.ENUM]: (parsedSchema) => {
 			if (this.config.generateUnionEnums) return {
 				...parsedSchema,
 				$content: parsedSchema.content,
@@ -800,15 +818,15 @@ var SchemaFormatters = class {
 				content: this.config.Ts.EnumFieldsWrapper(parsedSchema.content)
 			};
 		},
-		[SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
-			if (parsedSchema.nullable) return this.inline[SCHEMA_TYPES.OBJECT](parsedSchema);
+		[SCHEMA_TYPES$1.OBJECT]: (parsedSchema) => {
+			if (parsedSchema.nullable) return this.inline[SCHEMA_TYPES$1.OBJECT](parsedSchema);
 			return {
 				...parsedSchema,
 				$content: parsedSchema.content,
 				content: this.formatObjectContent(parsedSchema.content)
 			};
 		},
-		[SCHEMA_TYPES.PRIMITIVE]: (parsedSchema) => {
+		[SCHEMA_TYPES$1.PRIMITIVE]: (parsedSchema) => {
 			return {
 				...parsedSchema,
 				$content: parsedSchema.content
@@ -816,13 +834,13 @@ var SchemaFormatters = class {
 		}
 	};
 	inline = {
-		[SCHEMA_TYPES.ENUM]: (parsedSchema) => {
+		[SCHEMA_TYPES$1.ENUM]: (parsedSchema) => {
 			return {
 				...parsedSchema,
 				content: parsedSchema.$ref ? parsedSchema.typeName : this.config.Ts.UnionType(lodash.default.compact([...parsedSchema.content.map(({ value }) => `${value}`), parsedSchema.nullable && this.config.Ts.Keyword.Null])) || this.config.Ts.Keyword.Any
 			};
 		},
-		[SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
+		[SCHEMA_TYPES$1.OBJECT]: (parsedSchema) => {
 			if (typeof parsedSchema.content === "string") return {
 				...parsedSchema,
 				typeIdentifier: this.config.Ts.Keyword.Type,
@@ -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}`);
 		}
@@ -908,7 +923,7 @@ var ArraySchemaParser = class extends MonoSchemaParser {
 	parse() {
 		let contentType;
 		const { type: type$1, description: description$1, items } = this.schema || {};
-		if (Array.isArray(items) && type$1 === SCHEMA_TYPES.ARRAY) {
+		if (Array.isArray(items) && type$1 === SCHEMA_TYPES$1.ARRAY) {
 			const tupleContent = [];
 			for (const item of items) tupleContent.push(this.schemaParserFabric.createSchemaParser({
 				schema: item,
@@ -926,8 +941,8 @@ var ArraySchemaParser = class extends MonoSchemaParser {
 			...typeof this.schema === "object" ? this.schema : {},
 			$schemaPath: this.schemaPath.slice(),
 			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.PRIMITIVE,
-			type: SCHEMA_TYPES.PRIMITIVE,
+			schemaType: SCHEMA_TYPES$1.PRIMITIVE,
+			type: SCHEMA_TYPES$1.PRIMITIVE,
 			typeIdentifier: this.config.Ts.Keyword.Type,
 			name: this.typeName,
 			description: this.schemaFormatters.formatDescription(description$1),
@@ -947,12 +962,12 @@ var ComplexSchemaParser = class extends MonoSchemaParser {
 			...typeof this.schema === "object" ? this.schema : {},
 			$schemaPath: this.schemaPath.slice(),
 			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.COMPLEX,
-			type: SCHEMA_TYPES.PRIMITIVE,
+			schemaType: SCHEMA_TYPES$1.COMPLEX,
+			type: SCHEMA_TYPES$1.PRIMITIVE,
 			typeIdentifier: this.config.Ts.Keyword.Type,
 			name: this.typeName,
 			description: this.schemaFormatters.formatDescription(this.schema.description || lodash.default.compact(lodash.default.map(this.schema[complexType], "description"))[0] || ""),
-			content: this.config.Ts.IntersectionType(lodash.default.compact([this.config.Ts.ExpressionGroup(complexSchemaContent), this.schemaUtils.getInternalSchemaType(simpleSchema) === SCHEMA_TYPES.OBJECT && this.config.Ts.ExpressionGroup(this.schemaParserFabric.createSchemaParser({
+			content: this.config.Ts.IntersectionType(lodash.default.compact([this.config.Ts.ExpressionGroup(complexSchemaContent), this.schemaUtils.getInternalSchemaType(simpleSchema) === SCHEMA_TYPES$1.OBJECT && this.config.Ts.ExpressionGroup(this.schemaParserFabric.createSchemaParser({
 				schema: simpleSchema,
 				schemaPath: this.schemaPath
 			}).getInlineParseContent())])) || this.config.Ts.Keyword.Any
@@ -982,8 +997,8 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 			...typeof this.schema === "object" ? this.schema : {},
 			$schemaPath: this.schemaPath.slice(),
 			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.COMPLEX,
-			type: SCHEMA_TYPES.PRIMITIVE,
+			schemaType: SCHEMA_TYPES$1.COMPLEX,
+			type: SCHEMA_TYPES$1.PRIMITIVE,
 			typeIdentifier: ts.Keyword.Type,
 			name: this.typeName,
 			description: this.schemaFormatters.formatDescription(this.schema.description),
@@ -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,15 +1069,14 @@ 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;
 		let mappingPropertySchemaEnumKeysMap = {};
 		let mappingPropertySchema = lodash.default.get(abstractSchemaStruct?.component?.rawTypeData, ["properties", discPropertyName]);
 		if (this.schemaUtils.isRefSchema(mappingPropertySchema)) mappingPropertySchema = this.schemaUtils.getSchemaRefType(mappingPropertySchema);
-		if (mappingPropertySchema?.rawTypeData?.$parsed?.type === SCHEMA_TYPES.ENUM) mappingPropertySchemaEnumKeysMap = lodash.default.reduce(mappingPropertySchema.rawTypeData.$parsed.enum, (acc, key, index) => {
+		if (mappingPropertySchema?.rawTypeData?.$parsed?.type === SCHEMA_TYPES$1.ENUM) mappingPropertySchemaEnumKeysMap = lodash.default.reduce(mappingPropertySchema.rawTypeData.$parsed.enum, (acc, key, index) => {
 			const enumKey = mappingPropertySchema.rawTypeData.$parsed.content[index].key;
 			acc[key] = ts.EnumUsageKey(mappingPropertySchema.rawTypeData.$parsed.typeName, enumKey);
 			return acc;
@@ -1079,9 +1093,9 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 						...schema,
 						$ref: abstractSchemaStruct.component.$ref
 					};
-					if (this.schemaUtils.getInternalSchemaType(schema) === SCHEMA_TYPES.OBJECT) for (const schemaPropertyName in schema.properties) {
+					if (this.schemaUtils.getInternalSchemaType(schema) === SCHEMA_TYPES$1.OBJECT) for (const schemaPropertyName in schema.properties) {
 						const schemaProperty = schema.properties[schemaPropertyName];
-						if (schemaPropertyName === discPropertyName && this.schemaUtils.getInternalSchemaType(schemaProperty) === SCHEMA_TYPES.ENUM && schemaProperty.enum.length === 1 && mappingPropertySchemaEnumKeysMap[schemaProperty.enum[0]]) schema.properties[schemaPropertyName] = this.schemaParserFabric.createSchema({ content: mappingPropertySchemaEnumKeysMap[schemaProperty.enum[0]] });
+						if (schemaPropertyName === discPropertyName && this.schemaUtils.getInternalSchemaType(schemaProperty) === SCHEMA_TYPES$1.ENUM && schemaProperty.enum.length === 1 && mappingPropertySchemaEnumKeysMap[schemaProperty.enum[0]]) schema.properties[schemaPropertyName] = this.schemaParserFabric.createSchema({ content: mappingPropertySchemaEnumKeysMap[schemaProperty.enum[0]] });
 					}
 					return schema;
 				});
@@ -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
@@ -1120,7 +1133,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 	createComplexSchemaStruct = () => {
 		const ts = this.config.Ts;
 		const complexType = this.schemaUtils.getComplexType(this.schema);
-		if (complexType === SCHEMA_TYPES.COMPLEX_UNKNOWN) return null;
+		if (complexType === SCHEMA_TYPES$1.COMPLEX_UNKNOWN) return null;
 		return { content: ts.ExpressionGroup(this.schemaParser._complexSchemaParsers[complexType](this.schema)) };
 	};
 };
@@ -1223,8 +1236,8 @@ var EnumSchemaParser = class extends MonoSchemaParser {
 			$ref,
 			typeName: this.typeName || $ref && refType.typeName || null,
 			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.ENUM,
-			type: SCHEMA_TYPES.ENUM,
+			schemaType: SCHEMA_TYPES$1.ENUM,
+			type: SCHEMA_TYPES$1.ENUM,
 			keyType,
 			typeIdentifier: this.config.generateUnionEnums ? this.config.Ts.Keyword.Type : this.config.Ts.Keyword.Enum,
 			name: this.typeName,
@@ -1249,8 +1262,8 @@ var ObjectSchemaParser = class extends MonoSchemaParser {
 			...typeof this.schema === "object" ? this.schema : {},
 			$schemaPath: this.schemaPath.slice(),
 			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.OBJECT,
-			type: SCHEMA_TYPES.OBJECT,
+			schemaType: SCHEMA_TYPES$1.OBJECT,
+			type: SCHEMA_TYPES$1.OBJECT,
 			typeIdentifier: this.config.Ts.Keyword.Interface,
 			name: this.typeName,
 			description: this.schemaFormatters.formatDescription(this.schema.description),
@@ -1332,7 +1345,7 @@ var PrimitiveSchemaParser = class extends MonoSchemaParser {
 			...typeof this.schema === "object" ? this.schema : {},
 			oneOf: type$1.map((type$2) => ({ type: type$2 }))
 		});
-		if (Array.isArray(items) && type$1 === SCHEMA_TYPES.ARRAY) contentType = this.config.Ts.Tuple(items.map((item) => this.schemaParserFabric.createSchemaParser({
+		if (Array.isArray(items) && type$1 === SCHEMA_TYPES$1.ARRAY) contentType = this.config.Ts.Tuple(items.map((item) => this.schemaParserFabric.createSchemaParser({
 			schema: item,
 			schemaPath: this.schemaPath
 		}).getInlineParseContent()));
@@ -1340,8 +1353,8 @@ var PrimitiveSchemaParser = class extends MonoSchemaParser {
 			...typeof this.schema === "object" ? this.schema : {},
 			$schemaPath: this.schemaPath.slice(),
 			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.PRIMITIVE,
-			type: SCHEMA_TYPES.PRIMITIVE,
+			schemaType: SCHEMA_TYPES$1.PRIMITIVE,
+			type: SCHEMA_TYPES$1.PRIMITIVE,
 			typeIdentifier: this.config.Ts.Keyword.Type,
 			name: this.typeName,
 			description: this.schemaFormatters.formatDescription(description$1),
@@ -1422,67 +1435,47 @@ var SchemaParser = class {
 		this.schemaPath = [...schemaPath || []];
 	}
 	_complexSchemaParsers = {
-		[SCHEMA_TYPES.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();
+		[SCHEMA_TYPES$1.COMPLEX_ONE_OF]: (schema) => {
+			return new (this.config.schemaParsers.complexOneOf || OneOfSchemaParser)(this, schema, null, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.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();
+		[SCHEMA_TYPES$1.COMPLEX_ALL_OF]: (schema) => {
+			return new (this.config.schemaParsers.complexAllOf || AllOfSchemaParser)(this, schema, null, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.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();
+		[SCHEMA_TYPES$1.COMPLEX_ANY_OF]: (schema) => {
+			return new (this.config.schemaParsers.complexAnyOf || AnyOfSchemaParser)(this, schema, null, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.COMPLEX_NOT]: (schema) => {
-			const SchemaParser$1 = this.config.schemaParsers.complexNot || NotSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, null, this.schemaPath);
-			return schemaParser.parse();
+		[SCHEMA_TYPES$1.COMPLEX_NOT]: (schema) => {
+			return new (this.config.schemaParsers.complexNot || NotSchemaParser)(this, schema, null, this.schemaPath).parse();
 		}
 	};
 	_baseSchemaParsers = {
-		[SCHEMA_TYPES.ENUM]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.enum || EnumSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+		[SCHEMA_TYPES$1.ENUM]: (schema, typeName) => {
+			return new (this.config.schemaParsers.enum || EnumSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.OBJECT]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.object || ObjectSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+		[SCHEMA_TYPES$1.OBJECT]: (schema, typeName) => {
+			return new (this.config.schemaParsers.object || ObjectSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.COMPLEX]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.complex || ComplexSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+		[SCHEMA_TYPES$1.COMPLEX]: (schema, typeName) => {
+			return new (this.config.schemaParsers.complex || ComplexSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.PRIMITIVE]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.primitive || PrimitiveSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+		[SCHEMA_TYPES$1.PRIMITIVE]: (schema, typeName) => {
+			return new (this.config.schemaParsers.primitive || PrimitiveSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.DISCRIMINATOR]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.discriminator || DiscriminatorSchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+		[SCHEMA_TYPES$1.DISCRIMINATOR]: (schema, typeName) => {
+			return new (this.config.schemaParsers.discriminator || DiscriminatorSchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		},
-		[SCHEMA_TYPES.ARRAY]: (schema, typeName) => {
-			const SchemaParser$1 = this.config.schemaParsers.array || ArraySchemaParser;
-			const schemaParser = new SchemaParser$1(this, schema, typeName, this.schemaPath);
-			return schemaParser.parse();
+		[SCHEMA_TYPES$1.ARRAY]: (schema, typeName) => {
+			return new (this.config.schemaParsers.array || ArraySchemaParser)(this, schema, typeName, this.schemaPath).parse();
 		}
 	};
 	parseSchema = () => {
-		if (!this.schema) return this._baseSchemaParsers[SCHEMA_TYPES.PRIMITIVE](null, this.typeName);
+		if (!this.schema) return this._baseSchemaParsers[SCHEMA_TYPES$1.PRIMITIVE](null, this.typeName);
 		let schemaType = null;
 		let parsedSchema = null;
 		if (typeof this.schema === "string") return this.schema;
 		if (!this.schema.$parsed) {
 			if (!this.typeName && this.schemaUtils.isRefSchema(this.schema)) this.typeName = this.schemaUtils.getSchemaType(this.schema);
-			if (this.schema.items && !Array.isArray(this.schema.items) && !this.schema.type) this.schema.type = SCHEMA_TYPES.ARRAY;
+			if (this.schema.items && !Array.isArray(this.schema.items) && !this.schema.type) this.schema.type = SCHEMA_TYPES$1.ARRAY;
 			if (Array.isArray(this.schema.enum) && this.schema.enum.length === 1 && this.schema.enum[0] == null) {
 				consola.consola.debug("invalid enum schema", this.schema);
 				this.schema = { type: this.config.Ts.Keyword.Null };
@@ -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;
@@ -1597,8 +1588,8 @@ var SchemaUtils = class {
 			if (enumFieldType === this.config.Ts.Keyword.Undefined) return;
 			return internalCase(enumFieldType);
 		}
-		if (lodash.default.keys(schema.properties).length) return SCHEMA_TYPES.OBJECT;
-		if (schema.items) return SCHEMA_TYPES.ARRAY;
+		if (lodash.default.keys(schema.properties).length) return SCHEMA_TYPES$1.OBJECT;
+		if (schema.items) return SCHEMA_TYPES$1.ARRAY;
 		return null;
 	};
 	checkAndAddRequiredKeys = (schema, resultType) => {
@@ -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]),
@@ -1642,19 +1631,19 @@ var SchemaUtils = class {
 		return this.config.componentTypeNameResolver.resolve([...(prefixes || []).map((prefix) => pascalCase(`${prefix} ${typeName}`)), ...(suffixes || []).map((suffix) => pascalCase(`${typeName} ${suffix}`))], shouldReserve);
 	};
 	getComplexType = (schema) => {
-		if (schema.oneOf) return SCHEMA_TYPES.COMPLEX_ONE_OF;
-		if (schema.allOf) return SCHEMA_TYPES.COMPLEX_ALL_OF;
-		if (schema.anyOf) return SCHEMA_TYPES.COMPLEX_ANY_OF;
-		if (schema.not) return SCHEMA_TYPES.COMPLEX_NOT;
-		return SCHEMA_TYPES.COMPLEX_UNKNOWN;
+		if (schema.oneOf) return SCHEMA_TYPES$1.COMPLEX_ONE_OF;
+		if (schema.allOf) return SCHEMA_TYPES$1.COMPLEX_ALL_OF;
+		if (schema.anyOf) return SCHEMA_TYPES$1.COMPLEX_ANY_OF;
+		if (schema.not) return SCHEMA_TYPES$1.COMPLEX_NOT;
+		return SCHEMA_TYPES$1.COMPLEX_UNKNOWN;
 	};
 	getInternalSchemaType = (schema) => {
-		if (!lodash.default.isEmpty(schema.enum) || !lodash.default.isEmpty(this.getEnumNames(schema))) return SCHEMA_TYPES.ENUM;
-		if (schema.discriminator) return SCHEMA_TYPES.DISCRIMINATOR;
-		if (schema.allOf || schema.oneOf || schema.anyOf || schema.not) return SCHEMA_TYPES.COMPLEX;
-		if (!lodash.default.isEmpty(schema.properties)) return SCHEMA_TYPES.OBJECT;
-		if (schema.type === SCHEMA_TYPES.ARRAY) return SCHEMA_TYPES.ARRAY;
-		return SCHEMA_TYPES.PRIMITIVE;
+		if (!lodash.default.isEmpty(schema.enum) || !lodash.default.isEmpty(this.getEnumNames(schema))) return SCHEMA_TYPES$1.ENUM;
+		if (schema.discriminator) return SCHEMA_TYPES$1.DISCRIMINATOR;
+		if (schema.allOf || schema.oneOf || schema.anyOf || schema.not) return SCHEMA_TYPES$1.COMPLEX;
+		if (!lodash.default.isEmpty(schema.properties)) return SCHEMA_TYPES$1.OBJECT;
+		if (schema.type === SCHEMA_TYPES$1.ARRAY) return SCHEMA_TYPES$1.ARRAY;
+		return SCHEMA_TYPES$1.PRIMITIVE;
 	};
 	getSchemaType = (schema) => {
 		if (!schema) return this.config.Ts.Keyword.Any;
@@ -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}`,
@@ -3059,6 +3023,32 @@ var CodeGenProcess = class {
 	};
 };
 
+//#endregion
+//#region types/index.ts
+let RequestContentKind = /* @__PURE__ */ function(RequestContentKind$1) {
+	RequestContentKind$1["JSON"] = "JSON";
+	RequestContentKind$1["URL_ENCODED"] = "URL_ENCODED";
+	RequestContentKind$1["FORM_DATA"] = "FORM_DATA";
+	RequestContentKind$1["IMAGE"] = "IMAGE";
+	RequestContentKind$1["OTHER"] = "OTHER";
+	RequestContentKind$1["TEXT"] = "TEXT";
+	return RequestContentKind$1;
+}({});
+let SCHEMA_TYPES = /* @__PURE__ */ function(SCHEMA_TYPES$2) {
+	SCHEMA_TYPES$2["ARRAY"] = "array";
+	SCHEMA_TYPES$2["OBJECT"] = "object";
+	SCHEMA_TYPES$2["ENUM"] = "enum";
+	SCHEMA_TYPES$2["REF"] = "$ref";
+	SCHEMA_TYPES$2["PRIMITIVE"] = "primitive";
+	SCHEMA_TYPES$2["COMPLEX"] = "complex";
+	SCHEMA_TYPES$2["COMPLEX_ONE_OF"] = "oneOf";
+	SCHEMA_TYPES$2["COMPLEX_ANY_OF"] = "anyOf";
+	SCHEMA_TYPES$2["COMPLEX_ALL_OF"] = "allOf";
+	SCHEMA_TYPES$2["COMPLEX_NOT"] = "not";
+	SCHEMA_TYPES$2["COMPLEX_UNKNOWN"] = "__unknown";
+	return SCHEMA_TYPES$2;
+}({});
+
 //#endregion
 //#region src/commands/generate-templates/configuration.ts
 var TemplatesGenConfig = class {
@@ -3115,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,
@@ -3186,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
@@ -3195,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
@@ -3212,6 +3199,18 @@ Object.defineProperty(exports, 'HTTP_CLIENT', {
     return HTTP_CLIENT;
   }
 });
+Object.defineProperty(exports, 'RequestContentKind', {
+  enumerable: true,
+  get: function () {
+    return RequestContentKind;
+  }
+});
+Object.defineProperty(exports, 'SCHEMA_TYPES', {
+  enumerable: true,
+  get: function () {
+    return SCHEMA_TYPES;
+  }
+});
 Object.defineProperty(exports, 'TemplatesGenConfig', {
   enumerable: true,
   get: function () {
@@ -3248,4 +3247,4 @@ Object.defineProperty(exports, 'package_default', {
     return package_default;
   }
 });
-//# sourceMappingURL=src-B-cU8h_Y.cjs.map
+//# sourceMappingURL=src-D2FYrO2h.cjs.map