swagger-typescript-api 13.2.8 → 13.2.10

package/dist/{src-4gUT3jPg.js → src-s8addnrG.js}

@@ -1,20 +1,14 @@
 import { __export } from "./chunk-Cl8Af3a2.js";
+import * as module from "node:module";
 import { consola } from "consola";
 import lodash from "lodash";
-import * as typescript$3 from "typescript";
-import * as typescript$2 from "typescript";
-import * as typescript$1 from "typescript";
 import * as typescript from "typescript";
-import * as path$3 from "node:path";
-import * as path$2 from "node:path";
 import * as path$1 from "node:path";
 import path from "node:path";
 import { Biome, Distribution } from "@biomejs/js-api";
-import * as nanoid$1 from "nanoid";
 import * as nanoid from "nanoid";
 import * as yaml from "js-yaml";
 import * as swagger2openapi from "swagger2openapi";
-import * as url$2 from "node:url";
 import * as url$1 from "node:url";
 import url from "node:url";
 import * as Eta from "eta";
@@ -29,11 +23,11 @@ var CodeFormatter = class {
 	removeUnusedImports = (content) => {
 		const tempFileName = "file.ts";
 		const host = new TsLanguageServiceHost(tempFileName, content);
-		const languageService = typescript$3.createLanguageService(host);
+		const languageService = typescript.createLanguageService(host);
 		const fileTextChanges = languageService.organizeImports({
 			type: "file",
 			fileName: tempFileName
-		}, { newLineCharacter: typescript$3.sys.newLine }, void 0)[0];
+		}, { newLineCharacter: typescript.sys.newLine }, void 0)[0];
 		if (fileTextChanges?.textChanges.length) return fileTextChanges.textChanges.reduceRight((content$1, { span, newText }) => `${content$1.slice(0, span.start)}${newText}${content$1.slice(span.start + span.length)}`, content);
 		return content;
 	};
@@ -44,8 +38,8 @@ var CodeFormatter = class {
 			files: { maxSize: Number.MAX_SAFE_INTEGER },
 			formatter: { indentStyle: "space" }
 		});
