swagger-typescript-api 13.2.9 → 13.2.11

package/dist/{src-BGOGeWR6.js → src-BRCAbt5v.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.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";
@@ -219,12 +217,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",
@@ -233,19 +231,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";
@@ -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,
@@ -298,7 +295,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 */
@@ -337,7 +334,7 @@ const RESERVED_REQ_PARAMS_ARG_NAMES = [
 	"reqParams",
 	"httpParams"
 ];
-const SCHEMA_TYPES = {
+const SCHEMA_TYPES$1 = {
 	ARRAY: "array",
 	OBJECT: "object",
 	ENUM: "enum",
@@ -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
@@ -762,7 +766,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,
@@ -774,15 +778,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
@@ -790,13 +794,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.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,
@@ -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}`);
 		}
@@ -882,7 +883,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,
@@ -900,8 +901,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),
@@ -921,12 +922,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.compact(lodash.map(this.schema[complexType], "description"))[0] || ""),
-			content: this.config.Ts.IntersectionType(lodash.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.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
@@ -956,8 +957,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),
@@ -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,15 +1029,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.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.reduce(mappingPropertySchema.rawTypeData.$parsed.enum, (acc, key, index) => {
+		if (mappingPropertySchema?.rawTypeData?.$parsed?.type === SCHEMA_TYPES$1.ENUM) mappingPropertySchemaEnumKeysMap = lodash.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;
@@ -1053,9 +1053,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;
 				});
@@ -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
@@ -1094,7 +1093,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)) };
 	};
 };
@@ -1197,8 +1196,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,
@@ -1223,8 +1222,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),
@@ -1306,7 +1305,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()));
@@ -1314,8 +1313,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),
@@ -1396,67 +1395,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.debug("invalid enum schema", this.schema);
 				this.schema = { type: this.config.Ts.Keyword.Null };
@@ -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;
@@ -1571,8 +1548,8 @@ var SchemaUtils = class {
 			if (enumFieldType === this.config.Ts.Keyword.Undefined) return;
 			return internalCase(enumFieldType);
 		}
-		if (lodash.keys(schema.properties).length) return SCHEMA_TYPES.OBJECT;
-		if (schema.items) return SCHEMA_TYPES.ARRAY;
+		if (lodash.keys(schema.properties).length) return SCHEMA_TYPES$1.OBJECT;
+		if (schema.items) return SCHEMA_TYPES$1.ARRAY;
 		return null;
 	};
 	checkAndAddRequiredKeys = (schema, resultType) => {
@@ -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]),
@@ -1616,19 +1591,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.isEmpty(schema.enum) || !lodash.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.isEmpty(schema.properties)) return SCHEMA_TYPES.OBJECT;
-		if (schema.type === SCHEMA_TYPES.ARRAY) return SCHEMA_TYPES.ARRAY;
-		return SCHEMA_TYPES.PRIMITIVE;
+		if (!lodash.isEmpty(schema.enum) || !lodash.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.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;
@@ -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}`,
@@ -3033,6 +2983,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 {
@@ -3089,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,
@@ -3160,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
@@ -3169,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, TemplatesGenConfig, constants_exports, generateApi, generateTemplates, package_default };
-//# sourceMappingURL=src-BGOGeWR6.js.map
+export { CodeGenConfig, HTTP_CLIENT, RequestContentKind, SCHEMA_TYPES, TemplatesGenConfig, constants_exports, generateApi, generateTemplates, package_default };
+//# sourceMappingURL=src-BRCAbt5v.js.map