swagger-typescript-api 13.2.16 → 13.2.17

package/dist/{src-DWf638kx.cjs → generate-templates-wjE78AWV.cjs}

@@ -1,25 +1,34 @@
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all) => {
+var __exportAll = (all, no_symbols) => {
 	let target = {};
-	for (var name$1 in all) __defProp(target, name$1, {
-		get: all[name$1],
-		enumerable: true
-	});
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
 	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++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
 	}
 	return to;
 };
@@ -30,17 +39,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 let consola = require("consola");
-consola = __toESM(consola);
-let lodash = require("lodash");
-lodash = __toESM(lodash);
+let es_toolkit = require("es-toolkit");
+es_toolkit = __toESM(es_toolkit);
+let es_toolkit_compat = require("es-toolkit/compat");
+es_toolkit_compat = __toESM(es_toolkit_compat);
 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 _biomejs_js_api = require("@biomejs/js-api");
 let nanoid = require("nanoid");
 nanoid = __toESM(nanoid);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
 let swagger2openapi = require("swagger2openapi");
 swagger2openapi = __toESM(swagger2openapi);
 let yaml = require("yaml");
@@ -50,7 +61,6 @@ 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);
 
@@ -67,11 +77,11 @@ var CodeFormatter = class {
 			type: "file",
 			fileName: tempFileName
 		}, { 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);
