swagger-typescript-api 13.2.16 → 13.2.18

package/dist/{src-D-LZ3PGk.js → generate-templates-DGQlyLhe.mjs}

@@ -1,12 +1,16 @@
-import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
 import * as module from "node:module";
 import { consola } from "consola";
-import lodash from "lodash";
+import * as esToolkit from "es-toolkit";
+import { compact, flattenDeep, isEqual, merge, omit, uniq } from "es-toolkit";
+import * as esToolkitCompat from "es-toolkit/compat";
+import { camelCase, get, startCase, upperFirst } from "es-toolkit/compat";
 import * as typescript from "typescript";
 import * as path$1 from "node:path";
 import path from "node:path";
 import { Biome, Distribution } from "@biomejs/js-api";
 import * as nanoid from "nanoid";
+import * as crypto from "node:crypto";
 import * as swagger2openapi from "swagger2openapi";
 import * as YAML from "yaml";
 import * as url$1 from "node:url";
@@ -27,7 +31,7 @@ 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) => {
@@ -83,8 +87,8 @@ var TsLanguageServiceHost = class {
 		if (fileName === this.fileName) return this.content;
 		return typescript.sys.readFile(fileName, encoding);
 	}
-	fileExists(path$2) {
-		return typescript.sys.fileExists(path$2);
+	fileExists(path) {
+		return typescript.sys.fileExists(path);
 	}
 };
 
@@ -100,14 +104,14 @@ var NameResolver = class {
 		this.reserve(reservedNames);
 	}
 	reserve(names) {
-		const fixedNames = lodash.uniq(lodash.compact(names));
-		for (const name$1 of fixedNames) if (this.reservedNames.indexOf(name$1) === -1) this.reservedNames.push(name$1);
+		const fixedNames = uniq(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") {
@@ -125,7 +129,7 @@ var NameResolver = class {
 		}
 		if (Array.isArray(variants)) {
 			let usageName = null;
-			const uniqVariants = lodash.uniq(lodash.compact(variants));
+			const uniqVariants = uniq(compact(variants));
 			for (const variant of uniqVariants) if (!usageName && (!shouldReserve || !this.isReserved(variant))) usageName = variant;
 			if (usageName) {
 				shouldReserve && this.reserve([usageName]);
@@ -141,12 +145,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
@@ -176,12 +177,12 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.16";
+var version = "13.2.18";
 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,
@@ -250,8 +251,9 @@ const SCHEMA_TYPES$1 = {
 const objectAssign = (target, updater) => {
 	if (!updater) return;
 	const update = typeof updater === "function" ? updater(target) : updater;
-	const undefinedKeys = lodash.map(update, (value, key) => value === void 0 && key).filter((key) => typeof key === "string");
-	Object.assign(target, lodash.merge(target, update));
+	if (!update) return;
+	const undefinedKeys = Object.entries(update).filter(([, value]) => value === void 0).map(([key]) => key);
+	merge(target, update);
 	for (const key of undefinedKeys) target[key] = void 0;
 };
 
@@ -455,11 +457,11 @@ var CodeGenConfig = class {
 		BooleanValue: (content) => `${content}`,
 		NumberValue: (content) => `${content}`,
 		NullValue: () => "null",
-		UnionType: (contents) => lodash.join(lodash.uniq(contents), ` ${this.Ts.Keyword.Union} `),
+		UnionType: (contents) => uniq(contents).join(` ${this.Ts.Keyword.Union} `),
 		ExpressionGroup: (content) => content ? `(${content})` : "",
-		IntersectionType: (contents) => lodash.join(lodash.uniq(contents), ` ${this.Ts.Keyword.Intersection} `),
+		IntersectionType: (contents) => 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.compact([
+		TypeField: ({ readonly, key, optional, value }) => compact([
 			readonly && "readonly ",
 			key,
 			optional && "?",
@@ -469,12 +471,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.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 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]} */`] : [
@@ -564,13 +566,13 @@ var CodeGenConfig = class {
 		}
 	];
 	templateExtensions = [".eta", ".ejs"];
-	constructor({ codeGenConstructs, primitiveTypeConstructs, constants, templateInfos, hooks,...otherConfig }) {
+	constructor({ codeGenConstructs, primitiveTypeConstructs, constants, templateInfos, hooks, ...otherConfig }) {
 		objectAssign(this.Ts, codeGenConstructs);
 		objectAssign(this.primitiveTypes, primitiveTypeConstructs);
 		this.defaultResponseType = this.Ts.Keyword.Void;
 		this.update({
 			...otherConfig,
-			hooks: lodash.merge(this.hooks, hooks || {}),
+			hooks: merge(this.hooks, hooks || {}),
 			constants: {
 				...constants_exports,
 				...constants
@@ -666,10 +668,14 @@ var SchemaFormatters = class {
 				$content: parsedSchema.content,
 				content: this.config.Ts.UnionType(parsedSchema.content.map(({ value }) => value))
 			};
+			const escapedContent = parsedSchema.content.map((item) => ({
+				...item,
+				description: item.description ? this.escapeJSDocContent(item.description) : ""
+			}));
 			return {
 				...parsedSchema,
 				$content: parsedSchema.content,
-				content: this.config.Ts.EnumFieldsWrapper(parsedSchema.content)
+				content: this.config.Ts.EnumFieldsWrapper(escapedContent)
 			};
 		},
 		[SCHEMA_TYPES$1.OBJECT]: (parsedSchema) => {
@@ -691,7 +697,7 @@ var SchemaFormatters = class {
 		[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
+				content: parsedSchema.$ref ? parsedSchema.typeName : this.config.Ts.UnionType(compact([...parsedSchema.content.map(({ value }) => `${value}`), parsedSchema.nullable && this.config.Ts.Keyword.Null])) || this.config.Ts.Keyword.Any
 			};
 		},
 		[SCHEMA_TYPES$1.OBJECT]: (parsedSchema) => {
@@ -708,14 +714,19 @@ var SchemaFormatters = class {
 		}
 	};
 	formatSchema = (parsedSchema, formatType = "base") => {
-		const schemaType = lodash.get(parsedSchema, ["schemaType"]) || lodash.get(parsedSchema, ["$parsed", "schemaType"]);
-		return lodash.get(this, [formatType, schemaType])?.(parsedSchema) || parsedSchema;
+		const schemaType = get(parsedSchema, ["schemaType"]) || get(parsedSchema, ["$parsed", "schemaType"]);
+		return get(this, [formatType, schemaType])?.(parsedSchema) || parsedSchema;
+	};
+	escapeJSDocContent = (content) => {
+		if (content === void 0) return "";
+		return (typeof content === "string" ? content : String(content)).replace(/\*\//g, "*\\/");
 	};
-	formatDescription = (description$1, inline) => {
-		if (!description$1) return "";
-		if (!description$1.includes("\n")) return description$1;
-		if (inline) return lodash._(description$1).split(/\n/g).map((part) => part.trim()).compact().join(" ").valueOf();
-		return description$1.replace(/\n$/g, "");
+	formatDescription = (description, inline) => {
+		if (!description) return "";
+		const escapedDescription = this.escapeJSDocContent(description);
+		if (!escapedDescription.includes("\n")) return escapedDescription;
+		if (inline) return compact(escapedDescription.split(/\n/g).map((part) => part.trim())).join(" ");
+		return escapedDescription.replace(/\n$/g, "");
 	};
 	formatObjectContent = (content) => {
 		const fields = [];
@@ -776,7 +787,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({
@@ -799,7 +810,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)
 		};
 	}
@@ -810,7 +821,7 @@ var ArraySchemaParser = class extends MonoSchemaParser {
 var ComplexSchemaParser = class extends MonoSchemaParser {
 	parse() {
 		const complexType = this.schemaUtils.getComplexType(this.schema);
-		const simpleSchema = lodash.omit(lodash.clone(this.schema), lodash.keys(this.schemaParser._complexSchemaParsers));
+		const simpleSchema = omit(this.schema, Object.keys(this.schemaParser._complexSchemaParsers));
 		const complexSchemaContent = this.schemaParser._complexSchemaParsers[complexType](this.schema);
 		return {
 			...typeof this.schema === "object" ? this.schema : {},
@@ -820,8 +831,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.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$1.OBJECT && this.config.Ts.ExpressionGroup(this.schemaParserFabric.createSchemaParser({
+			description: this.schemaFormatters.formatDescription(this.schema.description || compact((this.schema[complexType] || []).map((item) => item?.description))[0] || ""),
+			content: this.config.Ts.IntersectionType(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
@@ -834,7 +845,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,
@@ -846,7 +857,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 			skipMappingType,
 			abstractSchemaStruct
 		});
-		const schemaContent = ts.IntersectionType([abstractSchemaStruct?.content, discriminatorSchemaStruct?.content].filter(Boolean));
+		const schemaContent = ts.IntersectionType(compact([abstractSchemaStruct?.content, discriminatorSchemaStruct?.content]));
 		return {
 			...typeof this.schema === "object" ? this.schema : {},
 			$schemaPath: this.schemaPath.slice(),
@@ -867,7 +878,7 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 			this.typeName
 		]);
 		const { discriminator } = this.schema;
-		const mappingEntries = lodash.entries(discriminator.mapping);
+		const mappingEntries = Object.entries(discriminator.mapping || {});
 		const ableToCreateMappingType = !skipMappingType && !!(abstractSchemaStruct?.typeName && mappingEntries.length);
 		const mappingContents = [];
 		let mappingTypeName;
@@ -927,22 +938,24 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 	};
 	createMappingPropertySchemaEnumKeys = ({ abstractSchemaStruct, discPropertyName }) => {
 		const ts = this.config.Ts;
-		let mappingPropertySchemaEnumKeysMap = {};
-		let mappingPropertySchema = lodash.get(abstractSchemaStruct?.component?.rawTypeData, ["properties", discPropertyName]);
+		const mappingPropertySchemaEnumKeysMap = {};
+		let mappingPropertySchema = 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.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.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) {
@@ -961,11 +974,11 @@ var DiscriminatorSchemaParser = class extends MonoSchemaParser {
 		}
 	};
 	createAbstractSchemaStruct = () => {
-		const { discriminator,...noDiscriminatorSchema } = this.schema;
-		const complexSchemaKeys = lodash.keys(this.schemaParser._complexSchemaParsers);
-		const schema = lodash.omit(structuredClone(noDiscriminatorSchema), complexSchemaKeys);
+		const { discriminator, ...noDiscriminatorSchema } = this.schema;
+		const complexSchemaKeys = Object.keys(this.schemaParser._complexSchemaParsers);
+		const schema = omit(structuredClone(noDiscriminatorSchema), complexSchemaKeys);
 		const schemaIsAny = this.schemaParserFabric.getInlineParseContent(structuredClone(schema)) === this.config.Ts.Keyword.Any;
-		if (!lodash.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
@@ -1034,9 +1047,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]
 			}))
@@ -1061,8 +1074,8 @@ var EnumSchemaParser = class extends MonoSchemaParser {
 				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);
+		if (Array.isArray(enumNames) && enumNames.length > 0) content = enumNames.map((enumName, index) => {
+			const enumValue = get(this.schema.enum, index);
 			const formattedKey = this.formatEnumKey({
 				key: enumName,
 				value: enumValue
@@ -1130,21 +1143,24 @@ var ObjectSchemaParser = class extends MonoSchemaParser {
 	}
 	getObjectSchemaContent = (schema) => {
 		const { properties, additionalProperties } = schema || {};
-		const propertiesContent = lodash.map(properties, (property, name$1) => {
-			const required = this.schemaUtils.isPropertyRequired(name$1, property, schema);
-			const rawTypeData = lodash.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 = 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.compact(lodash.map(property[this.schemaUtils.getComplexType(property)], "description"))[0] || rawTypeData.description || lodash.compact(lodash.map(rawTypeData[this.schemaUtils.getComplexType(rawTypeData)], "description"))[0] || "",
+				description: property.description || compact((property[complexType] || []).map((item) => item?.description))[0] || rawTypeData.description || compact((rawTypeData[rawDataComplexType] || []).map((item) => item?.description))[0] || "",
 				isRequired: required,
 				isNullable: nullable,
 				name: fieldName,
@@ -1155,8 +1171,8 @@ var ObjectSchemaParser = class extends MonoSchemaParser {
 					key: fieldName,
 					value: fieldValue
 				})
-			};
-		});
+			});
+		}
 		if (additionalProperties) {
 			const propertyNamesSchema = this.schemaUtils.getSchemaPropertyNamesSchema(schema);
 			let interfaceKeysContent;
@@ -1181,7 +1197,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;
@@ -1200,7 +1216,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,
@@ -1214,7 +1230,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)
 		};
 	}
@@ -1277,7 +1293,7 @@ var SchemaParser = class {
 	schemaWalker;
 	typeName;
 	schema;
-	schemaPath = [];
+	schemaPath;
 	constructor(schemaParserFabric, { typeName, schema, schemaPath } = {}) {
 		this.schemaParserFabric = schemaParserFabric;
 		this.config = schemaParserFabric.config;
@@ -1349,7 +1365,7 @@ var SchemaParser = class {
 			}
 			schemaType = this.schemaUtils.getInternalSchemaType(this.schema);
 			this.schemaPath.push(this.typeName);
-			lodash.merge(this.schema, this.config.hooks.onPreParseSchema(this.schema, this.typeName, schemaType));
+			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"));
@@ -1366,28 +1382,23 @@ var SchemaParser = class {
 		return this.schemaFormatters.formatSchema(parsedSchema, "base").content;
 	};
 	extractSchemaFromResponseStruct = (responseStruct) => {
-		const { content,...extras } = responseStruct;
-		const firstResponse = lodash.first(lodash.values(content));
-		const firstSchema = lodash.get(firstResponse, "schema");
+		const { content, ...extras } = responseStruct;
+		const firstResponse = Object.values(content || {})[0];
+		const firstSchema = get(firstResponse, "schema");
 		if (!firstSchema) return;
+		const { schema: _, ...restResponse } = firstResponse || {};
 		return {
 			...extras,
-			...lodash.omit(firstResponse, "schema"),
+			...restResponse,
 			...firstSchema
 		};
 	};
 };
 
-//#endregion
-//#region src/util/internal-case.ts
-function internalCase(value) {
-	return lodash.camelCase(lodash.lowerCase(value));
-}
-
 //#endregion
 //#region src/util/pascal-case.ts
 function pascalCase(value) {
-	return lodash.upperFirst(lodash.camelCase(value));
+	return upperFirst(camelCase(value));
 }
 
 //#endregion
@@ -1404,7 +1415,7 @@ var SchemaUtils = class {
 		this.schemaWalker = schemaWalker;
 	}
 	getRequiredProperties = (schema) => {
-		return lodash.uniq(schema && Array.isArray(schema.required) && schema.required || []);
+		return uniq(schema && Array.isArray(schema.required) && schema.required || []);
 	};
 	isRefSchema = (schema) => {
 		return !!schema?.$ref;
@@ -1423,15 +1434,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.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 || !!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]);
@@ -1439,13 +1450,13 @@ var SchemaUtils = class {
 	};
 	getSchemaPrimitiveType = (rawSchema) => {
 		const schema = rawSchema || {};
-		if (schema.type) return internalCase(schema.type);
+		if (schema.type) return camelCase(schema.type);
 		if (schema.enum) {
 			const enumFieldType = typeof schema.enum[0];
 			if (enumFieldType === this.config.Ts.Keyword.Undefined) return;
-			return internalCase(enumFieldType);
+			return camelCase(enumFieldType);
 		}
-		if (lodash.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;
 	};
@@ -1458,10 +1469,10 @@ var SchemaUtils = class {
 	};
 	makeAddRequiredToChildSchema = (parentSchema, childSchema) => {
 		if (!childSchema) return childSchema;
-		const required = lodash.uniq([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
+		const required = uniq([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
 		const refData = this.getSchemaRefType(childSchema);
 		if (refData) {
-			const existedRequiredKeys = lodash.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,
@@ -1469,17 +1480,17 @@ var SchemaUtils = class {
 			};
 		}
 		if (childSchema.properties) {
-			const existedRequiredKeys = lodash.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.uniq([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
+				required: uniq([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
 				...childSchema
 			};
 		}
 		return childSchema;
 	};
 	filterSchemaContents = (contents, filterFn) => {
-		return lodash.uniq(contents.filter((type) => filterFn(type)));
+		return uniq(contents.filter((type) => filterFn(type)));
 	};
 	resolveTypeName = (typeName, { suffixes, resolver, prefixes, shouldReserve = true }) => {
 		if (resolver) return this.config.componentTypeNameResolver.resolve([], (reserved) => {
@@ -1495,10 +1506,10 @@ var SchemaUtils = class {
 		return SCHEMA_TYPES$1.COMPLEX_UNKNOWN;
 	};
 	getInternalSchemaType = (schema) => {
-		if (!lodash.isEmpty(schema.enum) || !lodash.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.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;
 	};
@@ -1511,7 +1522,7 @@ var SchemaUtils = class {
 		else {
 			const primitiveType = this.getSchemaPrimitiveType(schema);
 			if (primitiveType == null) return this.config.Ts.Keyword.Any;
-			const typeAlias = lodash.get(this.config.primitiveTypes, [primitiveType, schema.format]) || lodash.get(this.config.primitiveTypes, [primitiveType, "$default"]) || this.config.primitiveTypes[primitiveType];
+			const typeAlias = get(this.config.primitiveTypes, [primitiveType, schema.format]) || get(this.config.primitiveTypes, [primitiveType, "$default"]) || this.config.primitiveTypes[primitiveType];
 			if (typeof typeAlias === "function") resultType = typeAlias(schema, this);
 			else resultType = typeAlias || primitiveType;
 		}
@@ -1519,9 +1530,9 @@ var SchemaUtils = class {
 		return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, resultType));
 	};
 	buildTypeNameFromPath = (schemaPath) => {
-		schemaPath = lodash.uniq(lodash.compact(schemaPath));
+		schemaPath = uniq(compact(schemaPath || []));
 		if (!schemaPath || !schemaPath[0]) return null;
-		return pascalCase(lodash.camelCase(lodash.uniq([schemaPath[0], schemaPath[schemaPath.length - 1]]).join("_")));
+		return pascalCase(uniq([schemaPath[0], schemaPath[schemaPath.length - 1]]).join("_"));
 	};
 	isConstantSchema(schema) {
 		return "const" in schema;
@@ -1564,7 +1575,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
@@ -1612,8 +1623,7 @@ var SchemaParserFabric = class {
 
 //#endregion
 //#region src/util/id.ts
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
-const generateId = nanoid.customAlphabet(ALPHABET, 12);
+const generateId = () => crypto.randomUUID();
 
 //#endregion
 //#region src/schema-routes/util/specific-arg-name-resolver.ts
@@ -1658,7 +1668,7 @@ var SchemaRoutes = class {
 		this.typeNameFormatter = typeNameFormatter;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.templatesWorker = templatesWorker;
-		this.FORM_DATA_TYPES = lodash.uniq([this.schemaUtils.getSchemaType({
+		this.FORM_DATA_TYPES = uniq([this.schemaUtils.getSchemaType({
 			type: "string",
 			format: "file"
 		}), this.schemaUtils.getSchemaType({
@@ -1666,49 +1676,50 @@ var SchemaRoutes = class {
 			format: "binary"
 		})]);
 	}
-	createRequestsMap = (routeInfoByMethodsMap) => {
-		const parameters = lodash.get(routeInfoByMethodsMap, "parameters");
-		return lodash.reduce(routeInfoByMethodsMap, (acc, requestInfo, method) => {
-			if (method.startsWith("x-") || ["parameters", "$ref"].includes(method)) return acc;
-			acc[method] = {
+	createRequestsMap = (routesByMethod) => {
+		const parameters = 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.compact(lodash.concat(parameters, requestInfo.parameters))
+				parameters: 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.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.warn("wrong path param name", paramName);
-			pathParams$1.push({
+			pathParams.push({
 				$match: match,
-				name: lodash.camelCase(paramName),
+				name: 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.uniq(queryParamMatches.join(",").replace(/(\{\?)|(\})|\s/g, "").split(","));
+			const paramNames = uniq(queryParamMatches.join(",").replace(/(\{\?)|(\})|\s/g, "").split(","));
 			for (const paramName of paramNames) {
-				if (paramName.includes("-")) consola.warn("wrong query param name", paramName);
+				if (typeof paramName === "string" && paramName.includes("-")) consola.warn("wrong query param name", paramName);
 				queryParams.push({
 					$match: paramName,
-					name: lodash.camelCase(paramName),
+					name: typeof paramName === "string" ? camelCase(paramName) : camelCase(String(paramName)),
 					required: true,
 					type: "string",
 					description: "",
@@ -1718,7 +1729,7 @@ var SchemaRoutes = class {
 			}
 		}
 		const result = {
-			originalRoute: originalRouteName || "",
+			originalRoute: rawRoute || "",
 			route: fixedRoute,
 			pathParams,
 			queryParams
@@ -1735,7 +1746,7 @@ var SchemaRoutes = class {
 			formData: [],
 			cookie: []
 		};
-		lodash.each(parameters, (parameter) => {
+		for (const parameter of parameters || []) {
 			const refTypeInfo = this.schemaParserFabric.schemaUtils.getSchemaRefType(parameter);
 			let routeParam = null;
 			if (refTypeInfo?.rawTypeData.in && refTypeInfo.rawTypeData) {
@@ -1746,7 +1757,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,
@@ -1754,16 +1765,19 @@ var SchemaRoutes = class {
 				};
 			}
 			if (routeParam.in === "path") {
-				if (!routeParam.name) return;
-				routeParam.name = lodash.camelCase(routeParam.name);
+				if (!routeParam.name) continue;
+				routeParam.name = 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.uniq(lodash.compact([...extraContentTypes || [], ...lodash.flatten(lodash.map(requestInfo, (requestInfoData) => requestInfoData && lodash.keys(requestInfoData.content)))]));
+	getContentTypes = (requestInfo, extraContentTypes) => {
+		const requestInfoArray = Array.isArray(requestInfo) ? requestInfo : Object.values(requestInfo || {});
+		return uniq(compact([...extraContentTypes || [], ...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;
@@ -1775,7 +1789,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.get(requestInfo, "content");
+		const content = get(requestInfo, "content");
 		if (!content) return null;
 		for (const dataType in content) if (content[dataType]?.schema) return {
 			...content[dataType].schema,
@@ -1789,13 +1803,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.isEqual(parsedSchema.content, content));
+			const foundSchemaByContent = parsedSchemas.find((parsedSchema) => 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":
@@ -1805,23 +1819,27 @@ var SchemaRoutes = class {
 		}
 		return defaultType || this.config.Ts.Keyword.Any;
 	};
-	getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType }) => lodash.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"]]);
@@ -1930,13 +1948,12 @@ var SchemaRoutes = class {
 			};
 			return acc;
 		}, {});
-		const fixedQueryParams = lodash.reduce(lodash.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 = 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: {
@@ -1979,7 +1996,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.assign(responseBodyInfo.responses[idx], {
+				if (idx > -1) Object.assign(responseBodyInfo.responses[idx], {
 					...successResponse.schema,
 					type: successResponse.type
 				});
@@ -1992,18 +2009,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 = 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: compact(errorSchemas.map((schema) => schema.title)).join(" "),
+				description: 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);
@@ -2031,11 +2048,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.camelCase(firstTag) : lodash.camelCase(lodash.compact(route.split("/"))[moduleNameIndex]);
+		const moduleName = moduleNameFirstTag && firstTag ? camelCase(firstTag) : camelCase(compact(route.split("/"))[moduleNameIndex] || "");
 		let hasSecurity = !!globalSecurity?.length;
 		if (security) hasSecurity = security.length > 0;
 		const routeParams = this.getRouteParams(routeInfo, pathParamsFromRouteName, queryParamsFromRouteName);
@@ -2055,7 +2072,7 @@ var SchemaRoutes = class {
 			route: rawRouteName,
 			moduleName,
 			responsesTypes: responseBodyInfo.responses,
-			description: description$1,
+			description,
 			tags,
 			summary,
 			responses,
@@ -2152,7 +2169,7 @@ var SchemaRoutes = class {
 	};
 	attachSchema = ({ usageSchema, parsedSchemas }) => {
 		this.config.routeNameDuplicatesMap.clear();
-		const pathsEntries = lodash.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)) {
@@ -2176,37 +2193,36 @@ var SchemaRoutes = class {
 			} else modules.$outOfModule.push(route);
 			return modules;
 		}, { $outOfModule: [] });
-		const routeGroups = lodash.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.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.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));
 	};
 };
 
@@ -2221,8 +2237,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("#");
@@ -2231,8 +2247,7 @@ var SchemaWalker = class {
 		return ref.startsWith("http://") || ref.startsWith("https://");
 	};
 	_getRefDataFromSchema = (schema, ref) => {
-		const path$2 = ref.replace("#", "").split("/");
-		const refData = lodash.get(schema, path$2);
+		const refData = get(schema, ref.replace("#", "").split("/"));
 		if (refData) this.caches.set(ref, refData);
 		return refData;
 	};
@@ -2245,14 +2260,14 @@ var Request = class {
 	constructor(config) {
 		this.config = config;
 	}
-	async download({ url: url$2, authToken,...options }) {
+	async download({ url, authToken, ...options }) {
 		const requestOptions = {};
 		if (authToken) requestOptions.headers = { Authorization: authToken };
-		lodash.merge(requestOptions, options, this.config.requestOptions);
+		merge(merge(requestOptions, options), this.config.requestOptions || {});
 		try {
-			return await (await fetch(url$2, requestOptions)).text();
+			return await (await fetch(url, requestOptions)).text();
 		} catch (error) {
-			const message = `error while fetching data from URL "${url$2}"`;
+			const message = `error while fetching data from URL "${url}"`;
 			consola.error(message, error);
 			return message;
 		}
@@ -2271,21 +2286,21 @@ var SwaggerSchemaResolver = class {
 		this.request = new Request(config);
 	}
 	async create() {
-		const { spec, patch, input, url: url$2, 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$2, 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.merge({
+			result.info = merge({
 				title: "No title",
 				version: ""
-			}, result.info);
+			}, result.info || {});
 			if (!Object.hasOwn(result, "openapi")) {
-				result.paths = lodash.merge({}, result.paths);
+				result.paths = merge({}, result.paths || {});
 				swagger2openapi.convertObj(result, {
 					...converterOptions,
 					resolveInternal: true,
@@ -2293,7 +2308,7 @@ var SwaggerSchemaResolver = class {
 					refSiblings: "preserve",
 					rbname: "requestBodyName"
 				}, (err, options) => {
-					const parsedSwaggerSchema = lodash.get(err, "options.openapi", lodash.get(options, "openapi"));
+					const parsedSwaggerSchema = get(err, "options.openapi") ?? get(options, "openapi");
 					if (!parsedSwaggerSchema && err) throw err;
 					this.config.update({ convertedFromSwagger2: true });
 					resolve({
@@ -2328,23 +2343,21 @@ var SwaggerSchemaResolver = class {
 		}
 	}
 	fixSwaggerSchema({ usageSchema, originalSchema }) {
-		const usagePaths = lodash.get(usageSchema, "paths");
-		const originalPaths = lodash.get(originalSchema, "paths");
-		lodash.each(usagePaths, (usagePathObject, route) => {
-			const originalPathObject = lodash.get(originalPaths, route);
-			lodash.each(usagePathObject, (usageRouteInfo, methodName) => {
-				const originalRouteInfo = lodash.get(originalPathObject, methodName);
-				const usageRouteParams = lodash.get(usageRouteInfo, "parameters", []);
-				const originalRouteParams = lodash.get(originalRouteInfo, "parameters", []);
+		const usagePaths = get(usageSchema, "paths") || {};
+		const originalPaths = get(originalSchema, "paths") || {};
+		for (const [route, usagePathObject] of Object.entries(usagePaths)) {
+			const originalPathObject = get(originalPaths, route) || {};
+			for (const [methodName, usageRouteInfo] of Object.entries(usagePathObject)) {
+				const originalRouteInfo = get(originalPathObject, methodName) || {};
+				const usageRouteParams = get(usageRouteInfo, "parameters") || [];
+				const originalRouteParams = get(originalRouteInfo, "parameters") || [];
 				if (typeof usageRouteInfo === "object") {
-					usageRouteInfo.consumes = lodash.uniq(lodash.compact([...usageRouteInfo.consumes || [], ...originalRouteInfo.consumes || []]));
-					usageRouteInfo.produces = lodash.uniq(lodash.compact([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
+					usageRouteInfo.consumes = uniq(compact([...usageRouteInfo.consumes || [], ...originalRouteInfo.consumes || []]));
+					usageRouteInfo.produces = uniq(compact([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
 				}
-				lodash.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);
+			}
+		}
 	}
 };
 
@@ -2364,10 +2377,10 @@ var TemplatesWorker = class {
 		if (this.config.silent) consola.level = 0;
 	}
 	getTemplatePaths = (config) => {
-		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 __dirname = path$1.dirname(url$1.fileURLToPath(import.meta.url));
+		const baseTemplatesPath = path$1.resolve(__dirname, "../templates/base");
+		const defaultTemplatesPath = path$1.resolve(__dirname, "../templates/default");
+		const modularTemplatesPath = path$1.resolve(__dirname, "../templates/modular");
 		return {
 			base: baseTemplatesPath,
 			default: defaultTemplatesPath,
@@ -2376,7 +2389,7 @@ var TemplatesWorker = class {
 			custom: config.templates && path$1.resolve(process.cwd(), config.templates)
 		};
 	};
-	cropExtension = (path$2) => this.config.templateExtensions.reduce((path$3, ext) => path$3.endsWith(ext) ? path$3.replace(ext, "") : path$3, path$2);
+	cropExtension = (path) => this.config.templateExtensions.reduce((path, ext) => path.endsWith(ext) ? path.replace(ext, "") : path, path);
 	getTemplateFullPath = (path_, fileName) => {
 		const raw = path$1.resolve(path_, "./", this.cropExtension(fileName));
 		return this.config.templateExtensions.map((extension) => `${raw}${extension}`).find((variant) => !!this.fileSystem.pathIsExist(variant));
@@ -2385,39 +2398,39 @@ var TemplatesWorker = class {
 		if (packageOrPath.startsWith("./") || packageOrPath.startsWith("../")) return require(path$1.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
 		return require(packageOrPath);
 	};
-	getTemplate = (name$1, fileName, path$2) => {
+	getTemplate = (name, fileName, path) => {
 		const { templatePaths } = this.config;
-		if (path$2) return this.fileSystem.getFileContent(path$2);
+		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.info(`"${name$1.toLowerCase()}" template found in "${templatePaths.custom}"`);
+			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.warn("Code generator will use the default template:", `"${name$1.toLowerCase()}"`, "template not found in", `"${templatePaths.custom}"`);
-		else consola.info(`Code generator will use the default template for "${name$1.toLowerCase()}"`);
+		else if (templatePaths.custom) consola.warn("Code generator will use the default template:", `"${name.toLowerCase()}"`, "template not found in", `"${templatePaths.custom}"`);
+		else 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.info(`try to read templates from directory "${templatePaths.custom}"`);
-		return lodash.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$2) => {
-		const raw = this.cropExtension(path$2);
+	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.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 = path$1.resolve(path_.replace(`@${foundTemplatePathKey}`, lodash.get(this.config.templatePaths, foundTemplatePathKey)));
+			const rawPath = path$1.resolve(path_.replace(`@${foundTemplatePathKey}`, get(this.config.templatePaths, foundTemplatePathKey)));
 			const fixedPath = this.findTemplateWithExt(rawPath);
 			if (fixedPath) return this.fileSystem.getFileContent(fixedPath);
 		}
@@ -2432,7 +2445,7 @@ var TemplatesWorker = class {
 		return eta.render(eta.compile(template, { async: false }), {
 			...this.getRenderTemplateData(),
 			...configuration
-		}, { includeFile: (path$2, configuration$1) => this.renderTemplate(this.getTemplateContent(path$2), configuration$1) });
+		}, { includeFile: (path, configuration) => this.renderTemplate(this.getTemplateContent(path), configuration) });
 	};
 };
 
@@ -2499,51 +2512,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.warn("wrong model name", name$1);
-			return name$1;
+		const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
+		if (typeof name !== "string") {
+			consola.warn("wrong model name", name);
+			return name;
 		}
-		if (/^(?!\d)([A-Z0-9_]{1,})$/g.test(name$1)) return lodash.compact([
+		if (/^(?!\d)([A-Z0-9_]{1,})$/g.test(name)) return 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.startCase(`${typePrefix}_${fixedModelName}_${typeSuffix}`).replace(/\s/g, "");
-		const formattedResultName = this.config.hooks.onFormatTypeName(formattedName, name$1, schemaType) || formattedName;
+		const formattedName = 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.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 startCase(name).replace(/ /g, "");
 		}
-		return name$1;
+		return name;
 	};
 };
 
 //#endregion
 //#region src/util/file-system.ts
 var FileSystem = class {
-	getFileContent = (path$2) => {
-		return fs.readFileSync(path$2, { encoding: "utf8" });
+	getFileContent = (path) => {
+		return fs.readFileSync(path, { encoding: "utf8" });
 	};
-	readDir = (path$2) => {
-		return fs.readdirSync(path$2);
+	readDir = (path) => {
+		return fs.readdirSync(path);
 	};
-	pathIsDir = (path$2) => {
-		if (!path$2) return false;
+	pathIsDir = (path) => {
+		if (!path) return false;
 		try {
-			return fs.statSync(path$2).isDirectory();
+			return fs.statSync(path).isDirectory();
 		} catch (e) {
 			return false;
 		}
@@ -2553,36 +2565,45 @@ var FileSystem = class {
 		if (fileNameParts.length > 1) fileNameParts.pop();
 		return fileNameParts.join(".");
 	};
-	removeDir = (path$2) => {
+	removeDir = (path) => {
 		try {
-			if (typeof fs.rmSync === "function") fs.rmSync(path$2, { recursive: true });
-			else fs.rmdirSync(path$2, { recursive: true });
+			if (typeof fs.rmSync === "function") fs.rmSync(path, { recursive: true });
+			else fs.rmdirSync(path, { recursive: true });
 		} catch (e) {
 			consola.debug("failed to remove dir", e);
 		}
 	};
-	createDir = (path$2) => {
+	createDir = (path) => {
 		try {
-			fs.mkdirSync(path$2, { recursive: true });
+			fs.mkdirSync(path, { recursive: true });
 		} catch (e) {
 			consola.debug("failed to create dir", e);
 		}
 	};
-	cleanDir = (path$2) => {
-		this.removeDir(path$2);
-		this.createDir(path$2);
+	cleanDir = (path) => {
+		this.removeDir(path);
+		this.createDir(path);
 	};
-	pathIsExist = (path$2) => {
-		return !!path$2 && fs.existsSync(path$2);
+	pathIsExist = (path) => {
+		return !!path && fs.existsSync(path);
 	};
 	createFile = ({ path: path_, fileName, content, withPrefix }) => {
-		const __dirname$1 = path$1.dirname(url$1.fileURLToPath(import.meta.url));
-		const absolutePath = path$1.resolve(__dirname$1, path_, `./${fileName}`);
+		const __dirname = path$1.dirname(url$1.fileURLToPath(import.meta.url));
+		const absolutePath = path$1.resolve(__dirname, path_, `./${fileName}`);
 		const fileContent = `${withPrefix ? FILE_PREFIX : ""}${content}`;
 		return fs.writeFileSync(absolutePath, fileContent);
 	};
 };
 
+//#endregion
+//#region src/util/lodash-compat.ts
+function createLodashCompat() {
+	return {
+		...esToolkit,
+		...esToolkitCompat
+	};
+}
+
 //#endregion
 //#region src/code-gen-process.ts
 const PATCHABLE_INSTANCES = [
@@ -2637,16 +2658,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.each(swagger.usageSchema.components, (component, componentName) => lodash.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.compact(["schemas", this.config.extractResponses && "responses"])).map((schemaComponent) => {
+		const parsedSchemas = this.schemaComponentsMap.filter(compact(["schemas", this.config.extractResponses && "responses"])).map((schemaComponent) => {
 			const parsed = this.schemaParserFabric.parseSchema(schemaComponent.rawTypeData, schemaComponent.typeName);
 			schemaComponent.typeData = parsed;
 			return parsed;
@@ -2704,7 +2723,8 @@ var CodeGenProcess = class {
 			utils: {
 				Ts: this.config.Ts,
 				formatDescription: this.schemaParserFabric.schemaFormatters.formatDescription,
-				internalCase,
+				escapeJSDocContent: this.schemaParserFabric.schemaFormatters.escapeJSDocContent,
+				internalCase: camelCase,
 				classNameCase: pascalCase,
 				pascalCase,
 				getInlineParseContent: this.schemaParserFabric.getInlineParseContent,
@@ -2721,7 +2741,7 @@ var CodeGenProcess = class {
 					return ` * ${line}${eol ? "\n" : ""}`;
 				},
 				NameResolver,
-				_: lodash,
+				_: createLodashCompat(),
 				require: this.templatesWorker.requireFnFromTemplate
 			},
 			config: this.config
@@ -2730,7 +2750,7 @@ var CodeGenProcess = class {
 	collectModelTypes = () => {
 		const components = this.schemaComponentsMap.getComponents();
 		let modelTypes = [];
-		const modelTypeComponents = lodash.compact(["schemas", this.config.extractResponses && "responses"]);
+		const modelTypeComponents = compact(["schemas", this.config.extractResponses && "responses"]);
 		const getSchemaComponentsCount = () => this.schemaComponentsMap.filter(...modelTypeComponents).length;
 		let schemaComponentsCount = getSchemaComponentsCount();
 		let processedCount = 0;
@@ -2752,14 +2772,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,
@@ -2771,7 +2791,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.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));
 		}
@@ -2821,7 +2841,7 @@ var CodeGenProcess = class {
 	};
 	createSingleFileInfo = async (templatesToRender, configuration) => {
 		const { generateRouteTypes, generateClient } = configuration.config;
-		return await this.createOutputFileInfo(configuration, configuration.fileName, lodash.compact([
+		return await this.createOutputFileInfo(configuration, configuration.fileName, compact([
 			this.templatesWorker.renderTemplate(templatesToRender.dataContracts, configuration),
 			generateRouteTypes && this.templatesWorker.renderTemplate(templatesToRender.routeTypes, configuration),
 			generateClient && this.templatesWorker.renderTemplate(templatesToRender.httpClient, configuration),
@@ -2857,21 +2877,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.merge({
+			externalDocs: merge({
 				url: "",
 				description: ""
-			}, externalDocs),
-			tags: lodash.compact(tags),
+			}, externalDocs || {}),
+			tags: compact(tags || []),
 			baseUrl: serverUrl,
 			title,
-			version: version$1
+			version
 		};
 	};
 	injectClassInstance = (key, value) => {
@@ -2882,28 +2902,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
@@ -3036,13 +3056,5 @@ async function generateTemplates(config) {
 }
 
 //#endregion
-//#region src/index.ts
-async function generateApi(config) {
-	if (config.debug) consola.level = Number.MAX_SAFE_INTEGER;
-	if (config.silent) consola.level = 0;
-	return await new CodeGenProcess(config).start();
-}
-
-//#endregion
-export { SCHEMA_TYPES as a, constants_exports as c, version as d, RequestContentKind as i, description as l, generateTemplates as n, CodeGenConfig as o, TemplatesGenConfig as r, HTTP_CLIENT as s, generateApi as t, name as u };
-//# sourceMappingURL=src-D-LZ3PGk.js.map
+export { CodeGenProcess as a, constants_exports as c, version as d, SCHEMA_TYPES as i, description as l, TemplatesGenConfig as n, CodeGenConfig as o, RequestContentKind as r, HTTP_CLIENT as s, generateTemplates as t, name as u };
+//# sourceMappingURL=generate-templates-DGQlyLhe.mjs.map