-		const formatted = biome.formatContent(biomeProject.projectKey, content, { filePath: path$3.format({
-			name: nanoid$1.nanoid(),
+		const formatted = biome.formatContent(biomeProject.projectKey, content, { filePath: path$1.format({
+			name: nanoid.nanoid(),
 			ext: "ts"
 		}) });
 		return formatted.content;
@@ -63,11 +57,11 @@ var TsLanguageServiceHost = class {
 	constructor(fileName, content) {
 		this.fileName = fileName;
 		this.content = content;
-		const tsconfig = typescript$3.findConfigFile(fileName, typescript$3.sys.fileExists);
-		this.compilerOptions = tsconfig ? typescript$3.convertCompilerOptionsFromJson(typescript$3.readConfigFile(tsconfig, typescript$3.sys.readFile).config.compilerOptions, "").options : typescript$3.getDefaultCompilerOptions();
+		const tsconfig = typescript.findConfigFile(fileName, typescript.sys.fileExists);
+		this.compilerOptions = tsconfig ? typescript.convertCompilerOptionsFromJson(typescript.readConfigFile(tsconfig, typescript.sys.readFile).config.compilerOptions, "").options : typescript.getDefaultCompilerOptions();
 	}
 	getNewLine() {
-		return "newLine" in typescript$3.sys ? typescript$3.sys.newLine : "\n";
+		return "newLine" in typescript.sys ? typescript.sys.newLine : "\n";
 	}
 	getScriptFileNames() {
 		return [this.fileName];
@@ -76,23 +70,23 @@ var TsLanguageServiceHost = class {
 		return this.compilerOptions;
 	}
 	getDefaultLibFileName() {
-		return typescript$3.getDefaultLibFileName(this.getCompilationSettings());
+		return typescript.getDefaultLibFileName(this.getCompilationSettings());
 	}
 	getCurrentDirectory() {
 		return process.cwd();
 	}
 	getScriptVersion() {
-		return typescript$3.version;
+		return typescript.version;
 	}
 	getScriptSnapshot() {
-		return typescript$3.ScriptSnapshot.fromString(this.content);
+		return typescript.ScriptSnapshot.fromString(this.content);
 	}
 	readFile(fileName, encoding) {
 		if (fileName === this.fileName) return this.content;
-		return typescript$3.sys.readFile(fileName, encoding);
+		return typescript.sys.readFile(fileName, encoding);
 	}
-	fileExists(path$4) {
-		return typescript$3.sys.fileExists(path$4);
+	fileExists(path$2) {
+		return typescript.sys.fileExists(path$2);
 	}
 };
 
@@ -162,7 +156,7 @@ const getRandomInt = (min = 0, max = 1) => {
 var ComponentTypeNameResolver = class extends NameResolver {
 	counter = 1;
 	fallbackNameCounter = 1;
-	countersByVariant = new Map();
+	countersByVariant = /* @__PURE__ */ new Map();
 	constructor(config, reservedNames) {
 		super(config, reservedNames, (variants) => {
 			const randomVariant = variants[getRandomInt(0, variants.length - 1)];
@@ -184,7 +178,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.8";
+var version = "13.2.10";
 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";
@@ -204,7 +198,7 @@ var exports = { ".": {
 	}
 } };
 var main = "./dist/lib.cjs";
-var module = "./dist/lib.js";
+var module$1 = "./dist/lib.js";
 var types = "./dist/lib.d.cts";
 var bin = {
 	"sta": "./dist/cli.js",
@@ -224,10 +218,10 @@ var scripts = {
 	"typedoc": "typedoc"
 };
 var dependencies = {
-	"@biomejs/js-api": "2.0.3",
-	"@biomejs/wasm-nodejs": "2.1.4",
+	"@biomejs/js-api": "3.0.0",
+	"@biomejs/wasm-nodejs": "2.2.4",
 	"@types/swagger-schema-official": "^2.0.25",
-	"c12": "^3.0.4",
+	"c12": "^3.2.0",
 	"citty": "^0.1.6",
 	"consola": "^3.4.2",
 	"eta": "^2.2.0",
@@ -239,22 +233,22 @@ var dependencies = {
 	"typescript": "~5.9.2"
 };
 var devDependencies = {
-	"@biomejs/biome": "2.1.4",
+	"@biomejs/biome": "2.2.4",
 	"@changesets/changelog-github": "0.5.1",
-	"@changesets/cli": "2.29.5",
-	"@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.2.0",
+	"@types/node": "24.3.2",
 	"@types/swagger2openapi": "7.0.4",
-	"axios": "1.11.0",
+	"axios": "1.12.1",
 	"openapi-types": "12.1.3",
-	"tsdown": "0.13.4",
-	"typedoc": "0.28.9",
+	"tsdown": "0.15.1",
+	"typedoc": "0.28.12",
 	"vitest": "3.2.4"
 };
-var packageManager = "yarn@4.9.2";
+var packageManager = "yarn@4.9.4";
 var engines = { "node": ">=20" };
 var publishConfig = {
 	"access": "public",
@@ -278,7 +272,7 @@ var package_default = {
 	type,
 	exports,
 	main,
-	module,
+	module: module$1,
 	types,
 	bin,
 	files,
@@ -304,7 +298,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 */
@@ -343,7 +337,7 @@ const RESERVED_REQ_PARAMS_ARG_NAMES = [
 	"reqParams",
 	"httpParams"
 ];
-const SCHEMA_TYPES = {
+const SCHEMA_TYPES$1 = {
 	ARRAY: "array",
 	OBJECT: "object",
 	ENUM: "enum",
@@ -433,7 +427,7 @@ var CodeGenConfig = class {
 		httpClient: "http-client",
 		outOfModuleApi: "Common"
 	};
-	routeNameDuplicatesMap = new Map();
+	routeNameDuplicatesMap = /* @__PURE__ */ new Map();
 	hooks = {
 		onPreBuildRoutePath: (_routePath) => void 0,
 		onBuildRoutePath: (_routeData) => void 0,
@@ -543,10 +537,10 @@ var CodeGenConfig = class {
 		]
 	};
 	compilerTsConfig = {
-		module: typescript$2.ModuleKind.ESNext,
+		module: typescript.ModuleKind.ESNext,
 		noImplicitReturns: true,
 		alwaysStrict: true,
-		target: typescript$2.ScriptTarget.ESNext,
+		target: typescript.ScriptTarget.ESNext,
 		declaration: true,
 		noImplicitAny: false,
 		sourceMap: false,
@@ -700,6 +694,7 @@ var CodeGenConfig = class {
 	}
 	update = (update) => {
 		objectAssign(this, update);
+		if (this.enumNamesAsValues) this.extractEnums = true;
 	};
 };
 
@@ -767,7 +762,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,
@@ -779,15 +774,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
@@ -795,13 +790,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,
@@ -887,7 +882,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,
@@ -905,8 +900,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),
@@ -926,12 +921,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
@@ -961,8 +956,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),
@@ -1041,7 +1036,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 		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;
@@ -1058,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;
 				});
@@ -1099,7 +1094,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)) };
 	};
 };
@@ -1156,9 +1151,19 @@ var EnumSchemaParser = class extends MonoSchemaParser {
 		let content = null;
 		const formatValue = (value) => {
 			if (value === null) return this.config.Ts.NullValue(value);
-			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "number" }))) return this.config.Ts.NumberValue(value);
-			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "boolean" }))) return this.config.Ts.BooleanValue(value);
-			return this.config.Ts.StringValue(value);
+			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "number" }))) {
+				const maybeNumber = typeof value === "number" ? value : Number(value);
+				if (!Number.isNaN(maybeNumber)) return this.config.Ts.NumberValue(maybeNumber);
+			}
+			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "boolean" }))) {
+				if (typeof value === "boolean") return this.config.Ts.BooleanValue(value);
+				if (value === "true" || value === "false") return this.config.Ts.BooleanValue(value === "true");
+			}
+			switch (typeof value) {
+				case "number": return this.config.Ts.NumberValue(value);
+				case "boolean": return this.config.Ts.BooleanValue(value);
+				default: return this.config.Ts.StringValue(value);
+			}
 		};
 		if (Array.isArray(enumNames) && lodash.size(enumNames)) content = enumNames.map((enumName, index) => {
 			const enumValue = lodash.get(this.schema.enum, index);
@@ -1192,8 +1197,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,
@@ -1218,8 +1223,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),
@@ -1301,7 +1306,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()));
@@ -1309,8 +1314,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),
@@ -1391,67 +1396,67 @@ var SchemaParser = class {
 		this.schemaPath = [...schemaPath || []];
 	}
 	_complexSchemaParsers = {
-		[SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema) => {
+		[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();
 		},
-		[SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema) => {
+		[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();
 		},
-		[SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema) => {
+		[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();
 		},
-		[SCHEMA_TYPES.COMPLEX_NOT]: (schema) => {
+		[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();
 		}
 	};
 	_baseSchemaParsers = {
-		[SCHEMA_TYPES.ENUM]: (schema, typeName) => {
+		[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();
 		},
-		[SCHEMA_TYPES.OBJECT]: (schema, typeName) => {
+		[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();
 		},
-		[SCHEMA_TYPES.COMPLEX]: (schema, typeName) => {
+		[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();
 		},
-		[SCHEMA_TYPES.PRIMITIVE]: (schema, typeName) => {
+		[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();
 		},
-		[SCHEMA_TYPES.DISCRIMINATOR]: (schema, typeName) => {
+		[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();
 		},
-		[SCHEMA_TYPES.ARRAY]: (schema, typeName) => {
+		[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();
 		}
 	};
 	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 };
@@ -1566,8 +1571,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) => {
@@ -1611,26 +1616,26 @@ 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;
 		const refTypeInfo = this.getSchemaRefType(schema);
 		if (refTypeInfo) return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, this.typeNameFormatter.format(refTypeInfo.typeName)));
 		let resultType;
-		if (this.isConstantSchema(schema)) resultType = this.formatJsValue(schema.const);
+		if (this.isConstantSchema(schema) && !schema.enum) resultType = this.formatJsValue(schema.const);
 		else {
 			const primitiveType = this.getSchemaPrimitiveType(schema);
 			if (primitiveType == null) return this.config.Ts.Keyword.Any;
@@ -1654,10 +1659,9 @@ var SchemaUtils = class {
 			case "string": return this.config.Ts.StringValue(value);
 			case "boolean": return this.config.Ts.BooleanValue(value);
 			case "number": return this.config.Ts.NumberValue(value);
-			default: {
+			default:
 				if (value === null) return this.config.Ts.NullValue(value);
 				return this.config.Ts.Keyword.Any;
-			}
 		}
 	};
 };
@@ -2056,7 +2060,7 @@ var SchemaRoutes = class {
 		};
 	};
 	createRequestParamsSchema = ({ queryParams, queryObjectSchema, pathArgsSchemas, extractRequestParams, routeName }) => {
-		if (!queryParams || !queryParams.length) return null;
+		if ((!queryParams || !queryParams.length) && (!pathArgsSchemas || !pathArgsSchemas.length)) return null;
 		const pathParams = pathArgsSchemas.reduce((acc, pathArgSchema) => {
 			if (pathArgSchema.name) acc[pathArgSchema.name] = {
 				...pathArgSchema,
@@ -2349,8 +2353,8 @@ var SchemaRoutes = class {
 var SchemaWalker = class {
 	config;
 	swaggerSchemaResolver;
-	schemas = new Map();
-	caches = new Map();
+	schemas = /* @__PURE__ */ new Map();
+	caches = /* @__PURE__ */ new Map();
 	constructor(config, swaggerSchemaResolver) {
 		this.config = config;
 		this.swaggerSchemaResolver = swaggerSchemaResolver;
@@ -2365,8 +2369,8 @@ var SchemaWalker = class {
 		return ref.startsWith("http://") || ref.startsWith("https://");
 	};
 	_getRefDataFromSchema = (schema, ref) => {
-		const path$4 = ref.replace("#", "").split("/");
-		const refData = lodash.get(schema, path$4);
+		const path$2 = ref.replace("#", "").split("/");
+		const refData = lodash.get(schema, path$2);
 		if (refData) this.caches.set(ref, refData);
 		return refData;
 	};
@@ -2379,15 +2383,15 @@ var Request = class {
 	constructor(config) {
 		this.config = config;
 	}
-	async download({ url: url$3, authToken,...options }) {
+	async download({ url: url$2, authToken,...options }) {
 		const requestOptions = {};
 		if (authToken) requestOptions.headers = { Authorization: authToken };
 		lodash.merge(requestOptions, options, this.config.requestOptions);
 		try {
-			const response = await fetch(url$3, requestOptions);
+			const response = await fetch(url$2, requestOptions);
 			return await response.text();
 		} catch (error) {
-			const message = `error while fetching data from URL "${url$3}"`;
+			const message = `error while fetching data from URL "${url$2}"`;
 			consola.error(message, error);
 			return message;
 		}
@@ -2406,9 +2410,9 @@ var SwaggerSchemaResolver = class {
 		this.request = new Request(config);
 	}
 	async create() {
-		const { spec, patch, input, url: url$3, authorizationToken } = this.config;
+		const { spec, patch, input, url: url$2, authorizationToken } = this.config;
 		if (spec) return await this.convertSwaggerObject(spec, { patch });
-		const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url$3, authorizationToken);
+		const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url$2, authorizationToken);
 		const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
 		return await this.convertSwaggerObject(swaggerSchemaObject, { patch });
 	}
@@ -2486,6 +2490,7 @@ var SwaggerSchemaResolver = class {
 
 //#endregion
 //#region src/templates-worker.ts
+const require = module.createRequire(import.meta.url);
 var TemplatesWorker = class {
 	config;
 	fileSystem;
@@ -2498,12 +2503,12 @@ var TemplatesWorker = class {
 		if (this.config.silent) consola.level = 0;
 	}
 	getTemplatePaths = (config) => {
-		const __dirname$1 = path$2.dirname(url$2.fileURLToPath(import.meta.url));
-		const baseTemplatesPath = path$2.resolve(__dirname$1, "../templates/base");
-		const defaultTemplatesPath = path$2.resolve(__dirname$1, "../templates/default");
-		const modularTemplatesPath = path$2.resolve(__dirname$1, "../templates/modular");
+		const __dirname$1 = path$1.dirname(url$1.fileURLToPath(import.meta.url));
+		const baseTemplatesPath = path$1.resolve(__dirname$1, "../templates/base");
+		const defaultTemplatesPath = path$1.resolve(__dirname$1, "../templates/default");
+		const modularTemplatesPath = path$1.resolve(__dirname$1, "../templates/modular");
 		const originalTemplatesPath = config.modular ? modularTemplatesPath : defaultTemplatesPath;
-		const customTemplatesPath = config.templates && path$2.resolve(process.cwd(), config.templates);
+		const customTemplatesPath = config.templates && path$1.resolve(process.cwd(), config.templates);
 		return {
 			base: baseTemplatesPath,
 			default: defaultTemplatesPath,
@@ -2512,20 +2517,20 @@ var TemplatesWorker = class {
 			custom: customTemplatesPath
 		};
 	};
-	cropExtension = (path$4) => this.config.templateExtensions.reduce((path$5, ext) => path$5.endsWith(ext) ? path$5.replace(ext, "") : path$5, path$4);
+	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$2.resolve(path_, "./", this.cropExtension(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));
 	};
-	requireFnFromTemplate = async (packageOrPath) => {
+	requireFnFromTemplate = (packageOrPath) => {
 		const isPath = packageOrPath.startsWith("./") || packageOrPath.startsWith("../");
-		if (isPath) return await import(path$2.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
-		return await import(packageOrPath);
+		if (isPath) return require(path$1.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
+		return require(packageOrPath);
 	};
-	getTemplate = (name$1, fileName, path$4) => {
+	getTemplate = (name$1, fileName, path$2) => {
 		const { templatePaths } = this.config;
-		if (path$4) return this.fileSystem.getFileContent(path$4);
+		if (path$2) return this.fileSystem.getFileContent(path$2);
 		if (!fileName) return "";
 		const customFullPath = templatePaths.custom && this.getTemplateFullPath(templatePaths.custom, fileName);
 		let fileContent = customFullPath && this.fileSystem.getFileContent(customFullPath);
@@ -2548,21 +2553,21 @@ var TemplatesWorker = class {
 			[name$1]: this.getTemplate(name$1, fileName)
 		}), {});
 	};
-	findTemplateWithExt = (path$4) => {
-		const raw = this.cropExtension(path$4);
+	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));
 	};
 	getTemplateContent = (path_) => {
 		const foundTemplatePathKey = lodash.keys(this.config.templatePaths).find((key) => path_.startsWith(`@${key}`));
 		if (foundTemplatePathKey) {
-			const rawPath = path$2.resolve(path_.replace(`@${foundTemplatePathKey}`, lodash.get(this.config.templatePaths, foundTemplatePathKey)));
+			const rawPath = path$1.resolve(path_.replace(`@${foundTemplatePathKey}`, lodash.get(this.config.templatePaths, foundTemplatePathKey)));
 			const fixedPath = this.findTemplateWithExt(rawPath);
 			if (fixedPath) return this.fileSystem.getFileContent(fixedPath);
 		}
-		const customPath = this.config.templatePaths.custom && this.findTemplateWithExt(path$2.resolve(this.config.templatePaths.custom, path_));
+		const customPath = this.config.templatePaths.custom && this.findTemplateWithExt(path$1.resolve(this.config.templatePaths.custom, path_));
 		if (customPath) return this.fileSystem.getFileContent(customPath);
-		const originalPath = this.findTemplateWithExt(path$2.resolve(this.config.templatePaths.original, path_));
+		const originalPath = this.findTemplateWithExt(path$1.resolve(this.config.templatePaths.original, path_));
 		if (originalPath) return this.fileSystem.getFileContent(originalPath);
 		return "";
 	};
@@ -2574,8 +2579,8 @@ var TemplatesWorker = class {
 		}, {
 			async: false,
 			...options,
-			includeFile: (path$4, configuration$1, options$1 = {}) => {
-				return this.renderTemplate(this.getTemplateContent(path$4), configuration$1, options$1);
+			includeFile: (path$2, configuration$1, options$1 = {}) => {
+				return this.renderTemplate(this.getTemplateContent(path$2), configuration$1, options$1);
 			}
 		});
 	};
@@ -2601,23 +2606,23 @@ var JavascriptTranslator = class extends Translator {
 	compileTSCode = (input) => {
 		const fileNameFull = `${input.fileName}${input.fileExtension}`;
 		const output = {};
-		const host = typescript$1.createCompilerHost(this.config.compilerTsConfig, true);
+		const host = typescript.createCompilerHost(this.config.compilerTsConfig, true);
 		const fileNames = [fileNameFull];
 		const originalSourceFileGet = host.getSourceFile.bind(host);
 		host.getSourceFile = (sourceFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
 			if (sourceFileName !== fileNameFull) return originalSourceFileGet(sourceFileName, languageVersion, onError, shouldCreateNewSourceFile);
-			return typescript$1.createSourceFile(sourceFileName, input.fileContent, languageVersion, true, typescript$1.ScriptKind.TS);
+			return typescript.createSourceFile(sourceFileName, input.fileContent, languageVersion, true, typescript.ScriptKind.TS);
 		};
 		host.writeFile = (fileName, contents) => {
 			output[fileName] = contents;
 		};
-		typescript$1.createProgram(fileNames, this.config.compilerTsConfig, host).emit();
+		typescript.createProgram(fileNames, this.config.compilerTsConfig, host).emit();
 		return output;
 	};
 	translate = async (input) => {
 		const compiled = this.compileTSCode(input);
-		const jsFileName = `${input.fileName}${typescript$1.Extension.Js}`;
-		const dtsFileName = `${input.fileName}${typescript$1.Extension.Dts}`;
+		const jsFileName = `${input.fileName}${typescript.Extension.Js}`;
+		const dtsFileName = `${input.fileName}${typescript.Extension.Dts}`;
 		const sourceContent = compiled[jsFileName];
 		const tsImportRows = input.fileContent.split("\n").filter((line) => line.startsWith("import "));
 		const declarationContent = compiled[dtsFileName].split("\n").map((line) => {
@@ -2626,11 +2631,11 @@ var JavascriptTranslator = class extends Translator {
 		}).join("\n");
 		return [{
 			fileName: input.fileName,
-			fileExtension: typescript$1.Extension.Js,
+			fileExtension: typescript.Extension.Js,
 			fileContent: await this.codeFormatter.formatCode(sourceContent)
 		}, {
 			fileName: input.fileName,
-			fileExtension: typescript$1.Extension.Dts,
+			fileExtension: typescript.Extension.Dts,
 			fileContent: await this.codeFormatter.formatCode(declarationContent)
 		}];
 	};
@@ -2639,7 +2644,7 @@ var JavascriptTranslator = class extends Translator {
 //#endregion
 //#region src/type-name-formatter.ts
 var TypeNameFormatter = class {
-	formattedModelNamesMap = new Map();
+	formattedModelNamesMap = /* @__PURE__ */ new Map();
 	config;
 	constructor(config) {
 		this.config = config;
@@ -2682,16 +2687,16 @@ var TypeNameFormatter = class {
 //#endregion
 //#region src/util/file-system.ts
 var FileSystem = class {
-	getFileContent = (path$4) => {
-		return fs.readFileSync(path$4, { encoding: "utf8" });
+	getFileContent = (path$2) => {
+		return fs.readFileSync(path$2, { encoding: "utf8" });
 	};
-	readDir = (path$4) => {
-		return fs.readdirSync(path$4);
+	readDir = (path$2) => {
+		return fs.readdirSync(path$2);
 	};
-	pathIsDir = (path$4) => {
-		if (!path$4) return false;
+	pathIsDir = (path$2) => {
+		if (!path$2) return false;
 		try {
-			const stat = fs.statSync(path$4);
+			const stat = fs.statSync(path$2);
 			return stat.isDirectory();
 		} catch (e) {
 			return false;
@@ -2702,27 +2707,27 @@ var FileSystem = class {
 		if (fileNameParts.length > 1) fileNameParts.pop();
 		return fileNameParts.join(".");
 	};
-	removeDir = (path$4) => {
+	removeDir = (path$2) => {
 		try {
-			if (typeof fs.rmSync === "function") fs.rmSync(path$4, { recursive: true });
-			else fs.rmdirSync(path$4, { recursive: true });
+			if (typeof fs.rmSync === "function") fs.rmSync(path$2, { recursive: true });
+			else fs.rmdirSync(path$2, { recursive: true });
 		} catch (e) {
 			consola.debug("failed to remove dir", e);
 		}
 	};
-	createDir = (path$4) => {
+	createDir = (path$2) => {
 		try {
-			fs.mkdirSync(path$4, { recursive: true });
+			fs.mkdirSync(path$2, { recursive: true });
 		} catch (e) {
 			consola.debug("failed to create dir", e);
 		}
 	};
-	cleanDir = (path$4) => {
-		this.removeDir(path$4);
-		this.createDir(path$4);
+	cleanDir = (path$2) => {
+		this.removeDir(path$2);
+		this.createDir(path$2);
 	};
-	pathIsExist = (path$4) => {
-		return !!path$4 && fs.existsSync(path$4);
+	pathIsExist = (path$2) => {
+		return !!path$2 && fs.existsSync(path$2);
 	};
 	createFile = ({ path: path_, fileName, content, withPrefix }) => {
 		const __dirname$1 = path$1.dirname(url$1.fileURLToPath(import.meta.url));
@@ -3028,6 +3033,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 {
@@ -3169,5 +3200,5 @@ async function generateApi(config) {
 }
 
 //#endregion
-export { CodeGenConfig, HTTP_CLIENT, TemplatesGenConfig, constants_exports, generateApi, generateTemplates, package_default };
-//# sourceMappingURL=src-4gUT3jPg.js.map
+export { CodeGenConfig, HTTP_CLIENT, RequestContentKind, SCHEMA_TYPES, TemplatesGenConfig, constants_exports, generateApi, generateTemplates, package_default };
+//# sourceMappingURL=src-s8addnrG.js.map