+		if (fileTextChanges?.textChanges.length) return fileTextChanges.textChanges.reduceRight((content, { span, newText }) => `${content.slice(0, span.start)}${newText}${content.slice(span.start + span.length)}`, content);
 		return content;
 	};
 	format = async (content) => {
-		const biome = await __biomejs_js_api.Biome.create({ distribution: __biomejs_js_api.Distribution.NODE });
+		const biome = await _biomejs_js_api.Biome.create({ distribution: _biomejs_js_api.Distribution.NODE });
 		const biomeProject = biome.openProject();
 		biome.applyConfiguration(biomeProject.projectKey, {
 			files: { maxSize: Number.MAX_SAFE_INTEGER },
@@ -123,8 +133,8 @@ var TsLanguageServiceHost = class {
 		if (fileName === this.fileName) return this.content;
 		return typescript.sys.readFile(fileName, encoding);
 	}
-	fileExists(path$1) {
-		return typescript.sys.fileExists(path$1);
+	fileExists(path) {
+		return typescript.sys.fileExists(path);
 	}
 };
 
@@ -140,14 +150,14 @@ var NameResolver = class {
 		this.reserve(reservedNames);
 	}
 	reserve(names) {
-		const fixedNames = lodash.default.uniq(lodash.default.compact(names));
-		for (const name$1 of fixedNames) if (this.reservedNames.indexOf(name$1) === -1) this.reservedNames.push(name$1);
+		const fixedNames = (0, es_toolkit.uniq)((0, es_toolkit.compact)(names));
+		for (const name of fixedNames) if (this.reservedNames.indexOf(name) === -1) this.reservedNames.push(name);
 	}
 	unreserve(names) {
-		this.reservedNames = this.reservedNames.filter((reservedName) => !names.some((name$1) => name$1 === reservedName));
+		this.reservedNames = this.reservedNames.filter((reservedName) => !names.some((name) => name === reservedName));
 	}
-	isReserved(name$1) {
-		return this.reservedNames.some((reservedName) => reservedName === name$1);
+	isReserved(name) {
+		return this.reservedNames.some((reservedName) => reservedName === name);
 	}
 	resolve(variants, resolver, extras, shouldReserve = true) {
 		if (typeof resolver === "function") {
@@ -165,7 +175,7 @@ var NameResolver = class {
 		}
 		if (Array.isArray(variants)) {
 			let usageName = null;
-			const uniqVariants = lodash.default.uniq(lodash.default.compact(variants));
+			const uniqVariants = (0, es_toolkit.uniq)((0, es_toolkit.compact)(variants));
 			for (const variant of uniqVariants) if (!usageName && (!shouldReserve || !this.isReserved(variant))) usageName = variant;
 			if (usageName) {
 				shouldReserve && this.reserve([usageName]);
@@ -181,12 +191,9 @@ var NameResolver = class {
 
 //#endregion
 //#region src/util/random.ts
-const getRandomFloat = (min = 0, max = 1) => {
-	return Math.random() * (max - min) + min;
-};
 const getRandomInt = (min = 0, max = 1) => {
 	if (min === max) return min;
-	return Math.round(getRandomFloat(min, max));
+	return Math.round(Math.random() * (max - min) + min);
 };
 
 //#endregion
@@ -216,12 +223,12 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.16";
+var version = "13.2.17";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 
 //#endregion
 //#region src/constants.ts
-var constants_exports = /* @__PURE__ */ __export({
+var constants_exports = /* @__PURE__ */ __exportAll({
 	DEFAULT_BODY_ARG_NAME: () => DEFAULT_BODY_ARG_NAME,
 	FILE_PREFIX: () => FILE_PREFIX,
 	HTTP_CLIENT: () => HTTP_CLIENT,
@@ -285,16 +292,6 @@ const SCHEMA_TYPES$1 = {
 	COMPLEX_UNKNOWN: "__unknown"
 };
 
-//#endregion
-//#region src/util/object-assign.ts
-const objectAssign = (target, updater) => {
-	if (!updater) return;
-	const update = typeof updater === "function" ? updater(target) : updater;
-	const undefinedKeys = lodash.default.map(update, (value, key) => value === void 0 && key).filter((key) => typeof key === "string");
-	Object.assign(target, lodash.default.merge(target, update));
-	for (const key of undefinedKeys) target[key] = void 0;
-};
-
 //#endregion
 //#region src/configuration.ts
 const TsKeyword = {
@@ -495,11 +492,11 @@ var CodeGenConfig = class {
 		BooleanValue: (content) => `${content}`,
 		NumberValue: (content) => `${content}`,
 		NullValue: () => "null",
-		UnionType: (contents) => lodash.default.join(lodash.default.uniq(contents), ` ${this.Ts.Keyword.Union} `),
+		UnionType: (contents) => (0, es_toolkit.uniq)(contents).join(` ${this.Ts.Keyword.Union} `),
 		ExpressionGroup: (content) => content ? `(${content})` : "",
-		IntersectionType: (contents) => lodash.default.join(lodash.default.uniq(contents), ` ${this.Ts.Keyword.Intersection} `),
+		IntersectionType: (contents) => (0, es_toolkit.uniq)(contents).join(` ${this.Ts.Keyword.Intersection} `),
 		RecordType: (key, value) => this.Ts.TypeWithGeneric(this.Ts.Keyword.Record, [key, value]),
-		TypeField: ({ readonly, key, optional, value }) => lodash.default.compact([
+		TypeField: ({ readonly, key, optional, value }) => (0, es_toolkit.compact)([
 			readonly && "readonly ",
 			key,
 			optional && "?",
@@ -509,12 +506,12 @@ var CodeGenConfig = class {
 		InterfaceDynamicField: (key, value) => `[key: ${key}]: ${value}`,
 		EnumUsageKey: (enumStruct, key) => `${enumStruct}.${key}`,
 		EnumField: (key, value) => `${key} = ${value}`,
-		EnumFieldDescription: (description$1) => {
-			if (description$1) return `  /** ${description$1} */`;
+		EnumFieldDescription: (description) => {
+			if (description) return `  /** ${description} */`;
 			else return "";
 		},
-		EnumFieldsWrapper: (contents) => lodash.default.map(contents, ({ key, value, description: description$1 }) => {
-			return [this.Ts.EnumFieldDescription(description$1), `  ${this.Ts.EnumField(key, value)}`].filter(Boolean).join("\n");
+		EnumFieldsWrapper: (contents) => contents.map(({ key, value, description }) => {
+			return (0, es_toolkit.compact)([this.Ts.EnumFieldDescription(description), `  ${this.Ts.EnumField(key, value)}`]).join("\n");
 		}).join(",\n"),
 		ObjectWrapper: (content) => `{\n${content}\n}`,
 		MultilineComment: (contents, formatFn) => [...contents.length === 1 ? [`/** ${contents[0]} */`] : [
@@ -604,13 +601,13 @@ var CodeGenConfig = class {
 		}
 	];
 	templateExtensions = [".eta", ".ejs"];
-	constructor({ codeGenConstructs, primitiveTypeConstructs, constants, templateInfos, hooks,...otherConfig }) {
-		objectAssign(this.Ts, codeGenConstructs);
-		objectAssign(this.primitiveTypes, primitiveTypeConstructs);
+	constructor({ codeGenConstructs, primitiveTypeConstructs, constants, templateInfos, hooks, ...otherConfig }) {
+		Object.assign(this.Ts, codeGenConstructs);
+		Object.assign(this.primitiveTypes, primitiveTypeConstructs);
 		this.defaultResponseType = this.Ts.Keyword.Void;
 		this.update({
 			...otherConfig,
-			hooks: lodash.default.merge(this.hooks, hooks || {}),
+			hooks: (0, es_toolkit.merge)(this.hooks, hooks || {}),
 			constants: {
 				...constants_exports,
 				...constants
@@ -626,7 +623,7 @@ var CodeGenConfig = class {
 		this.componentTypeNameResolver = new ComponentTypeNameResolver(this, []);
 	}
 	update = (update) => {
-		objectAssign(this, update);
+		Object.assign(this, update);
 		if (this.enumNamesAsValues) this.extractEnums = true;
 	};
 };
@@ -731,7 +728,7 @@ var SchemaFormatters = class {
 		[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
+				content: parsedSchema.$ref ? parsedSchema.typeName : this.config.Ts.UnionType((0, es_toolkit.compact)([...parsedSchema.content.map(({ value }) => `${value}`), parsedSchema.nullable && this.config.Ts.Keyword.Null])) || this.config.Ts.Keyword.Any
 			};
 		},
 		[SCHEMA_TYPES$1.OBJECT]: (parsedSchema) => {
@@ -748,14 +745,14 @@ var SchemaFormatters = class {
 		}
 	};
 	formatSchema = (parsedSchema, formatType = "base") => {
-		const schemaType = lodash.default.get(parsedSchema, ["schemaType"]) || lodash.default.get(parsedSchema, ["$parsed", "schemaType"]);
-		return lodash.default.get(this, [formatType, schemaType])?.(parsedSchema) || parsedSchema;
+		const schemaType = (0, es_toolkit_compat.get)(parsedSchema, ["schemaType"]) || (0, es_toolkit_compat.get)(parsedSchema, ["$parsed", "schemaType"]);
+		return (0, es_toolkit_compat.get)(this, [formatType, schemaType])?.(parsedSchema) || parsedSchema;
 	};
-	formatDescription = (description$1, inline) => {
-		if (!description$1) return "";
-		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, "");
+	formatDescription = (description, inline) => {
+		if (!description) return "";
+		if (!description.includes("\n")) return description;
+		if (inline) return (0, es_toolkit.compact)(description.split(/\n/g).map((part) => part.trim())).join(" ");
+		return description.replace(/\n$/g, "");
 	};
 	formatObjectContent = (content) => {
 		const fields = [];
@@ -816,7 +813,7 @@ var MonoSchemaParser = class {
 var ArraySchemaParser = class extends MonoSchemaParser {
 	parse() {
 		let contentType;
-		const { type, description: description$1, items } = this.schema || {};
+		const { type, description, items } = this.schema || {};
 		if (Array.isArray(items) && type === SCHEMA_TYPES$1.ARRAY) {
 			const tupleContent = [];
 			for (const item of items) tupleContent.push(this.schemaParserFabric.createSchemaParser({
@@ -839,7 +836,7 @@ var ArraySchemaParser = class extends MonoSchemaParser {
 			type: SCHEMA_TYPES$1.PRIMITIVE,
 			typeIdentifier: this.config.Ts.Keyword.Type,
 			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(description$1),
+			description: this.schemaFormatters.formatDescription(description),
 			content: this.schemaUtils.safeAddNullToType(this.schema, contentType)
 		};
 	}
@@ -850,7 +847,7 @@ var ArraySchemaParser = class extends MonoSchemaParser {
 var ComplexSchemaParser = class extends MonoSchemaParser {
 	parse() {
 		const complexType = this.schemaUtils.getComplexType(this.schema);
-		const simpleSchema = lodash.default.omit(lodash.default.clone(this.schema), lodash.default.keys(this.schemaParser._complexSchemaParsers));
+		const simpleSchema = (0, es_toolkit.omit)(this.schema, Object.keys(this.schemaParser._complexSchemaParsers));
 		const complexSchemaContent = this.schemaParser._complexSchemaParsers[complexType](this.schema);
 		return {
 			...typeof this.schema === "object" ? this.schema : {},
@@ -860,8 +857,8 @@ var ComplexSchemaParser = class extends MonoSchemaParser {
 			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$1.OBJECT && this.config.Ts.ExpressionGroup(this.schemaParserFabric.createSchemaParser({
+			description: this.schemaFormatters.formatDescription(this.schema.description || (0, es_toolkit.compact)((this.schema[complexType] || []).map((item) => item?.description))[0] || ""),
+			content: this.config.Ts.IntersectionType((0, es_toolkit.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
@@ -874,7 +871,7 @@ var ComplexSchemaParser = class extends MonoSchemaParser {
 var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 	parse() {
 		const ts = this.config.Ts;
-		const { discriminator,...noDiscriminatorSchema } = this.schema;
+		const { discriminator, ...noDiscriminatorSchema } = this.schema;
 		if (!discriminator.mapping) return this.schemaParserFabric.createSchemaParser({
 			schema: noDiscriminatorSchema,
 			typeName: this.typeName,
@@ -886,7 +883,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 			skipMappingType,
 			abstractSchemaStruct
 		});
-		const schemaContent = ts.IntersectionType([abstractSchemaStruct?.content, discriminatorSchemaStruct?.content].filter(Boolean));
+		const schemaContent = ts.IntersectionType((0, es_toolkit.compact)([abstractSchemaStruct?.content, discriminatorSchemaStruct?.content]));
 		return {
 			...typeof this.schema === "object" ? this.schema : {},
 			$schemaPath: this.schemaPath.slice(),
@@ -907,7 +904,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 			this.typeName
 		]);
 		const { discriminator } = this.schema;
-		const mappingEntries = lodash.default.entries(discriminator.mapping);
+		const mappingEntries = Object.entries(discriminator.mapping || {});
 		const ableToCreateMappingType = !skipMappingType && !!(abstractSchemaStruct?.typeName && mappingEntries.length);
 		const mappingContents = [];
 		let mappingTypeName;
@@ -967,22 +964,24 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 	};
 	createMappingPropertySchemaEnumKeys = ({ abstractSchemaStruct, discPropertyName }) => {
 		const ts = this.config.Ts;
-		let mappingPropertySchemaEnumKeysMap = {};
-		let mappingPropertySchema = lodash.default.get(abstractSchemaStruct?.component?.rawTypeData, ["properties", discPropertyName]);
+		const mappingPropertySchemaEnumKeysMap = {};
+		let mappingPropertySchema = (0, es_toolkit_compat.get)(abstractSchemaStruct?.component?.rawTypeData, ["properties", discPropertyName]);
 		if (this.schemaUtils.isRefSchema(mappingPropertySchema)) mappingPropertySchema = this.schemaUtils.getSchemaRefType(mappingPropertySchema);
 		const parsedEnum = mappingPropertySchema?.rawTypeData?.$parsed;
-		if (parsedEnum?.type === SCHEMA_TYPES$1.ENUM) mappingPropertySchemaEnumKeysMap = lodash.default.reduce(parsedEnum.enum, (acc, key, index) => {
-			const enumContent = parsedEnum.content?.[index];
-			if (this.config.generateUnionEnums) {
-				const literalValue = enumContent?.value ?? (key !== void 0 ? ts.StringValue(key) : void 0);
-				if (literalValue !== void 0) acc[key] = literalValue;
-			} else if (parsedEnum.typeName && enumContent?.key) acc[key] = ts.EnumUsageKey(parsedEnum.typeName, enumContent.key);
-			return acc;
-		}, {});
+		if (parsedEnum?.type === SCHEMA_TYPES$1.ENUM) {
+			const enumEntries = (parsedEnum.enum || []).map((key, index) => [key, index]);
+			for (const [key, index] of enumEntries) {
+				const enumContent = parsedEnum.content?.[index];
+				if (this.config.generateUnionEnums) {
+					const literalValue = enumContent?.value ?? (key !== void 0 ? ts.StringValue(key) : void 0);
+					if (literalValue !== void 0) mappingPropertySchemaEnumKeysMap[key] = literalValue;
+				} else if (parsedEnum.typeName && enumContent?.key) mappingPropertySchemaEnumKeysMap[key] = ts.EnumUsageKey(parsedEnum.typeName, enumContent.key);
+			}
+		}
 		return mappingPropertySchemaEnumKeysMap;
 	};
 	mutateMappingDependentSchema = ({ discPropertyName, abstractSchemaStruct, mappingSchema, refPath, mappingPropertySchemaEnumKeysMap }) => {
-		const complexSchemaKeys = lodash.default.keys(this.schemaParser._complexSchemaParsers);
+		const complexSchemaKeys = Object.keys(this.schemaParser._complexSchemaParsers);
 		if (mappingSchema.$ref && abstractSchemaStruct?.component?.$ref) {
 			const mappingRefSchema = this.schemaUtils.getSchemaRefType(mappingSchema)?.rawTypeData;
 			if (mappingRefSchema) {
@@ -1001,11 +1000,11 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 		}
 	};
 	createAbstractSchemaStruct = () => {
-		const { discriminator,...noDiscriminatorSchema } = this.schema;
-		const complexSchemaKeys = lodash.default.keys(this.schemaParser._complexSchemaParsers);
-		const schema = lodash.default.omit(structuredClone(noDiscriminatorSchema), complexSchemaKeys);
+		const { discriminator, ...noDiscriminatorSchema } = this.schema;
+		const complexSchemaKeys = Object.keys(this.schemaParser._complexSchemaParsers);
+		const schema = (0, es_toolkit.omit)(structuredClone(noDiscriminatorSchema), complexSchemaKeys);
 		const schemaIsAny = this.schemaParserFabric.getInlineParseContent(structuredClone(schema)) === this.config.Ts.Keyword.Any;
-		if (!lodash.default.keys(schema).length || schemaIsAny) return null;
+		if (!Object.keys(schema).length || schemaIsAny) return null;
 		const typeName = this.schemaUtils.resolveTypeName(this.typeName, {
 			prefixes: this.config.extractingOptions.discriminatorAbstractPrefix,
 			resolver: this.config.extractingOptions.discriminatorAbstractResolver
@@ -1074,9 +1073,9 @@ var EnumSchemaParser = class extends MonoSchemaParser {
 		const refType = this.schemaUtils.getSchemaRefType(this.schema);
 		const $ref = refType?.$ref || null;
 		if (Array.isArray(this.schema.enum)) this.schema.enum = this.schema.enum.filter((key) => key != null);
-		if (Array.isArray(this.schema.enum) && Array.isArray(this.schema.enum[0])) return this.schemaParserFabric.parseSchema({ oneOf: this.schema.enum.map((enumNames$1) => ({
+		if (Array.isArray(this.schema.enum) && Array.isArray(this.schema.enum[0])) return this.schemaParserFabric.parseSchema({ oneOf: this.schema.enum.map((enumNames) => ({
 			type: "array",
-			items: enumNames$1.map((enumName) => ({
+			items: enumNames.map((enumName) => ({
 				type: "string",
 				enum: [enumName]
 			}))
@@ -1101,8 +1100,8 @@ var EnumSchemaParser = class extends MonoSchemaParser {
 				default: return this.config.Ts.StringValue(value);
 			}
 		};
-		if (Array.isArray(enumNames) && lodash.default.size(enumNames)) content = enumNames.map((enumName, index) => {
-			const enumValue = lodash.default.get(this.schema.enum, index);
+		if (Array.isArray(enumNames) && enumNames.length > 0) content = enumNames.map((enumName, index) => {
+			const enumValue = (0, es_toolkit_compat.get)(this.schema.enum, index);
 			const formattedKey = this.formatEnumKey({
 				key: enumName,
 				value: enumValue
@@ -1170,21 +1169,24 @@ var ObjectSchemaParser = class extends MonoSchemaParser {
 	}
 	getObjectSchemaContent = (schema) => {
 		const { properties, additionalProperties } = schema || {};
-		const propertiesContent = lodash.default.map(properties, (property, name$1) => {
-			const required = this.schemaUtils.isPropertyRequired(name$1, property, schema);
-			const rawTypeData = lodash.default.get(this.schemaUtils.getSchemaRefType(property), "rawTypeData", {});
+		const propertiesContent = [];
+		for (const [name, property] of Object.entries(properties || {})) {
+			const required = this.schemaUtils.isPropertyRequired(name, property, schema);
+			const rawTypeData = (0, es_toolkit_compat.get)(this.schemaUtils.getSchemaRefType(property), "rawTypeData", {});
 			const nullable = !!(rawTypeData.nullable || property.nullable);
-			const fieldName = this.typeNameFormatter.isValidName(name$1) ? name$1 : this.config.Ts.StringValue(name$1);
+			const fieldName = this.typeNameFormatter.isValidName(name) ? name : this.config.Ts.StringValue(name);
 			const fieldValue = this.schemaParserFabric.createSchemaParser({
 				schema: property,
-				schemaPath: [...this.schemaPath, name$1]
+				schemaPath: [...this.schemaPath, name]
 			}).getInlineParseContent();
 			const readOnly = property.readOnly;
-			return {
+			const complexType = this.schemaUtils.getComplexType(property);
+			const rawDataComplexType = this.schemaUtils.getComplexType(rawTypeData);
+			propertiesContent.push({
 				...property,
 				$$raw: property,
 				title: property.title,
-				description: property.description || lodash.default.compact(lodash.default.map(property[this.schemaUtils.getComplexType(property)], "description"))[0] || rawTypeData.description || lodash.default.compact(lodash.default.map(rawTypeData[this.schemaUtils.getComplexType(rawTypeData)], "description"))[0] || "",
+				description: property.description || (0, es_toolkit.compact)((property[complexType] || []).map((item) => item?.description))[0] || rawTypeData.description || (0, es_toolkit.compact)((rawTypeData[rawDataComplexType] || []).map((item) => item?.description))[0] || "",
 				isRequired: required,
 				isNullable: nullable,
 				name: fieldName,
@@ -1195,8 +1197,8 @@ var ObjectSchemaParser = class extends MonoSchemaParser {
 					key: fieldName,
 					value: fieldValue
 				})
-			};
-		});
+			});
+		}
 		if (additionalProperties) {
 			const propertyNamesSchema = this.schemaUtils.getSchemaPropertyNamesSchema(schema);
 			let interfaceKeysContent;
@@ -1221,7 +1223,7 @@ var ObjectSchemaParser = class extends MonoSchemaParser {
 var PrimitiveSchemaParser = class extends MonoSchemaParser {
 	parse() {
 		let contentType = null;
-		const { additionalProperties, type, description: description$1, items } = this.schema || {};
+		const { additionalProperties, type, description, items } = this.schema || {};
 		if (type === this.config.Ts.Keyword.Object && additionalProperties) {
 			const propertyNamesSchema = this.schemaUtils.getSchemaPropertyNamesSchema(this.schema);
 			let recordKeysContent;
@@ -1240,7 +1242,7 @@ var PrimitiveSchemaParser = class extends MonoSchemaParser {
 		}
 		if (Array.isArray(type) && type.length) contentType = this.schemaParser._complexSchemaParsers.oneOf({
 			...typeof this.schema === "object" ? this.schema : {},
-			oneOf: type.map((type$1) => ({ type: type$1 }))
+			oneOf: type.map((type) => ({ type }))
 		});
 		if (Array.isArray(items) && type === SCHEMA_TYPES$1.ARRAY) contentType = this.config.Ts.Tuple(items.map((item) => this.schemaParserFabric.createSchemaParser({
 			schema: item,
@@ -1254,7 +1256,7 @@ var PrimitiveSchemaParser = class extends MonoSchemaParser {
 			type: SCHEMA_TYPES$1.PRIMITIVE,
 			typeIdentifier: this.config.Ts.Keyword.Type,
 			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(description$1),
+			description: this.schemaFormatters.formatDescription(description),
 			content: type === this.config.Ts.Keyword.Null ? type : contentType || this.schemaUtils.getSchemaType(this.schema)
 		};
 	}
@@ -1389,7 +1391,7 @@ var SchemaParser = class {
 			}
 			schemaType = this.schemaUtils.getInternalSchemaType(this.schema);
 			this.schemaPath.push(this.typeName);
-			lodash.default.merge(this.schema, this.config.hooks.onPreParseSchema(this.schema, this.typeName, schemaType));
+			(0, es_toolkit.merge)(this.schema, this.config.hooks.onPreParseSchema(this.schema, this.typeName, schemaType) || {});
 			parsedSchema = this._baseSchemaParsers[schemaType](this.schema, this.typeName);
 			this.schema.$parsed = this.config.hooks.onParseSchema(this.schema, parsedSchema) || parsedSchema;
 			if (this.config.sortTypes && Array.isArray(this.schema.$parsed?.content)) this.schema.$parsed.content = this.schema.$parsed.content.sort(sortByProperty("name"));
@@ -1406,28 +1408,23 @@ var SchemaParser = class {
 		return this.schemaFormatters.formatSchema(parsedSchema, "base").content;
 	};
 	extractSchemaFromResponseStruct = (responseStruct) => {
-		const { content,...extras } = responseStruct;
-		const firstResponse = lodash.default.first(lodash.default.values(content));
-		const firstSchema = lodash.default.get(firstResponse, "schema");
+		const { content, ...extras } = responseStruct;
+		const firstResponse = Object.values(content || {})[0];
+		const firstSchema = (0, es_toolkit_compat.get)(firstResponse, "schema");
 		if (!firstSchema) return;
+		const { schema: _, ...restResponse } = firstResponse || {};
 		return {
 			...extras,
-			...lodash.default.omit(firstResponse, "schema"),
+			...restResponse,
 			...firstSchema
 		};
 	};
 };
 
-//#endregion
-//#region src/util/internal-case.ts
-function internalCase(value) {
-	return lodash.default.camelCase(lodash.default.lowerCase(value));
-}
-
 //#endregion
 //#region src/util/pascal-case.ts
 function pascalCase(value) {
-	return lodash.default.upperFirst(lodash.default.camelCase(value));
+	return (0, es_toolkit_compat.upperFirst)((0, es_toolkit_compat.camelCase)(value));
 }
 
 //#endregion
@@ -1444,7 +1441,7 @@ var SchemaUtils = class {
 		this.schemaWalker = schemaWalker;
 	}
 	getRequiredProperties = (schema) => {
-		return lodash.default.uniq(schema && Array.isArray(schema.required) && schema.required || []);
+		return (0, es_toolkit.uniq)(schema && Array.isArray(schema.required) && schema.required || []);
 	};
 	isRefSchema = (schema) => {
 		return !!schema?.$ref;
@@ -1463,15 +1460,15 @@ var SchemaUtils = class {
 		if (!this.isRefSchema(schema)) return null;
 		return this.schemaComponentsMap.get(schema.$ref);
 	};
-	isPropertyRequired = (name$1, propertySchema, rootSchema) => {
+	isPropertyRequired = (name, propertySchema, rootSchema) => {
 		if (propertySchema["x-omitempty"] === false) return true;
-		const isRequired = typeof propertySchema.required === "boolean" ? !!propertySchema.required : Array.isArray(rootSchema.required) ? rootSchema.required.includes(name$1) : !!rootSchema.required;
+		const isRequired = typeof propertySchema.required === "boolean" ? !!propertySchema.required : Array.isArray(rootSchema.required) ? rootSchema.required.includes(name) : !!rootSchema.required;
 		if (this.config.convertedFromSwagger2) return typeof propertySchema.nullable === this.config.Ts.Keyword.Undefined ? isRequired : !propertySchema.nullable;
 		return isRequired;
 	};
 	isNullMissingInType = (schema, type) => {
 		const { nullable, type: schemaType } = schema || {};
-		return (nullable || !!lodash.default.get(schema, "x-nullable") || schemaType === this.config.Ts.Keyword.Null) && typeof type === "string" && !type.includes(` ${this.config.Ts.Keyword.Null}`) && !type.includes(`${this.config.Ts.Keyword.Null} `);
+		return (nullable || !!(0, es_toolkit_compat.get)(schema, "x-nullable") || schemaType === this.config.Ts.Keyword.Null) && typeof type === "string" && !type.includes(` ${this.config.Ts.Keyword.Null}`) && !type.includes(`${this.config.Ts.Keyword.Null} `);
 	};
 	safeAddNullToType = (schema, type) => {
 		if (this.isNullMissingInType(schema, type)) return this.config.Ts.UnionType([type, this.config.Ts.Keyword.Null]);
@@ -1479,13 +1476,13 @@ var SchemaUtils = class {
 	};
 	getSchemaPrimitiveType = (rawSchema) => {
 		const schema = rawSchema || {};
-		if (schema.type) return internalCase(schema.type);
+		if (schema.type) return (0, es_toolkit_compat.camelCase)(schema.type);
 		if (schema.enum) {
 			const enumFieldType = typeof schema.enum[0];
 			if (enumFieldType === this.config.Ts.Keyword.Undefined) return;
-			return internalCase(enumFieldType);
+			return (0, es_toolkit_compat.camelCase)(enumFieldType);
 		}
-		if (lodash.default.keys(schema.properties).length) return SCHEMA_TYPES$1.OBJECT;
+		if (Object.keys(schema.properties || {}).length) return SCHEMA_TYPES$1.OBJECT;
 		if (schema.items) return SCHEMA_TYPES$1.ARRAY;
 		return null;
 	};
@@ -1498,10 +1495,10 @@ var SchemaUtils = class {
 	};
 	makeAddRequiredToChildSchema = (parentSchema, childSchema) => {
 		if (!childSchema) return childSchema;
-		const required = lodash.default.uniq([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
+		const required = (0, es_toolkit.uniq)([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
 		const refData = this.getSchemaRefType(childSchema);
 		if (refData) {
-			const existedRequiredKeys = lodash.default.keys(refData.rawTypeData?.properties || {}).filter((key) => required.includes(key));
+			const existedRequiredKeys = Object.keys(refData.rawTypeData?.properties || {}).filter((key) => required.includes(key));
 			if (!existedRequiredKeys.length) return childSchema;
 			return {
 				...childSchema,
@@ -1509,17 +1506,17 @@ var SchemaUtils = class {
 			};
 		}
 		if (childSchema.properties) {
-			const existedRequiredKeys = lodash.default.keys(childSchema.properties).filter((key) => required.includes(key));
+			const existedRequiredKeys = Object.keys(childSchema.properties).filter((key) => required.includes(key));
 			if (!existedRequiredKeys.length) return childSchema;
 			return {
-				required: lodash.default.uniq([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
+				required: (0, es_toolkit.uniq)([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
 				...childSchema
 			};
 		}
 		return childSchema;
 	};
 	filterSchemaContents = (contents, filterFn) => {
-		return lodash.default.uniq(contents.filter((type) => filterFn(type)));
+		return (0, es_toolkit.uniq)(contents.filter((type) => filterFn(type)));
 	};
 	resolveTypeName = (typeName, { suffixes, resolver, prefixes, shouldReserve = true }) => {
 		if (resolver) return this.config.componentTypeNameResolver.resolve([], (reserved) => {
@@ -1535,10 +1532,10 @@ var SchemaUtils = class {
 		return SCHEMA_TYPES$1.COMPLEX_UNKNOWN;
 	};
 	getInternalSchemaType = (schema) => {
-		if (!lodash.default.isEmpty(schema.enum) || !lodash.default.isEmpty(this.getEnumNames(schema))) return SCHEMA_TYPES$1.ENUM;
+		if (schema.enum && schema.enum.length > 0 || this.getEnumNames(schema) && this.getEnumNames(schema).length > 0) 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.properties && Object.keys(schema.properties).length > 0) return SCHEMA_TYPES$1.OBJECT;
 		if (schema.type === SCHEMA_TYPES$1.ARRAY) return SCHEMA_TYPES$1.ARRAY;
 		return SCHEMA_TYPES$1.PRIMITIVE;
 	};
@@ -1551,7 +1548,7 @@ var SchemaUtils = class {
 		else {
 			const primitiveType = this.getSchemaPrimitiveType(schema);
 			if (primitiveType == null) return this.config.Ts.Keyword.Any;
-			const typeAlias = lodash.default.get(this.config.primitiveTypes, [primitiveType, schema.format]) || lodash.default.get(this.config.primitiveTypes, [primitiveType, "$default"]) || this.config.primitiveTypes[primitiveType];
+			const typeAlias = (0, es_toolkit_compat.get)(this.config.primitiveTypes, [primitiveType, schema.format]) || (0, es_toolkit_compat.get)(this.config.primitiveTypes, [primitiveType, "$default"]) || this.config.primitiveTypes[primitiveType];
 			if (typeof typeAlias === "function") resultType = typeAlias(schema, this);
 			else resultType = typeAlias || primitiveType;
 		}
@@ -1559,9 +1556,9 @@ var SchemaUtils = class {
 		return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, resultType));
 	};
 	buildTypeNameFromPath = (schemaPath) => {
-		schemaPath = lodash.default.uniq(lodash.default.compact(schemaPath));
+		schemaPath = (0, es_toolkit.uniq)((0, es_toolkit.compact)(schemaPath || []));
 		if (!schemaPath || !schemaPath[0]) return null;
-		return pascalCase(lodash.default.camelCase(lodash.default.uniq([schemaPath[0], schemaPath[schemaPath.length - 1]]).join("_")));
+		return pascalCase((0, es_toolkit.uniq)([schemaPath[0], schemaPath[schemaPath.length - 1]]).join("_"));
 	};
 	isConstantSchema(schema) {
 		return "const" in schema;
@@ -1604,7 +1601,7 @@ var SchemaParserFabric = class {
 			schemaPath
 		});
 	};
-	createSchema = ({ content, linkedSchema = {}, linkedComponent, schemaPath,...otherSchemaProps }) => {
+	createSchema = ({ content, linkedSchema = {}, linkedComponent, schemaPath, ...otherSchemaProps }) => {
 		const parser = this.createSchemaParser({
 			schema: linkedComponent || linkedSchema,
 			schemaPath
@@ -1652,8 +1649,7 @@ var SchemaParserFabric = class {
 
 //#endregion
 //#region src/util/id.ts
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
-const generateId = nanoid.customAlphabet(ALPHABET, 12);
+const generateId = () => node_crypto.randomUUID();
 
 //#endregion
 //#region src/schema-routes/util/specific-arg-name-resolver.ts
@@ -1698,7 +1694,7 @@ var SchemaRoutes = class {
 		this.typeNameFormatter = typeNameFormatter;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.templatesWorker = templatesWorker;
-		this.FORM_DATA_TYPES = lodash.default.uniq([this.schemaUtils.getSchemaType({
+		this.FORM_DATA_TYPES = (0, es_toolkit.uniq)([this.schemaUtils.getSchemaType({
 			type: "string",
 			format: "file"
 		}), this.schemaUtils.getSchemaType({
@@ -1706,49 +1702,50 @@ var SchemaRoutes = class {
 			format: "binary"
 		})]);
 	}
-	createRequestsMap = (routeInfoByMethodsMap) => {
-		const parameters = lodash.default.get(routeInfoByMethodsMap, "parameters");
-		return lodash.default.reduce(routeInfoByMethodsMap, (acc, requestInfo, method) => {
-			if (method.startsWith("x-") || ["parameters", "$ref"].includes(method)) return acc;
-			acc[method] = {
+	createRequestsMap = (routesByMethod) => {
+		const parameters = (0, es_toolkit_compat.get)(routesByMethod, "parameters");
+		const result = {};
+		for (const [method, requestInfo] of Object.entries(routesByMethod)) {
+			if (method.startsWith("x-") || ["parameters", "$ref"].includes(method)) continue;
+			result[method] = {
 				...requestInfo,
-				parameters: lodash.default.compact(lodash.default.concat(parameters, requestInfo.parameters))
+				parameters: (0, es_toolkit.compact)([...parameters || [], ...requestInfo.parameters || []])
 			};
-			return acc;
-		}, {});
+		}
+		return result;
 	};
-	parseRouteName = (originalRouteName) => {
-		const routeName = this.config.hooks.onPreBuildRoutePath(originalRouteName) || originalRouteName;
+	parseRouteName = (rawRoute) => {
+		const routeName = this.config.hooks.onPreBuildRoutePath(rawRoute) || rawRoute;
 		const pathParamMatches = (routeName || "").match(/({[\w[\\\]^`][-_.\w]*})|(:[\w[\\\]^`][-_.\w]*:?)/g);
-		const pathParams = lodash.default.reduce(pathParamMatches, (pathParams$1, match) => {
+		const pathParams = [];
+		for (const match of pathParamMatches || []) {
 			const paramName = match.replace(/\{|\}|:/g, "");
-			if (!paramName) return pathParams$1;
+			if (!paramName) continue;
 			if (paramName.includes("-")) consola.consola.warn("wrong path param name", paramName);
-			pathParams$1.push({
+			pathParams.push({
 				$match: match,
-				name: lodash.default.camelCase(paramName),
+				name: (0, es_toolkit_compat.camelCase)(paramName),
 				required: true,
 				type: "string",
 				description: "",
 				schema: { type: "string" },
 				in: "path"
 			});
-			return pathParams$1;
-		}, []);
-		let fixedRoute = pathParams.reduce((fixedRoute$1, pathParam, i, arr) => {
-			const insertion = this.config.hooks.onInsertPathParam(pathParam.name, i, arr, fixedRoute$1) || pathParam.name;
-			return fixedRoute$1.replace(pathParam.$match, `\${${insertion}}`);
+		}
+		let fixedRoute = pathParams.reduce((fixedRoute, pathParam, i, arr) => {
+			const insertion = this.config.hooks.onInsertPathParam(pathParam.name, i, arr, fixedRoute) || pathParam.name;
+			return fixedRoute.replace(pathParam.$match, `\${${insertion}}`);
 		}, routeName || "");
 		const queryParamMatches = fixedRoute.match(/(\{\?.*\})/g);
 		const queryParams = [];
 		if (queryParamMatches?.length) {
 			for (const match of queryParamMatches) fixedRoute = fixedRoute.replace(match, "");
-			const paramNames = lodash.default.uniq(queryParamMatches.join(",").replace(/(\{\?)|(\})|\s/g, "").split(","));
+			const paramNames = (0, es_toolkit.uniq)(queryParamMatches.join(",").replace(/(\{\?)|(\})|\s/g, "").split(","));
 			for (const paramName of paramNames) {
-				if (paramName.includes("-")) consola.consola.warn("wrong query param name", paramName);
+				if (typeof paramName === "string" && paramName.includes("-")) consola.consola.warn("wrong query param name", paramName);
 				queryParams.push({
 					$match: paramName,
-					name: lodash.default.camelCase(paramName),
+					name: typeof paramName === "string" ? (0, es_toolkit_compat.camelCase)(paramName) : (0, es_toolkit_compat.camelCase)(String(paramName)),
 					required: true,
 					type: "string",
 					description: "",
@@ -1758,7 +1755,7 @@ var SchemaRoutes = class {
 			}
 		}
 		const result = {
-			originalRoute: originalRouteName || "",
+			originalRoute: rawRoute || "",
 			route: fixedRoute,
 			pathParams,
 			queryParams
@@ -1775,7 +1772,7 @@ var SchemaRoutes = class {
 			formData: [],
 			cookie: []
 		};
-		lodash.default.each(parameters, (parameter) => {
+		for (const parameter of parameters || []) {
 			const refTypeInfo = this.schemaParserFabric.schemaUtils.getSchemaRefType(parameter);
 			let routeParam = null;
 			if (refTypeInfo?.rawTypeData.in && refTypeInfo.rawTypeData) {
@@ -1786,7 +1783,7 @@ var SchemaRoutes = class {
 				};
 				if (parameter?.required && !routeParam.required) routeParam.required = parameter.required;
 			} else {
-				if (!parameter.in) return;
+				if (!parameter.in) continue;
 				if (!routeParams[parameter.in]) routeParams[parameter.in] = [];
 				routeParam = {
 					...parameter,
@@ -1794,16 +1791,19 @@ var SchemaRoutes = class {
 				};
 			}
 			if (routeParam.in === "path") {
-				if (!routeParam.name) return;
-				routeParam.name = lodash.default.camelCase(routeParam.name);
+				if (!routeParam.name) continue;
+				routeParam.name = (0, es_toolkit_compat.camelCase)(routeParam.name);
 			}
-			if (routeParam) routeParams[routeParam.in].push(routeParam);
-		});
+			routeParams[routeParam.in].push(routeParam);
+		}
 		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)))]));
+	getContentTypes = (requestInfo, extraContentTypes) => {
+		const requestInfoArray = Array.isArray(requestInfo) ? requestInfo : Object.values(requestInfo || {});
+		return (0, es_toolkit.uniq)((0, es_toolkit.compact)([...extraContentTypes || [], ...(0, es_toolkit.flattenDeep)(requestInfoArray.map((requestInfoData) => requestInfoData && Object.keys(requestInfoData?.content || {})))]));
+	};
 	getContentKind = (contentTypes) => {
 		if (contentTypes.includes("application/vnd.api+json")) return CONTENT_KIND.JSON_API;
 		if (contentTypes.some((contentType) => contentType.startsWith("application/json")) || contentTypes.some((contentType) => contentType.endsWith("+json"))) return CONTENT_KIND.JSON;
@@ -1815,7 +1815,7 @@ var SchemaRoutes = class {
 	};
 	isSuccessStatus = (status) => this.config.defaultResponseAsSuccess && status === "default" || +status >= this.config.successResponseStatusRange[0] && +status <= this.config.successResponseStatusRange[1] || status === "2xx";
 	getSchemaFromRequestType = (requestInfo) => {
-		const content = lodash.default.get(requestInfo, "content");
+		const content = (0, es_toolkit_compat.get)(requestInfo, "content");
 		if (!content) return null;
 		for (const dataType in content) if (content[dataType]?.schema) return {
 			...content[dataType].schema,
@@ -1829,13 +1829,13 @@ var SchemaRoutes = class {
 		if (schema) {
 			const content = this.schemaParserFabric.getInlineParseContent(schema, typeName, [operationId]);
 			const foundedSchemaByName = parsedSchemas.find((parsedSchema) => this.typeNameFormatter.format(parsedSchema.name) === content);
-			const foundSchemaByContent = parsedSchemas.find((parsedSchema) => lodash.default.isEqual(parsedSchema.content, content));
+			const foundSchemaByContent = parsedSchemas.find((parsedSchema) => (0, es_toolkit.isEqual)(parsedSchema.content, content));
 			const foundSchema = foundedSchemaByName || foundSchemaByContent;
 			return foundSchema ? this.typeNameFormatter.format(foundSchema.name) : content;
 		}
 		if (refTypeInfo) {
 			const typeNameWithoutOpId = refTypeInfo.typeName.replace(operationId, "");
-			if (parsedSchemas.find((schema$1) => schema$1.name === typeNameWithoutOpId)) return this.typeNameFormatter.format(typeNameWithoutOpId);
+			if (parsedSchemas.find((schema) => schema.name === typeNameWithoutOpId)) return this.typeNameFormatter.format(typeNameWithoutOpId);
 			switch (refTypeInfo.componentName) {
 				case "schemas": return this.typeNameFormatter.format(refTypeInfo.typeName);
 				case "responses":
@@ -1845,23 +1845,27 @@ var SchemaRoutes = class {
 		}
 		return defaultType || this.config.Ts.Keyword.Any;
 	};
-	getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType }) => lodash.default.reduce(requestInfos, (acc, requestInfo, status) => {
-		const contentTypes = this.getContentTypes([requestInfo]);
-		return [...acc, {
-			...requestInfo || {},
-			contentTypes,
-			contentKind: this.getContentKind(contentTypes),
-			type: this.schemaParserFabric.schemaUtils.safeAddNullToType(requestInfo, this.getTypeFromRequestInfo({
-				requestInfo,
-				parsedSchemas,
-				operationId,
-				defaultType
-			})),
-			description: this.schemaParserFabric.schemaFormatters.formatDescription(requestInfo.description || "", true),
-			status: Number.isNaN(+status) ? status : +status,
-			isSuccess: this.isSuccessStatus(status)
-		}];
-	}, []);
+	getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType }) => {
+		const result = [];
+		for (const [status, requestInfo] of Object.entries(requestInfos || {})) {
+			const contentTypes = this.getContentTypes([requestInfo], operationId);
+			result.push({
+				...requestInfo || {},
+				contentTypes,
+				contentKind: this.getContentKind(contentTypes),
+				type: this.schemaParserFabric.schemaUtils.safeAddNullToType(requestInfo, this.getTypeFromRequestInfo({
+					requestInfo,
+					parsedSchemas,
+					operationId,
+					defaultType
+				})),
+				description: this.schemaParserFabric.schemaFormatters.formatDescription(requestInfo.description || "", true),
+				status: Number.isNaN(+status) ? status : +status,
+				isSuccess: this.isSuccessStatus(status)
+			});
+		}
+		return result;
+	};
 	getResponseBodyInfo = (routeInfo, parsedSchemas) => {
 		const { produces, operationId, responses } = routeInfo;
 		const contentTypes = this.getContentTypes(responses, [...produces || [], routeInfo["x-accepts"]]);
@@ -1970,13 +1974,12 @@ var SchemaRoutes = class {
 			};
 			return acc;
 		}, {});
-		const fixedQueryParams = lodash.default.reduce(lodash.default.get(queryObjectSchema, "properties", {}), (acc, property, name$1) => {
-			if (name$1 && typeof property === "object") acc[name$1] = {
-				...property,
-				in: "query"
-			};
-			return acc;
-		}, {});
+		const fixedQueryParams = {};
+		const queryObjectProperties = (0, es_toolkit_compat.get)(queryObjectSchema, "properties") || {};
+		for (const [name, property] of Object.entries(queryObjectProperties)) if (name && typeof property === "object") fixedQueryParams[name] = {
+			...property,
+			in: "query"
+		};
 		const schema = {
 			...queryObjectSchema,
 			properties: {
@@ -2019,7 +2022,7 @@ var SchemaRoutes = class {
 				successResponse.schema.contentKind = contentKind;
 				if (successResponse.schema.typeData) successResponse.schema.typeData.isExtractedResponseBody = true;
 				successResponse.type = this.schemaParserFabric.getInlineParseContent({ $ref: successResponse.schema.$ref });
-				if (idx > -1) lodash.default.assign(responseBodyInfo.responses[idx], {
+				if (idx > -1) Object.assign(responseBodyInfo.responses[idx], {
 					...successResponse.schema,
 					type: successResponse.type
 				});
@@ -2032,18 +2035,18 @@ var SchemaRoutes = class {
 				suffixes: this.config.extractingOptions.responseErrorSuffix,
 				resolver: this.config.extractingOptions.responseErrorNameResolver
 			});
-			const errorSchemas = responseBodyInfo.error.schemas.map(this.getSchemaFromRequestType).filter(Boolean);
+			const errorSchemas = (0, es_toolkit.compact)(responseBodyInfo.error.schemas.map(this.getSchemaFromRequestType));
 			if (!errorSchemas.length) return;
 			const schema = this.schemaParserFabric.parseSchema({
 				oneOf: errorSchemas,
-				title: errorSchemas.map((schema$1) => schema$1.title).filter(Boolean).join(" "),
-				description: errorSchemas.map((schema$1) => schema$1.description).filter(Boolean).join("\n")
+				title: (0, es_toolkit.compact)(errorSchemas.map((schema) => schema.title)).join(" "),
+				description: (0, es_toolkit.compact)(errorSchemas.map((schema) => schema.description)).join("\n")
 			}, null, [routeInfo.operationId]);
 			const component = this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
 				"components",
 				"schemas",
 				typeName
-			]), { ...schema });
+			]), schema);
 			responseBodyInfo.error.schemas = [component];
 			if (component.typeData) component.typeData.isExtractedResponseError = true;
 			responseBodyInfo.error.type = this.typeNameFormatter.format(component.typeName);
@@ -2071,11 +2074,11 @@ var SchemaRoutes = class {
 	parseRouteInfo = (rawRouteName, routeInfo, method, usageSchema, parsedSchemas) => {
 		const { security: globalSecurity } = usageSchema;
 		const { moduleNameIndex, moduleNameFirstTag, extractRequestParams } = this.config;
-		const { operationId, requestBody, security, parameters, summary, description: description$1, tags, responses, requestBodyName, produces, consumes,...otherInfo } = routeInfo;
+		const { operationId, requestBody, security, parameters, summary, description, tags, responses, requestBodyName, produces, consumes, ...otherInfo } = routeInfo;
 		const { route, pathParams: pathParamsFromRouteName, queryParams: queryParamsFromRouteName } = this.parseRouteName(rawRouteName);
 		const routeId = generateId();
 		const firstTag = tags && tags.length > 0 ? tags[0] : null;
-		const moduleName = moduleNameFirstTag && firstTag ? lodash.default.camelCase(firstTag) : lodash.default.camelCase(lodash.default.compact(route.split("/"))[moduleNameIndex]);
+		const moduleName = moduleNameFirstTag && firstTag ? (0, es_toolkit_compat.camelCase)(firstTag) : (0, es_toolkit_compat.camelCase)((0, es_toolkit.compact)(route.split("/"))[moduleNameIndex] || "");
 		let hasSecurity = !!globalSecurity?.length;
 		if (security) hasSecurity = security.length > 0;
 		const routeParams = this.getRouteParams(routeInfo, pathParamsFromRouteName, queryParamsFromRouteName);
@@ -2095,7 +2098,7 @@ var SchemaRoutes = class {
 			route: rawRouteName,
 			moduleName,
 			responsesTypes: responseBodyInfo.responses,
-			description: description$1,
+			description,
 			tags,
 			summary,
 			responses,
@@ -2192,7 +2195,7 @@ var SchemaRoutes = class {
 	};
 	attachSchema = ({ usageSchema, parsedSchemas }) => {
 		this.config.routeNameDuplicatesMap.clear();
-		const pathsEntries = lodash.default.entries(usageSchema.paths);
+		const pathsEntries = Object.entries(usageSchema.paths || {});
 		for (const [rawRouteName, routeInfoByMethodsMap] of pathsEntries) {
 			const routeInfosMap = this.createRequestsMap(routeInfoByMethodsMap);
 			for (const [method, routeInfo] of Object.entries(routeInfosMap)) {
@@ -2216,37 +2219,36 @@ var SchemaRoutes = class {
 			} else modules.$outOfModule.push(route);
 			return modules;
 		}, { $outOfModule: [] });
-		const routeGroups = lodash.default.reduce(groupedRoutes, (acc, routesGroup, moduleName) => {
-			if (moduleName === "$outOfModule") acc.outOfModule = routesGroup;
-			else {
-				if (!acc.combined) acc.combined = [];
-				acc.combined.push({
-					moduleName,
-					routes: routesGroup.map((route) => {
-						const { original: originalName, usage: usageName } = route.routeName;
-						if (routesGroup.length > 1 && usageName !== originalName && !routesGroup.some(({ routeName, id }) => id !== route.id && originalName === routeName.original)) return {
-							...route,
-							routeName: {
-								...route.routeName,
-								usage: originalName
-							}
-						};
-						return route;
-					})
-				});
-			}
-			return acc;
-		}, {});
+		const routeGroups = {
+			outOfModule: void 0,
+			combined: void 0
+		};
+		for (const [moduleName, routesGroup] of Object.entries(groupedRoutes)) if (moduleName === "$outOfModule") routeGroups.outOfModule = routesGroup;
+		else {
+			if (!routeGroups.combined) routeGroups.combined = [];
+			routeGroups.combined.push({
+				moduleName,
+				routes: routesGroup.map((route) => {
+					const { original: originalName, usage: usageName } = route.routeName;
+					if (routesGroup.length > 1 && usageName !== originalName && !routesGroup.some(({ routeName, id }) => id !== route.id && originalName === routeName.original)) return {
+						...route,
+						routeName: {
+							...route.routeName,
+							usage: originalName
+						}
+					};
+					return route;
+				})
+			});
+		}
 		if (this.config.sortRoutes) {
 			if (routeGroups.outOfModule) routeGroups.outOfModule = this.sortRoutes(routeGroups.outOfModule);
-			if (routeGroups.combined) lodash.default.each(routeGroups.combined, (routeGroup) => {
-				routeGroup.routes = this.sortRoutes(routeGroup.routes);
-			});
+			if (routeGroups.combined) for (const routeGroup of routeGroups.combined) routeGroup.routes = this.sortRoutes(routeGroup.routes);
 		}
 		return routeGroups;
 	};
 	sortRoutes = (routes) => {
-		return lodash.default.slice(routes).sort((routeA, routeB) => routeA.routeName.usage.localeCompare(routeB.routeName.usage));
+		return routes.slice().sort((routeA, routeB) => routeA.routeName.usage.localeCompare(routeB.routeName.usage));
 	};
 };
 
@@ -2261,8 +2263,8 @@ var SchemaWalker = class {
 		this.config = config;
 		this.swaggerSchemaResolver = swaggerSchemaResolver;
 	}
-	addSchema = (name$1, schema) => {
-		this.schemas.set(name$1, structuredClone(schema));
+	addSchema = (name, schema) => {
+		this.schemas.set(name, structuredClone(schema));
 	};
 	_isLocalRef = (ref) => {
 		return ref.startsWith("#");
@@ -2271,8 +2273,7 @@ var SchemaWalker = class {
 		return ref.startsWith("http://") || ref.startsWith("https://");
 	};
 	_getRefDataFromSchema = (schema, ref) => {
-		const path$1 = ref.replace("#", "").split("/");
-		const refData = lodash.default.get(schema, path$1);
+		const refData = (0, es_toolkit_compat.get)(schema, ref.replace("#", "").split("/"));
 		if (refData) this.caches.set(ref, refData);
 		return refData;
 	};
@@ -2285,14 +2286,14 @@ var Request = class {
 	constructor(config) {
 		this.config = config;
 	}
-	async download({ url: url$1, authToken,...options }) {
+	async download({ url, authToken, ...options }) {
 		const requestOptions = {};
 		if (authToken) requestOptions.headers = { Authorization: authToken };
-		lodash.default.merge(requestOptions, options, this.config.requestOptions);
+		(0, es_toolkit.merge)((0, es_toolkit.merge)(requestOptions, options), this.config.requestOptions || {});
 		try {
-			return await (await fetch(url$1, requestOptions)).text();
+			return await (await fetch(url, requestOptions)).text();
 		} catch (error) {
-			const message = `error while fetching data from URL "${url$1}"`;
+			const message = `error while fetching data from URL "${url}"`;
 			consola.consola.error(message, error);
 			return message;
 		}
@@ -2311,21 +2312,21 @@ var SwaggerSchemaResolver = class {
 		this.request = new Request(config);
 	}
 	async create() {
-		const { spec, patch, input, url: url$1, authorizationToken } = this.config;
+		const { spec, patch, input, url, authorizationToken } = this.config;
 		if (spec) return await this.convertSwaggerObject(spec, { patch });
-		const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url$1, authorizationToken);
+		const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url, authorizationToken);
 		const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
 		return await this.convertSwaggerObject(swaggerSchemaObject, { patch });
 	}
 	convertSwaggerObject(swaggerSchema, converterOptions) {
 		return new Promise((resolve) => {
 			const result = structuredClone(swaggerSchema);
-			result.info = lodash.default.merge({
+			result.info = (0, es_toolkit.merge)({
 				title: "No title",
 				version: ""
-			}, result.info);
+			}, result.info || {});
 			if (!Object.hasOwn(result, "openapi")) {
-				result.paths = lodash.default.merge({}, result.paths);
+				result.paths = (0, es_toolkit.merge)({}, result.paths || {});
 				swagger2openapi.convertObj(result, {
 					...converterOptions,
 					resolveInternal: true,
@@ -2333,7 +2334,7 @@ var SwaggerSchemaResolver = class {
 					refSiblings: "preserve",
 					rbname: "requestBodyName"
 				}, (err, options) => {
-					const parsedSwaggerSchema = lodash.default.get(err, "options.openapi", lodash.default.get(options, "openapi"));
+					const parsedSwaggerSchema = (0, es_toolkit_compat.get)(err, "options.openapi") ?? (0, es_toolkit_compat.get)(options, "openapi");
 					if (!parsedSwaggerSchema && err) throw err;
 					this.config.update({ convertedFromSwagger2: true });
 					resolve({
@@ -2368,23 +2369,21 @@ var SwaggerSchemaResolver = class {
 		}
 	}
 	fixSwaggerSchema({ usageSchema, originalSchema }) {
-		const usagePaths = lodash.default.get(usageSchema, "paths");
-		const originalPaths = lodash.default.get(originalSchema, "paths");
-		lodash.default.each(usagePaths, (usagePathObject, route) => {
-			const originalPathObject = lodash.default.get(originalPaths, route);
-			lodash.default.each(usagePathObject, (usageRouteInfo, methodName) => {
-				const originalRouteInfo = lodash.default.get(originalPathObject, methodName);
-				const usageRouteParams = lodash.default.get(usageRouteInfo, "parameters", []);
-				const originalRouteParams = lodash.default.get(originalRouteInfo, "parameters", []);
+		const usagePaths = (0, es_toolkit_compat.get)(usageSchema, "paths") || {};
+		const originalPaths = (0, es_toolkit_compat.get)(originalSchema, "paths") || {};
+		for (const [route, usagePathObject] of Object.entries(usagePaths)) {
+			const originalPathObject = (0, es_toolkit_compat.get)(originalPaths, route) || {};
+			for (const [methodName, usageRouteInfo] of Object.entries(usagePathObject)) {
+				const originalRouteInfo = (0, es_toolkit_compat.get)(originalPathObject, methodName) || {};
+				const usageRouteParams = (0, es_toolkit_compat.get)(usageRouteInfo, "parameters") || [];
+				const originalRouteParams = (0, es_toolkit_compat.get)(originalRouteInfo, "parameters") || [];
 				if (typeof usageRouteInfo === "object") {
-					usageRouteInfo.consumes = lodash.default.uniq(lodash.default.compact([...usageRouteInfo.consumes || [], ...originalRouteInfo.consumes || []]));
-					usageRouteInfo.produces = lodash.default.uniq(lodash.default.compact([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
+					usageRouteInfo.consumes = (0, es_toolkit.uniq)((0, es_toolkit.compact)([...usageRouteInfo.consumes || [], ...originalRouteInfo.consumes || []]));
+					usageRouteInfo.produces = (0, es_toolkit.uniq)((0, es_toolkit.compact)([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
 				}
-				lodash.default.each(originalRouteParams, (originalRouteParam) => {
-					if (!usageRouteParams.find((param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name)) usageRouteParams.push(originalRouteParam);
-				});
-			});
-		});
+				for (const originalRouteParam of originalRouteParams) if (!usageRouteParams.find((param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name)) usageRouteParams.push(originalRouteParam);
+			}
+		}
 	}
 };
 
@@ -2404,10 +2403,10 @@ var TemplatesWorker = class {
 		if (this.config.silent) consola.consola.level = 0;
 	}
 	getTemplatePaths = (config) => {
-		const __dirname$2 = node_path.dirname(node_url.fileURLToPath(require("url").pathToFileURL(__filename).href));
-		const baseTemplatesPath = node_path.resolve(__dirname$2, "../templates/base");
-		const defaultTemplatesPath = node_path.resolve(__dirname$2, "../templates/default");
-		const modularTemplatesPath = node_path.resolve(__dirname$2, "../templates/modular");
+		const __dirname = node_path.dirname(node_url.fileURLToPath(require("url").pathToFileURL(__filename).href));
+		const baseTemplatesPath = node_path.resolve(__dirname, "../templates/base");
+		const defaultTemplatesPath = node_path.resolve(__dirname, "../templates/default");
+		const modularTemplatesPath = node_path.resolve(__dirname, "../templates/modular");
 		return {
 			base: baseTemplatesPath,
 			default: defaultTemplatesPath,
@@ -2416,7 +2415,7 @@ var TemplatesWorker = class {
 			custom: config.templates && node_path.resolve(process.cwd(), config.templates)
 		};
 	};
-	cropExtension = (path$1) => this.config.templateExtensions.reduce((path$2, ext) => path$2.endsWith(ext) ? path$2.replace(ext, "") : path$2, path$1);
+	cropExtension = (path) => this.config.templateExtensions.reduce((path, ext) => path.endsWith(ext) ? path.replace(ext, "") : path, path);
 	getTemplateFullPath = (path_, fileName) => {
 		const raw = node_path.resolve(path_, "./", this.cropExtension(fileName));
 		return this.config.templateExtensions.map((extension) => `${raw}${extension}`).find((variant) => !!this.fileSystem.pathIsExist(variant));
@@ -2425,39 +2424,39 @@ var TemplatesWorker = class {
 		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) => {
+	getTemplate = (name, fileName, path) => {
 		const { templatePaths } = this.config;
-		if (path$1) return this.fileSystem.getFileContent(path$1);
+		if (path) return this.fileSystem.getFileContent(path);
 		if (!fileName) return "";
 		const customFullPath = templatePaths.custom && this.getTemplateFullPath(templatePaths.custom, fileName);
 		let fileContent = customFullPath && this.fileSystem.getFileContent(customFullPath);
 		if (fileContent) {
-			consola.consola.info(`"${name$1.toLowerCase()}" template found in "${templatePaths.custom}"`);
+			consola.consola.info(`"${name.toLowerCase()}" template found in "${templatePaths.custom}"`);
 			return fileContent;
 		}
 		const baseFullPath = this.getTemplateFullPath(templatePaths.base, fileName);
 		if (baseFullPath) fileContent = this.fileSystem.getFileContent(baseFullPath);
-		else if (templatePaths.custom) consola.consola.warn("Code generator will use the default template:", `"${name$1.toLowerCase()}"`, "template not found in", `"${templatePaths.custom}"`);
-		else consola.consola.info(`Code generator will use the default template for "${name$1.toLowerCase()}"`);
+		else if (templatePaths.custom) consola.consola.warn("Code generator will use the default template:", `"${name.toLowerCase()}"`, "template not found in", `"${templatePaths.custom}"`);
+		else consola.consola.info(`Code generator will use the default template for "${name.toLowerCase()}"`);
 		const originalFullPath = this.getTemplateFullPath(templatePaths.original, fileName);
 		if (originalFullPath) fileContent = this.fileSystem.getFileContent(originalFullPath);
 		return fileContent;
 	};
 	getTemplates = ({ templatePaths }) => {
 		if (templatePaths.custom) consola.consola.info(`try to read templates from directory "${templatePaths.custom}"`);
-		return lodash.default.reduce(this.config.templateInfos, (acc, { name: name$1, fileName }) => ({
+		return this.config.templateInfos.reduce((acc, { name, fileName }) => ({
 			...acc,
-			[name$1]: this.getTemplate(name$1, fileName)
+			[name]: this.getTemplate(name, fileName)
 		}), {});
 	};
-	findTemplateWithExt = (path$1) => {
-		const raw = this.cropExtension(path$1);
+	findTemplateWithExt = (path) => {
+		const raw = this.cropExtension(path);
 		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}`));
+		const foundTemplatePathKey = Object.keys(this.config.templatePaths).find((key) => path_.startsWith(`@${key}`));
 		if (foundTemplatePathKey) {
-			const rawPath = node_path.resolve(path_.replace(`@${foundTemplatePathKey}`, lodash.default.get(this.config.templatePaths, foundTemplatePathKey)));
+			const rawPath = node_path.resolve(path_.replace(`@${foundTemplatePathKey}`, (0, es_toolkit_compat.get)(this.config.templatePaths, foundTemplatePathKey)));
 			const fixedPath = this.findTemplateWithExt(rawPath);
 			if (fixedPath) return this.fileSystem.getFileContent(fixedPath);
 		}
@@ -2472,7 +2471,7 @@ var TemplatesWorker = class {
 		return eta$1.render(eta$1.compile(template, { async: false }), {
 			...this.getRenderTemplateData(),
 			...configuration
-		}, { includeFile: (path$1, configuration$1) => this.renderTemplate(this.getTemplateContent(path$1), configuration$1) });
+		}, { includeFile: (path, configuration) => this.renderTemplate(this.getTemplateContent(path), configuration) });
 	};
 };
 
@@ -2539,51 +2538,50 @@ var TypeNameFormatter = class {
 	constructor(config) {
 		this.config = config;
 	}
-	format = (name$1, options = {}) => {
+	format = (name, options = {}) => {
 		const schemaType = options.type ?? "type-name";
 		const typePrefix = schemaType === "enum-key" ? this.config.enumKeyPrefix : this.config.typePrefix;
 		const typeSuffix = schemaType === "enum-key" ? this.config.enumKeySuffix : this.config.typeSuffix;
-		const hashKey = `${typePrefix}_${name$1}_${typeSuffix}`;
-		if (typeof name$1 !== "string") {
-			consola.consola.warn("wrong model name", name$1);
-			return name$1;
+		const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
+		if (typeof name !== "string") {
+			consola.consola.warn("wrong model name", name);
+			return name;
 		}
-		if (/^(?!\d)([A-Z0-9_]{1,})$/g.test(name$1)) return lodash.default.compact([
+		if (/^(?!\d)([A-Z0-9_]{1,})$/g.test(name)) return (0, es_toolkit.compact)([
 			typePrefix,
-			name$1,
+			name,
 			typeSuffix
 		]).join("_");
 		if (this.formattedModelNamesMap.has(hashKey)) return this.formattedModelNamesMap.get(hashKey);
-		const fixedModelName = this.fixModelName(name$1, { type: schemaType });
-		const formattedName = lodash.default.startCase(`${typePrefix}_${fixedModelName}_${typeSuffix}`).replace(/\s/g, "");
-		const formattedResultName = this.config.hooks.onFormatTypeName(formattedName, name$1, schemaType) || formattedName;
+		const formattedName = (0, es_toolkit_compat.startCase)(`${typePrefix}_${this.fixModelName(name, { type: schemaType })}_${typeSuffix}`).replace(/\s/g, "");
+		const formattedResultName = this.config.hooks.onFormatTypeName(formattedName, name, schemaType) || formattedName;
 		this.formattedModelNamesMap.set(hashKey, formattedResultName);
 		return formattedResultName;
 	};
-	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)) 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, "");
+	isValidName = (name) => /^([A-Za-z$_]{1,})$/g.test(name);
+	fixModelName = (name, options) => {
+		if (!this.isValidName(name)) {
+			if (!/^[a-zA-Z_$]/g.test(name)) return `${options.type === "enum-key" ? this.config.fixInvalidEnumKeyPrefix : this.config.fixInvalidTypeNamePrefix} ${name}`;
+			if (name.includes(".")) return name.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.includes("-")) return (0, es_toolkit_compat.startCase)(name).replace(/ /g, "");
 		}
-		return name$1;
+		return name;
 	};
 };
 
 //#endregion
 //#region src/util/file-system.ts
 var FileSystem = class {
-	getFileContent = (path$1) => {
-		return node_fs.readFileSync(path$1, { encoding: "utf8" });
+	getFileContent = (path) => {
+		return node_fs.readFileSync(path, { encoding: "utf8" });
 	};
-	readDir = (path$1) => {
-		return node_fs.readdirSync(path$1);
+	readDir = (path) => {
+		return node_fs.readdirSync(path);
 	};
-	pathIsDir = (path$1) => {
-		if (!path$1) return false;
+	pathIsDir = (path) => {
+		if (!path) return false;
 		try {
-			return node_fs.statSync(path$1).isDirectory();
+			return node_fs.statSync(path).isDirectory();
 		} catch (e) {
 			return false;
 		}
@@ -2593,36 +2591,45 @@ var FileSystem = class {
 		if (fileNameParts.length > 1) fileNameParts.pop();
 		return fileNameParts.join(".");
 	};
-	removeDir = (path$1) => {
+	removeDir = (path) => {
 		try {
-			if (typeof node_fs.rmSync === "function") node_fs.rmSync(path$1, { recursive: true });
-			else node_fs.rmdirSync(path$1, { recursive: true });
+			if (typeof node_fs.rmSync === "function") node_fs.rmSync(path, { recursive: true });
+			else node_fs.rmdirSync(path, { recursive: true });
 		} catch (e) {
 			consola.consola.debug("failed to remove dir", e);
 		}
 	};
-	createDir = (path$1) => {
+	createDir = (path) => {
 		try {
-			node_fs.mkdirSync(path$1, { recursive: true });
+			node_fs.mkdirSync(path, { recursive: true });
 		} catch (e) {
 			consola.consola.debug("failed to create dir", e);
 		}
 	};
-	cleanDir = (path$1) => {
-		this.removeDir(path$1);
-		this.createDir(path$1);
+	cleanDir = (path) => {
+		this.removeDir(path);
+		this.createDir(path);
 	};
-	pathIsExist = (path$1) => {
-		return !!path$1 && node_fs.existsSync(path$1);
+	pathIsExist = (path) => {
+		return !!path && node_fs.existsSync(path);
 	};
 	createFile = ({ path: path_, fileName, content, withPrefix }) => {
-		const __dirname$2 = node_path.dirname(node_url.fileURLToPath(require("url").pathToFileURL(__filename).href));
-		const absolutePath = node_path.resolve(__dirname$2, path_, `./${fileName}`);
+		const __dirname = node_path.dirname(node_url.fileURLToPath(require("url").pathToFileURL(__filename).href));
+		const absolutePath = node_path.resolve(__dirname, path_, `./${fileName}`);
 		const fileContent = `${withPrefix ? FILE_PREFIX : ""}${content}`;
 		return node_fs.writeFileSync(absolutePath, fileContent);
 	};
 };
 
+//#endregion
+//#region src/util/lodash-compat.ts
+function createLodashCompat() {
+	return {
+		...es_toolkit,
+		...es_toolkit_compat
+	};
+}
+
 //#endregion
 //#region src/code-gen-process.ts
 const PATCHABLE_INSTANCES = [
@@ -2677,16 +2684,14 @@ var CodeGenProcess = class {
 		if (this.config.swaggerSchema) swagger.usageSchema = this.config.swaggerSchema;
 		if (this.config.originalSchema) swagger.originalSchema = this.config.originalSchema;
 		this.schemaComponentsMap.clear();
-		lodash.default.each(swagger.usageSchema.components, (component, componentName) => lodash.default.each(component, (rawTypeData, typeName) => {
-			this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
-				"components",
-				componentName,
-				typeName
-			]), rawTypeData);
-		}));
+		for (const [componentName, component] of Object.entries(swagger.usageSchema.components || {})) for (const [typeName, rawTypeData] of Object.entries(component)) this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
+			"components",
+			componentName,
+			typeName
+		]), rawTypeData);
 		this.schemaComponentsMap.discriminatorsFirst();
 		this.schemaComponentsMap.enumsFirst();
-		const parsedSchemas = this.schemaComponentsMap.filter(lodash.default.compact(["schemas", this.config.extractResponses && "responses"])).map((schemaComponent) => {
+		const parsedSchemas = this.schemaComponentsMap.filter((0, es_toolkit.compact)(["schemas", this.config.extractResponses && "responses"])).map((schemaComponent) => {
 			const parsed = this.schemaParserFabric.parseSchema(schemaComponent.rawTypeData, schemaComponent.typeName);
 			schemaComponent.typeData = parsed;
 			return parsed;
@@ -2744,7 +2749,7 @@ var CodeGenProcess = class {
 			utils: {
 				Ts: this.config.Ts,
 				formatDescription: this.schemaParserFabric.schemaFormatters.formatDescription,
-				internalCase,
+				internalCase: es_toolkit_compat.camelCase,
 				classNameCase: pascalCase,
 				pascalCase,
 				getInlineParseContent: this.schemaParserFabric.getInlineParseContent,
@@ -2761,7 +2766,7 @@ var CodeGenProcess = class {
 					return ` * ${line}${eol ? "\n" : ""}`;
 				},
 				NameResolver,
-				_: lodash.default,
+				_: createLodashCompat(),
 				require: this.templatesWorker.requireFnFromTemplate
 			},
 			config: this.config
@@ -2770,7 +2775,7 @@ var CodeGenProcess = class {
 	collectModelTypes = () => {
 		const components = this.schemaComponentsMap.getComponents();
 		let modelTypes = [];
-		const modelTypeComponents = lodash.default.compact(["schemas", this.config.extractResponses && "responses"]);
+		const modelTypeComponents = (0, es_toolkit.compact)(["schemas", this.config.extractResponses && "responses"]);
 		const getSchemaComponentsCount = () => this.schemaComponentsMap.filter(...modelTypeComponents).length;
 		let schemaComponentsCount = getSchemaComponentsCount();
 		let processedCount = 0;
@@ -2792,14 +2797,14 @@ var CodeGenProcess = class {
 		if (!typeInfo.typeData) typeInfo.typeData = this.schemaParserFabric.parseSchema(typeInfo.rawTypeData, typeInfo.typeName);
 		const rawTypeData = typeInfo.typeData;
 		const typeData = this.schemaParserFabric.schemaFormatters.base[rawTypeData.type] ? this.schemaParserFabric.schemaFormatters.base[rawTypeData.type](rawTypeData) : rawTypeData;
-		const { typeIdentifier, name: originalName, content, description: description$1 } = typeData;
-		const name$1 = this.typeNameFormatter.format(originalName);
-		if (name$1 === null) return null;
+		const { typeIdentifier, name: originalName, content, description } = typeData;
+		const name = this.typeNameFormatter.format(originalName);
+		if (name === null) return null;
 		const preparedModelType = {
 			...typeData,
 			typeIdentifier,
-			name: name$1,
-			description: description$1,
+			name,
+			description,
 			$content: rawTypeData.content,
 			rawContent: rawTypeData.content,
 			content,
@@ -2811,7 +2816,7 @@ var CodeGenProcess = class {
 	generateOutputFiles = async ({ configuration }) => {
 		const { modular, templatesToRender } = this.config;
 		const output = modular ? await this.createMultipleFileInfos(templatesToRender, configuration) : await this.createSingleFileInfo(templatesToRender, configuration);
-		if (!lodash.default.isEmpty(configuration.extraTemplates)) for (const extraTemplate of configuration.extraTemplates) {
+		if (configuration.extraTemplates?.length) for (const extraTemplate of configuration.extraTemplates) {
 			const content = this.templatesWorker.renderTemplate(this.fileSystem.getFileContent(extraTemplate.path), configuration);
 			output.push(...await this.createOutputFileInfo(configuration, extraTemplate.name, content));
 		}
@@ -2861,7 +2866,7 @@ var CodeGenProcess = class {
 	};
 	createSingleFileInfo = async (templatesToRender, configuration) => {
 		const { generateRouteTypes, generateClient } = configuration.config;
-		return await this.createOutputFileInfo(configuration, configuration.fileName, lodash.default.compact([
+		return await this.createOutputFileInfo(configuration, configuration.fileName, (0, es_toolkit.compact)([
 			this.templatesWorker.renderTemplate(templatesToRender.dataContracts, configuration),
 			generateRouteTypes && this.templatesWorker.renderTemplate(templatesToRender.routeTypes, configuration),
 			generateClient && this.templatesWorker.renderTemplate(templatesToRender.httpClient, configuration),
@@ -2897,21 +2902,21 @@ var CodeGenProcess = class {
 	createApiConfig = (swaggerSchema) => {
 		const { info, servers, host, basePath, externalDocs, tags } = swaggerSchema;
 		const server = servers?.[0] || { url: "" };
-		const { title = "No title", version: version$1 } = info || {};
+		const { title = "No title", version } = info || {};
 		const { url: serverUrl } = server;
 		return {
 			info: info || {},
 			servers: servers || [],
 			basePath,
 			host,
-			externalDocs: lodash.default.merge({
+			externalDocs: (0, es_toolkit.merge)({
 				url: "",
 				description: ""
-			}, externalDocs),
-			tags: lodash.default.compact(tags),
+			}, externalDocs || {}),
+			tags: (0, es_toolkit.compact)(tags || []),
 			baseUrl: serverUrl,
 			title,
-			version: version$1
+			version
 		};
 	};
 	injectClassInstance = (key, value) => {
@@ -2922,28 +2927,28 @@ 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 RequestContentKind = /* @__PURE__ */ function(RequestContentKind) {
+	RequestContentKind["JSON"] = "JSON";
+	RequestContentKind["URL_ENCODED"] = "URL_ENCODED";
+	RequestContentKind["FORM_DATA"] = "FORM_DATA";
+	RequestContentKind["IMAGE"] = "IMAGE";
+	RequestContentKind["OTHER"] = "OTHER";
+	RequestContentKind["TEXT"] = "TEXT";
+	return RequestContentKind;
 }({});
-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;
+let SCHEMA_TYPES = /* @__PURE__ */ function(SCHEMA_TYPES) {
+	SCHEMA_TYPES["ARRAY"] = "array";
+	SCHEMA_TYPES["OBJECT"] = "object";
+	SCHEMA_TYPES["ENUM"] = "enum";
+	SCHEMA_TYPES["REF"] = "$ref";
+	SCHEMA_TYPES["PRIMITIVE"] = "primitive";
+	SCHEMA_TYPES["COMPLEX"] = "complex";
+	SCHEMA_TYPES["COMPLEX_ONE_OF"] = "oneOf";
+	SCHEMA_TYPES["COMPLEX_ANY_OF"] = "anyOf";
+	SCHEMA_TYPES["COMPLEX_ALL_OF"] = "allOf";
+	SCHEMA_TYPES["COMPLEX_NOT"] = "not";
+	SCHEMA_TYPES["COMPLEX_UNKNOWN"] = "__unknown";
+	return SCHEMA_TYPES;
 }({});
 
 //#endregion
@@ -2961,7 +2966,7 @@ var TemplatesGenConfig = class {
 		this.update(config);
 	}
 	update = (update) => {
-		objectAssign(this, update);
+		Object.assign(this, update);
 	};
 };
 
@@ -3075,14 +3080,6 @@ async function generateTemplates(config) {
 	return await new TemplatesGenProcess(config).start();
 }
 
-//#endregion
-//#region src/index.ts
-async function generateApi(config) {
-	if (config.debug) consola.consola.level = Number.MAX_SAFE_INTEGER;
-	if (config.silent) consola.consola.level = 0;
-	return await new CodeGenProcess(config).start();
-}
-
 //#endregion
 Object.defineProperty(exports, 'CodeGenConfig', {
   enumerable: true,
@@ -3090,6 +3087,12 @@ Object.defineProperty(exports, 'CodeGenConfig', {
     return CodeGenConfig;
   }
 });
+Object.defineProperty(exports, 'CodeGenProcess', {
+  enumerable: true,
+  get: function () {
+    return CodeGenProcess;
+  }
+});
 Object.defineProperty(exports, 'HTTP_CLIENT', {
   enumerable: true,
   get: function () {
@@ -3132,12 +3135,6 @@ Object.defineProperty(exports, 'description', {
     return description;
   }
 });
-Object.defineProperty(exports, 'generateApi', {
-  enumerable: true,
-  get: function () {
-    return generateApi;
-  }
-});
 Object.defineProperty(exports, 'generateTemplates', {
   enumerable: true,
   get: function () {
@@ -3156,4 +3153,4 @@ Object.defineProperty(exports, 'version', {
     return version;
   }
 });
-//# sourceMappingURL=src-DWf638kx.cjs.map
+//# sourceMappingURL=generate-templates-wjE78AWV.cjs.map