swagger-typescript-api 13.2.17 → 13.3.0

package/dist/{generate-templates-BO-5CKCm.mjs → generate-templates-BaT2BiRR.mjs}

@@ -1,22 +1,24 @@
 import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
 import * as module from "node:module";
-import { consola } from "consola";
+import consola, { consola as consola$1 } from "consola";
 import * as esToolkit from "es-toolkit";
-import { compact, flattenDeep, isEqual, merge, omit, uniq } from "es-toolkit";
+import { compact, flattenDeep, isEqual, mapValues, merge, omit, uniq } from "es-toolkit";
 import * as esToolkitCompat from "es-toolkit/compat";
-import { camelCase, get, startCase, upperFirst } from "es-toolkit/compat";
+import { camelCase, get, reduce, 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 { typeGuard } from "yummies/type-guard";
 import * as crypto from "node:crypto";
 import * as swagger2openapi from "swagger2openapi";
 import * as YAML from "yaml";
+import * as fs from "node:fs";
+import SwaggerParser from "@apidevtools/swagger-parser";
 import * as url$1 from "node:url";
 import url from "node:url";
 import { Eta } from "eta";
-import * as fs from "node:fs";
 
 //#region src/code-formatter.ts
 var CodeFormatter = class {
@@ -119,7 +121,7 @@ var NameResolver = class {
 			while (usageName === null) {
 				const variant = resolver(variants, extras);
 				if (variant === void 0) {
-					consola.warn("unable to resolve name. current reserved names: ", ...this.reservedNames);
+					consola$1.warn("unable to resolve name. current reserved names: ", ...this.reservedNames);
 					return null;
 				}
 				if (!shouldReserve || !this.isReserved(variant)) usageName = variant;
@@ -135,10 +137,10 @@ var NameResolver = class {
 				shouldReserve && this.reserve([usageName]);
 				return usageName;
 			}
-			consola.debug("trying to resolve name with using fallback name generator using variants", ...variants);
+			consola$1.debug("trying to resolve name with using fallback name generator using variants", ...variants);
 			return this.resolve(variants, this.getFallbackName, extras);
 		}
-		consola.debug("problem with reserving names. current reserved names: ", ...this.reservedNames);
+		consola$1.debug("problem with reserving names. current reserved names: ", ...this.reservedNames);
 		return null;
 	}
 };
@@ -164,11 +166,11 @@ var ComponentTypeNameResolver = class extends NameResolver {
 				const variantCounter = this.countersByVariant.get(randomVariant) + 1;
 				this.countersByVariant.set(randomVariant, variantCounter);
 				const dirtyResolvedName = `${randomVariant}${variantCounter}`;
-				consola.debug("generated dirty resolved type name for component - ", dirtyResolvedName);
+				consola$1.debug("generated dirty resolved type name for component - ", dirtyResolvedName);
 				return dirtyResolvedName;
 			}
 			const fallbackName = `${this.config.componentTypeNameResolver}${this.fallbackNameCounter++}`;
-			consola.debug("generated fallback type name for component - ", fallbackName);
+			consola$1.debug("generated fallback type name for component - ", fallbackName);
 			return fallbackName;
 		});
 	}
@@ -177,7 +179,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.17";
+var version = "13.3.0";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 
 //#endregion
@@ -246,6 +248,17 @@ 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;
+	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;
+};
+
 //#endregion
 //#region src/configuration.ts
 const TsKeyword = {
@@ -327,6 +340,7 @@ var CodeGenConfig = class {
 		onFormatTypeName: (_typeName, _rawTypeName, _schemaType) => {},
 		onFormatRouteName: (_routeInfo, _templateRouteName) => {}
 	};
+	resolvedSwaggerSchema;
 	defaultResponseType;
 	singleHttpClient = false;
 	httpClientType = HTTP_CLIENT.FETCH;
@@ -556,8 +570,8 @@ var CodeGenConfig = class {
 	];
 	templateExtensions = [".eta", ".ejs"];
 	constructor({ codeGenConstructs, primitiveTypeConstructs, constants, templateInfos, hooks, ...otherConfig }) {
-		Object.assign(this.Ts, codeGenConstructs);
-		Object.assign(this.primitiveTypes, primitiveTypeConstructs);
+		objectAssign(this.Ts, codeGenConstructs);
+		objectAssign(this.primitiveTypes, primitiveTypeConstructs);
 		this.defaultResponseType = this.Ts.Keyword.Void;
 		this.update({
 			...otherConfig,
@@ -577,16 +591,21 @@ var CodeGenConfig = class {
 		this.componentTypeNameResolver = new ComponentTypeNameResolver(this, []);
 	}
 	update = (update) => {
-		Object.assign(this, update);
+		objectAssign(this, update);
 		if (this.enumNamesAsValues) this.extractEnums = true;
 	};
 };
 
+//#endregion
+//#region src/util/pascal-case.ts
+function pascalCase(value) {
+	return upperFirst(camelCase(value));
+}
+
 //#endregion
 //#region src/schema-components-map.ts
 var SchemaComponentsMap = class {
 	_data = [];
-	config;
 	constructor(config) {
 		this.config = config;
 	}
@@ -599,18 +618,27 @@ var SchemaComponentsMap = class {
 	parseRef = (ref) => {
 		return ref.split("/");
 	};
-	createComponent($ref, rawTypeData) {
+	createComponentDraft($ref, rawTypeData) {
+		if (typeGuard.isObject(rawTypeData) && rawTypeData.typeName && rawTypeData.rawTypeData && rawTypeData.$ref) return rawTypeData;
 		const parsed = this.parseRef($ref);
-		const componentSchema = {
+		const [, rawPointer = ""] = $ref.split("#");
+		const pointerParts = (rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}`).split("/").filter(Boolean);
+		const typeName = pointerParts.at(-1) || parsed.at(-1) || "Unknown";
+		const rawComponentName = pointerParts.at(-2) || parsed[parsed.length - 2] || "schemas";
+		return {
 			$ref,
-			typeName: parsed[parsed.length - 1],
+			typeName,
 			rawTypeData,
-			componentName: parsed[parsed.length - 2],
+			componentName: rawComponentName === "definitions" ? "schemas" : rawComponentName,
 			typeData: null
 		};
+	}
+	createComponent($ref, rawTypeData, addAtStart) {
+		const componentSchema = this.createComponentDraft($ref, rawTypeData);
 		const usageComponent = this.config.hooks.onCreateComponent(componentSchema) || componentSchema;
 		const refIndex = this._data.findIndex((c) => c.$ref === $ref);
-		if (refIndex === -1) this._data.push(usageComponent);
+		if (refIndex === -1) if (addAtStart) this._data.unshift(usageComponent);
+		else this._data.push(usageComponent);
 		else this._data[refIndex] = usageComponent;
 		return usageComponent;
 	}
@@ -621,7 +649,19 @@ var SchemaComponentsMap = class {
 		return this._data.filter((it) => componentNames.some((componentName) => it.$ref.startsWith(`#/components/${componentName}`)));
 	}
 	get = ($ref) => {
-		return this._data.find((c) => c.$ref === $ref) || null;
+		const localFound = this._data.find((c) => c.$ref === $ref) || null;
+		if (localFound != null) return localFound;
+		const { resolvedSwaggerSchema } = this.config;
+		if (resolvedSwaggerSchema.isLocalRef($ref)) return null;
+		const foundByRef = resolvedSwaggerSchema.getRef($ref);
+		const refDetails = resolvedSwaggerSchema.getRefDetails($ref);
+		if (foundByRef != null) {
+			const componentDraft = this.createComponentDraft($ref, foundByRef);
+			componentDraft.typeName = this.config.hooks.onFormatExternalTypeName?.(componentDraft.typeName, refDetails) || componentDraft.typeName;
+			if (this._data.some((component) => component.typeName === componentDraft.typeName)) componentDraft.typeName = this.config.hooks.onFixDuplicateExternalTypeName?.(componentDraft.typeName, refDetails, this._data.map((it) => it.typeName)) ?? `${pascalCase(refDetails.externalOpenapiFileName || "External")}${componentDraft.typeName}`;
+			return this.createComponent($ref, componentDraft);
+		}
+		return null;
 	};
 	enumsFirst() {
 		this._data.sort((a, b) => {
@@ -657,10 +697,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) => {
@@ -702,11 +746,16 @@ var SchemaFormatters = class {
 		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, inline) => {
 		if (!description) return "";
-		if (!description.includes("\n")) return description;
-		if (inline) return compact(description.split(/\n/g).map((part) => part.trim())).join(" ");
-		return description.replace(/\n$/g, "");
+		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 = [];
@@ -995,7 +1044,7 @@ var EnumKeyResolver = class extends NameResolver {
 	constructor(config, reservedNames) {
 		super(config, reservedNames, (variants) => {
 			const generatedVariant = variants[0] && `${variants[0]}${this.counter++}` || `${this.config.enumKeyResolverName}${this.counter++}`;
-			consola.debug("generated fallback type name for enum key - ", generatedVariant);
+			consola$1.debug("generated fallback type name for enum key - ", generatedVariant);
 			return generatedVariant;
 		});
 	}
@@ -1270,17 +1319,15 @@ var SchemaParser = class {
 	schemaFormatters;
 	schemaUtils;
 	templatesWorker;
-	schemaWalker;
 	typeName;
 	schema;
-	schemaPath = [];
+	schemaPath;
 	constructor(schemaParserFabric, { typeName, schema, schemaPath } = {}) {
 		this.schemaParserFabric = schemaParserFabric;
 		this.config = schemaParserFabric.config;
 		this.templatesWorker = schemaParserFabric.templatesWorker;
 		this.schemaComponentsMap = schemaParserFabric.schemaComponentsMap;
 		this.typeNameFormatter = schemaParserFabric.typeNameFormatter;
-		this.schemaWalker = schemaParserFabric.schemaWalker;
 		this.schemaFormatters = schemaParserFabric.schemaFormatters;
 		this.schemaUtils = schemaParserFabric.schemaUtils;
 		this.typeName = typeName || null;
@@ -1330,7 +1377,7 @@ var SchemaParser = class {
 			if (!this.typeName && this.schemaUtils.isRefSchema(this.schema)) this.typeName = this.schemaUtils.getSchemaType(this.schema);
 			if (this.schema.items && !Array.isArray(this.schema.items) && !this.schema.type) this.schema.type = SCHEMA_TYPES$1.ARRAY;
 			if (Array.isArray(this.schema.enum) && this.schema.enum.length === 1 && this.schema.enum[0] == null) {
-				consola.debug("invalid enum schema", this.schema);
+				consola$1.debug("invalid enum schema", this.schema);
 				this.schema = { type: this.config.Ts.Keyword.Null };
 			}
 			if ("content" in this.schema && typeof this.schema.content === "object") {
@@ -1375,24 +1422,13 @@ var SchemaParser = class {
 	};
 };
 
-//#endregion
-//#region src/util/pascal-case.ts
-function pascalCase(value) {
-	return upperFirst(camelCase(value));
-}
-
 //#endregion
 //#region src/schema-parser/schema-utils.ts
 var SchemaUtils = class {
-	config;
-	schemaComponentsMap;
-	typeNameFormatter;
-	schemaWalker;
-	constructor({ config, schemaComponentsMap, typeNameFormatter, schemaWalker }) {
+	constructor(config, schemaComponentsMap, typeNameFormatter) {
 		this.config = config;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.typeNameFormatter = typeNameFormatter;
-		this.schemaWalker = schemaWalker;
 	}
 	getRequiredProperties = (schema) => {
 		return uniq(schema && Array.isArray(schema.required) && schema.required || []);
@@ -1538,14 +1574,12 @@ var SchemaParserFabric = class {
 	schemaFormatters;
 	templatesWorker;
 	schemaUtils;
-	schemaWalker;
-	constructor(config, templatesWorker, schemaComponentsMap, typeNameFormatter, schemaWalker) {
+	constructor(config, templatesWorker, schemaComponentsMap, typeNameFormatter) {
 		this.config = config;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.typeNameFormatter = typeNameFormatter;
 		this.templatesWorker = templatesWorker;
-		this.schemaWalker = schemaWalker;
-		this.schemaUtils = new SchemaUtils(this);
+		this.schemaUtils = new SchemaUtils(this.config, this.schemaComponentsMap, this.typeNameFormatter);
 		this.schemaFormatters = new SchemaFormatters(this);
 	}
 	createSchemaParser = ({ schema, typeName, schemaPath }) => {
@@ -1612,7 +1646,7 @@ var SpecificArgNameResolver = class extends NameResolver {
 	constructor(config, reservedNames) {
 		super(config, reservedNames, (variants) => {
 			const generatedVariant = variants[0] && `${variants[0]}${this.counter++}` || `${this.config.specificArgNameResolverName}${this.counter++}`;
-			consola.debug("generated fallback type name for specific arg - ", generatedVariant);
+			consola$1.debug("generated fallback type name for specific arg - ", generatedVariant);
 			return generatedVariant;
 		});
 	}
@@ -1630,12 +1664,7 @@ const CONTENT_KIND = {
 	TEXT: "TEXT"
 };
 var SchemaRoutes = class {
-	config;
-	schemaParserFabric;
 	schemaUtils;
-	typeNameFormatter;
-	schemaComponentsMap;
-	templatesWorker;
 	FORM_DATA_TYPES = [];
 	routes = [];
 	hasSecurityRoutes = false;
@@ -1644,10 +1673,10 @@ var SchemaRoutes = class {
 	constructor(config, schemaParserFabric, schemaComponentsMap, templatesWorker, typeNameFormatter) {
 		this.config = config;
 		this.schemaParserFabric = schemaParserFabric;
-		this.schemaUtils = this.schemaParserFabric.schemaUtils;
-		this.typeNameFormatter = typeNameFormatter;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.templatesWorker = templatesWorker;
+		this.typeNameFormatter = typeNameFormatter;
+		this.schemaUtils = this.schemaParserFabric.schemaUtils;
 		this.FORM_DATA_TYPES = uniq([this.schemaUtils.getSchemaType({
 			type: "string",
 			format: "file"
@@ -1656,11 +1685,16 @@ var SchemaRoutes = class {
 			format: "binary"
 		})]);
 	}
-	createRequestsMap = (routesByMethod) => {
+	createRequestsMap = (resolvedSwaggerSchema, 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;
+			if (method.startsWith("x-") || ["parameters"].includes(method)) continue;
+			if (method === "$ref") {
+				const refData = resolvedSwaggerSchema.getRef(requestInfo);
+				if (typeGuard.isObject(refData)) Object.assign(result, this.createRequestsMap(resolvedSwaggerSchema, refData));
+				continue;
+			}
 			result[method] = {
 				...requestInfo,
 				parameters: compact([...parameters || [], ...requestInfo.parameters || []])
@@ -1675,7 +1709,7 @@ var SchemaRoutes = class {
 		for (const match of pathParamMatches || []) {
 			const paramName = match.replace(/\{|\}|:/g, "");
 			if (!paramName) continue;
-			if (paramName.includes("-")) consola.warn("wrong path param name", paramName);
+			if (paramName.includes("-")) consola$1.warn("wrong path param name", paramName);
 			pathParams.push({
 				$match: match,
 				name: camelCase(paramName),
@@ -1696,7 +1730,7 @@ var SchemaRoutes = class {
 			for (const match of queryParamMatches) fixedRoute = fixedRoute.replace(match, "");
 			const paramNames = uniq(queryParamMatches.join(",").replace(/(\{\?)|(\})|\s/g, "").split(","));
 			for (const paramName of paramNames) {
-				if (typeof paramName === "string" && paramName.includes("-")) consola.warn("wrong query param name", paramName);
+				if (typeof paramName === "string" && paramName.includes("-")) consola$1.warn("wrong query param name", paramName);
 				queryParams.push({
 					$match: paramName,
 					name: typeof paramName === "string" ? camelCase(paramName) : camelCase(String(paramName)),
@@ -1729,7 +1763,7 @@ var SchemaRoutes = class {
 		for (const parameter of parameters || []) {
 			const refTypeInfo = this.schemaParserFabric.schemaUtils.getSchemaRefType(parameter);
 			let routeParam = null;
-			if (refTypeInfo?.rawTypeData.in && refTypeInfo.rawTypeData) {
+			if (!!refTypeInfo?.rawTypeData && typeof refTypeInfo === "object" && refTypeInfo?.rawTypeData.in) {
 				if (!routeParams[refTypeInfo.rawTypeData.in]) routeParams[refTypeInfo.rawTypeData.in] = [];
 				routeParam = {
 					...refTypeInfo.rawTypeData,
@@ -1799,10 +1833,11 @@ var SchemaRoutes = class {
 		}
 		return defaultType || this.config.Ts.Keyword.Any;
 	};
-	getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType }) => {
+	getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType, resolvedSwaggerSchema }) => {
 		const result = [];
 		for (const [status, requestInfo] of Object.entries(requestInfos || {})) {
 			const contentTypes = this.getContentTypes([requestInfo], operationId);
+			const links = this.getRouteLinksFromResponse(resolvedSwaggerSchema, requestInfo, status);
 			result.push({
 				...requestInfo || {},
 				contentTypes,
@@ -1814,21 +1849,48 @@ var SchemaRoutes = class {
 					defaultType
 				})),
 				description: this.schemaParserFabric.schemaFormatters.formatDescription(requestInfo.description || "", true),
+				links,
 				status: Number.isNaN(+status) ? status : +status,
 				isSuccess: this.isSuccessStatus(status)
 			});
 		}
 		return result;
 	};
-	getResponseBodyInfo = (routeInfo, parsedSchemas) => {
+	getRouteLinksFromResponse = (resolvedSwaggerSchema, responseInfo, status) => {
+		const links = get(responseInfo, "links");
+		if (!typeGuard.isObject(links)) return [];
+		return reduce(links, (acc, linkInfo, linkName) => {
+			if (!typeGuard.isObject(linkInfo)) return acc;
+			let normalizedLinkInfo = linkInfo;
+			if (typeof linkInfo.$ref === "string") {
+				const refData = resolvedSwaggerSchema.getRef(linkInfo.$ref);
+				if (typeGuard.isObject(refData)) normalizedLinkInfo = refData;
+			}
+			const operationId = typeof normalizedLinkInfo.operationId === "string" ? normalizedLinkInfo.operationId : void 0;
+			const operationRef = typeof normalizedLinkInfo.operationRef === "string" ? normalizedLinkInfo.operationRef : typeof linkInfo.$ref === "string" ? linkInfo.$ref : void 0;
+			if (!operationId && !operationRef) return acc;
+			const parameters = typeGuard.isObject(normalizedLinkInfo.parameters) ? mapValues(normalizedLinkInfo.parameters, (value) => String(value)) : void 0;
+			acc.push({
+				status: Number.isNaN(+status) ? status : +status,
+				name: String(linkName),
+				operationId,
+				operationRef,
+				parameters
+			});
+			return acc;
+		}, []);
+	};
+	getResponseBodyInfo = (routeInfo, parsedSchemas, resolvedSwaggerSchema) => {
 		const { produces, operationId, responses } = routeInfo;
 		const contentTypes = this.getContentTypes(responses, [...produces || [], routeInfo["x-accepts"]]);
 		const responseInfos = this.getRequestInfoTypes({
 			requestInfos: responses,
 			parsedSchemas,
 			operationId,
-			defaultType: this.config.defaultResponseType
+			defaultType: this.config.defaultResponseType,
+			resolvedSwaggerSchema
 		});
+		const links = responseInfos.flatMap((responseInfo) => responseInfo.links || []);
 		const successResponse = responseInfos.find((response) => response.isSuccess);
 		const errorResponses = responseInfos.filter((response) => !response.isSuccess && response.type !== this.config.Ts.Keyword.Any);
 		const handleResponseHeaders = (src) => {
@@ -1841,6 +1903,7 @@ var SchemaRoutes = class {
 		return {
 			contentTypes,
 			responses: responseInfos,
+			links,
 			success: {
 				schema: successResponse,
 				type: successResponse?.type || this.config.Ts.Keyword.Any
@@ -2011,11 +2074,11 @@ var SchemaRoutes = class {
 		const { routeNameDuplicatesMap, templatesToRender } = this.config;
 		const routeNameTemplate = templatesToRender.routeName;
 		const routeNameFromTemplate = this.templatesWorker.renderTemplate(routeNameTemplate, { routeInfo: rawRouteInfo });
-		const routeName = this.config.hooks.onFormatRouteName(rawRouteInfo, routeNameFromTemplate) || routeNameFromTemplate;
+		const routeName = this.config.hooks.onFormatRouteName?.(rawRouteInfo, routeNameFromTemplate) || routeNameFromTemplate;
 		const duplicateIdentifier = `${moduleName}|${routeName}`;
 		if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
 			routeNameDuplicatesMap.set(duplicateIdentifier, routeNameDuplicatesMap.get(duplicateIdentifier) + 1);
-			consola.warn(`Module "${moduleName}" already has method "${routeName}()".`, `This method has been renamed to "${routeName + routeNameDuplicatesMap.get(duplicateIdentifier)}()" to solve conflict names.`);
+			consola$1.warn(`Module "${moduleName}" already has method "${routeName}()".`, `This method has been renamed to "${routeName + routeNameDuplicatesMap.get(duplicateIdentifier)}()" to solve conflict names.`);
 		} else routeNameDuplicatesMap.set(duplicateIdentifier, 1);
 		const duplicates = routeNameDuplicatesMap.get(duplicateIdentifier);
 		const routeNameInfo = {
@@ -2023,10 +2086,10 @@ var SchemaRoutes = class {
 			original: routeName,
 			duplicate: duplicates > 1
 		};
-		return this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) || routeNameInfo;
+		return this.config.hooks.onCreateRouteName?.(routeNameInfo, rawRouteInfo) || routeNameInfo;
 	};
-	parseRouteInfo = (rawRouteName, routeInfo, method, usageSchema, parsedSchemas) => {
-		const { security: globalSecurity } = usageSchema;
+	parseRouteInfo = (rawRouteName, routeInfo, method, resolvedSwaggerSchema, parsedSchemas) => {
+		const { security: globalSecurity } = resolvedSwaggerSchema.usageSchema;
 		const { moduleNameIndex, moduleNameFirstTag, extractRequestParams } = this.config;
 		const { operationId, requestBody, security, parameters, summary, description, tags, responses, requestBodyName, produces, consumes, ...otherInfo } = routeInfo;
 		const { route, pathParams: pathParamsFromRouteName, queryParams: queryParamsFromRouteName } = this.parseRouteName(rawRouteName);
@@ -2043,7 +2106,7 @@ var SchemaRoutes = class {
 			description: pathArgSchema.description
 		}));
 		const pathArgsNames = pathArgs.map((arg) => arg.name);
-		const responseBodyInfo = this.getResponseBodyInfo(routeInfo, parsedSchemas);
+		const responseBodyInfo = this.getResponseBodyInfo(routeInfo, parsedSchemas, resolvedSwaggerSchema);
 		const rawRouteInfo = {
 			...otherInfo,
 			pathArgs,
@@ -2052,6 +2115,7 @@ var SchemaRoutes = class {
 			route: rawRouteName,
 			moduleName,
 			responsesTypes: responseBodyInfo.responses,
+			links: responseBodyInfo.links,
 			description,
 			tags,
 			summary,
@@ -2147,13 +2211,13 @@ var SchemaRoutes = class {
 			raw: rawRouteInfo
 		};
 	};
-	attachSchema = ({ usageSchema, parsedSchemas }) => {
+	attachSchema = (resolvedSwaggerSchema, parsedSchemas) => {
 		this.config.routeNameDuplicatesMap.clear();
-		const pathsEntries = Object.entries(usageSchema.paths || {});
+		const pathsEntries = Object.entries(resolvedSwaggerSchema.usageSchema.paths || {});
 		for (const [rawRouteName, routeInfoByMethodsMap] of pathsEntries) {
-			const routeInfosMap = this.createRequestsMap(routeInfoByMethodsMap);
+			const routeInfosMap = this.createRequestsMap(resolvedSwaggerSchema, routeInfoByMethodsMap);
 			for (const [method, routeInfo] of Object.entries(routeInfosMap)) {
-				const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, usageSchema, parsedSchemas);
+				const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, resolvedSwaggerSchema, parsedSchemas);
 				const processedRouteInfo = this.config.hooks.onCreateRoute(parsedRouteInfo);
 				if (processedRouteInfo !== false) {
 					const route = processedRouteInfo || parsedRouteInfo;
@@ -2207,30 +2271,353 @@ var SchemaRoutes = class {
 };
 
 //#endregion
-//#region src/schema-walker.ts
-var SchemaWalker = class {
-	config;
-	swaggerSchemaResolver;
-	schemas = /* @__PURE__ */ new Map();
-	caches = /* @__PURE__ */ new Map();
-	constructor(config, swaggerSchemaResolver) {
+//#region src/resolved-swagger-schema.ts
+var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
+	parsedRefsCache = /* @__PURE__ */ new Map();
+	externalSchemaCache = /* @__PURE__ */ new Map();
+	httpMethodSegments = new Set([
+		"get",
+		"put",
+		"post",
+		"delete",
+		"patch",
+		"options",
+		"head",
+		"trace",
+		"parameters"
+	]);
+	normalizeRef(ref) {
+		let normalizedRef = ref;
+		normalizedRef = normalizedRef.replace(/\/#(?=\/)/, "#");
+		normalizedRef = normalizedRef.replace(/#(?!\/)/, "#/");
+		return normalizedRef;
+	}
+	createEscapedPathsRefVariant(ref) {
+		const [prefix = "", rawPointer = ""] = this.normalizeRef(ref).split("#");
+		const pointer = rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}`;
+		if (!pointer.startsWith("/paths/") || pointer.startsWith("/paths/~1")) return null;
+		const rest = pointer.slice(7);
+		if (!rest) return null;
+		const parts = rest.split("/");
+		const last = parts.at(-1)?.toLowerCase() || "";
+		const hasTailSegment = this.httpMethodSegments.has(last);
+		const pathParts = hasTailSegment ? parts.slice(0, -1) : parts;
+		const tail = hasTailSegment ? `/${parts.at(-1)}` : "";
+		if (!pathParts.length) return null;
+		return `${prefix}#/paths/${`~1${pathParts.join("/").replace(/\//g, "~1")}`}${tail}`;
+	}
+	isHttpUrl(value) {
+		return /^https?:\/\//i.test(value);
+	}
+	getRemoteRequestHeaders() {
+		return Object.assign({}, this.config.authorizationToken ? { Authorization: this.config.authorizationToken } : {}, this.config.requestOptions?.headers || {});
+	}
+	stripHash(urlOrPath) {
+		return urlOrPath.split("#")[0] || urlOrPath;
+	}
+	extractRefsFromSchema(schema) {
+		const refs = /* @__PURE__ */ new Set();
+		const walk = (node) => {
+			if (!node || typeof node !== "object") return;
+			if (Array.isArray(node)) {
+				for (const item of node) walk(item);
+				return;
+			}
+			const recordNode = node;
+			if (typeof recordNode.$ref === "string") refs.add(recordNode.$ref);
+			for (const value of Object.values(recordNode)) walk(value);
+		};
+		walk(schema);
+		return [...refs];
+	}
+	async fetchRemoteSchemaDocument(url) {
+		try {
+			const response = await fetch(url, { headers: this.getRemoteRequestHeaders() });
+			if (!response.ok) return null;
+			const content = await response.text();
+			try {
+				const parsed = JSON.parse(content);
+				if (parsed && typeof parsed === "object") return parsed;
+			} catch {
+				const parsed = YAML.parse(content);
+				if (parsed && typeof parsed === "object") return parsed;
+			}
+		} catch (e) {
+			consola.debug(e);
+		}
+		return null;
+	}
+	async warmUpRemoteSchemasCache() {
+		if (typeof this.config.url !== "string" || !this.isHttpUrl(this.config.url)) return;
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [this.stripHash(this.config.url)];
+		while (queue.length > 0) {
+			const currentUrl = queue.shift();
+			if (!currentUrl || visited.has(currentUrl)) continue;
+			visited.add(currentUrl);
+			if (this.externalSchemaCache.has(currentUrl)) continue;
+			const schema = await this.fetchRemoteSchemaDocument(currentUrl);
+			if (!schema) continue;
+			this.externalSchemaCache.set(currentUrl, schema);
+			for (const ref of this.extractRefsFromSchema(schema)) {
+				const normalizedRef = this.normalizeRef(ref);
+				if (normalizedRef.startsWith("#")) continue;
+				const [externalPath = ""] = normalizedRef.split("#");
+				if (!externalPath) continue;
+				let absoluteUrl = "";
+				try {
+					absoluteUrl = this.isHttpUrl(externalPath) ? this.stripHash(externalPath) : this.stripHash(new URL(externalPath, currentUrl).toString());
+				} catch (e) {
+					consola.debug(e);
+				}
+				if (absoluteUrl && !visited.has(absoluteUrl)) queue.push(absoluteUrl);
+			}
+		}
+	}
+	collectRemoteAbsoluteRefCandidates(ref) {
+		if (!ref || this.isHttpUrl(ref) || ref.startsWith("#")) return [];
+		const [relativePath = "", rawPointer = ""] = this.normalizeRef(ref).split("#");
+		if (!relativePath) return [];
+		const pointer = rawPointer ? rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}` : "";
+		const bases = /* @__PURE__ */ new Set();
+		if (typeof this.config.url === "string" && this.isHttpUrl(this.config.url)) bases.add(this.config.url);
+		for (const cachedUrl of this.externalSchemaCache.keys()) if (this.isHttpUrl(cachedUrl)) bases.add(cachedUrl);
+		for (const resolver of this.resolvers) try {
+			const resolverPaths = typeof resolver.paths === "function" ? resolver.paths() : [];
+			for (const resolverPath of resolverPaths) if (typeof resolverPath === "string" && this.isHttpUrl(resolverPath)) bases.add(resolverPath);
+		} catch (e) {
+			consola.debug(e);
+		}
+		const results = /* @__PURE__ */ new Set();
+		for (const base of bases) try {
+			const absolutePath = new URL(relativePath, base).toString();
+			results.add(pointer ? `${absolutePath}#${pointer}` : absolutePath);
+		} catch (e) {
+			consola.debug(e);
+		}
+		return [...results];
+	}
+	resolveFromRemoteSchemaCache(absoluteRef) {
+		const [externalPath = "", rawPointer = ""] = this.normalizeRef(absoluteRef).split("#");
+		if (!externalPath || !this.isHttpUrl(externalPath)) return null;
+		const schema = this.externalSchemaCache.get(this.stripHash(externalPath));
+		if (!schema) return null;
+		const pointer = rawPointer ? rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}` : "/";
+		const resolved = this.resolveJsonPointer(schema, pointer);
+		if (resolved == null) return null;
+		return this.absolutizeLocalRefs(resolved, this.stripHash(externalPath));
+	}
+	constructor(config, usageSchema, originalSchema, resolvers) {
 		this.config = config;
-		this.swaggerSchemaResolver = swaggerSchemaResolver;
+		this.usageSchema = usageSchema;
+		this.originalSchema = originalSchema;
+		this.resolvers = resolvers;
+		this.usageSchema = usageSchema;
+		this.originalSchema = originalSchema;
+	}
+	getRefDetails(ref) {
+		const normalizedRef = this.normalizeRef(ref);
+		if (!this.parsedRefsCache.has(ref)) {
+			const isLocal = normalizedRef.startsWith("#");
+			if (isLocal) this.parsedRefsCache.set(ref, {
+				ref: normalizedRef,
+				isLocal,
+				externalUrlOrPath: null
+			});
+			else {
+				const externalUrlOrPath = normalizedRef.split("#")[0] || "";
+				let externalOpenapiFileName = externalUrlOrPath.replace(/\/$/, "").split("/").at(-1) || "";
+				if (externalOpenapiFileName.endsWith(".json") || externalOpenapiFileName.endsWith(".yaml")) externalOpenapiFileName = externalOpenapiFileName.slice(0, -5);
+				else if (externalOpenapiFileName.endsWith(".yml")) externalOpenapiFileName = externalOpenapiFileName.slice(0, -4);
+				this.parsedRefsCache.set(ref, {
+					ref: normalizedRef,
+					isLocal,
+					externalUrlOrPath,
+					externalOpenapiFileName
+				});
+			}
+		}
+		const cachedRef = this.parsedRefsCache.get(ref);
+		if (cachedRef) return cachedRef;
+		if (normalizedRef.startsWith("#")) return {
+			ref: normalizedRef,
+			isLocal: true,
+			externalUrlOrPath: null
+		};
+		return {
+			ref: normalizedRef,
+			isLocal: false,
+			externalUrlOrPath: normalizedRef.split("#")[0] || null,
+			externalOpenapiFileName: ""
+		};
+	}
+	isLocalRef(ref) {
+		return this.getRefDetails(ref).isLocal;
+	}
+	getRef(ref) {
+		if (!ref) return null;
+		const normalizedRef = this.normalizeRef(ref);
+		const escapedPathsRefVariant = this.createEscapedPathsRefVariant(ref);
+		if (normalizedRef !== ref) {
+			const resolvedByNormalizedRef = this.tryToResolveRef(normalizedRef);
+			if (resolvedByNormalizedRef) return this.normalizeResolvedExternalSchemaRef(normalizedRef, resolvedByNormalizedRef);
+		}
+		if (escapedPathsRefVariant) {
+			const resolvedByEscapedPathsRef = this.tryToResolveRef(escapedPathsRefVariant);
+			if (resolvedByEscapedPathsRef) return this.normalizeResolvedExternalSchemaRef(escapedPathsRefVariant, resolvedByEscapedPathsRef);
+		}
+		const remoteAbsoluteCandidates = this.collectRemoteAbsoluteRefCandidates(ref);
+		for (const remoteAbsoluteRef of remoteAbsoluteCandidates) {
+			const resolvedFromRemoteCache = this.resolveFromRemoteSchemaCache(remoteAbsoluteRef);
+			if (resolvedFromRemoteCache) return resolvedFromRemoteCache;
+			const resolvedByRemoteAbsoluteRef = this.tryToResolveRef(remoteAbsoluteRef);
+			if (resolvedByRemoteAbsoluteRef) return this.normalizeResolvedExternalSchemaRef(remoteAbsoluteRef, resolvedByRemoteAbsoluteRef);
+		}
+		const resolvedByOrigRef = this.tryToResolveRef(ref);
+		if (resolvedByOrigRef) return this.normalizeResolvedExternalSchemaRef(ref, resolvedByOrigRef);
+		if (/#[a-z]/.test(ref)) {
+			const fixedRef = ref.replace(/#[a-z]/, (match) => {
+				const [hashtag, char] = match.split("");
+				return `${hashtag}/${char}`;
+			});
+			const resolvedByFixedRef = this.tryToResolveRef(fixedRef);
+			if (resolvedByFixedRef) return this.normalizeResolvedExternalSchemaRef(fixedRef, resolvedByFixedRef);
+		}
+		return this.tryToResolveRefFromFile(normalizedRef);
+	}
+	tryToResolveRef(ref) {
+		if (!this.resolvers || !ref) return null;
+		for (const resolver of this.resolvers) try {
+			return resolver.get(ref);
+		} catch (e) {
+			consola.debug(e);
+		}
+		return null;
+	}
+	readExternalSchema(filePath) {
+		if (this.externalSchemaCache.has(filePath)) return this.externalSchemaCache.get(filePath) || null;
+		if (!fs.existsSync(filePath)) return null;
+		try {
+			const content = fs.readFileSync(filePath, "utf8");
+			const parsed = JSON.parse(content);
+			this.externalSchemaCache.set(filePath, parsed);
+			return parsed;
+		} catch {
+			try {
+				const content = fs.readFileSync(filePath, "utf8");
+				const parsed = YAML.parse(content);
+				if (parsed && typeof parsed === "object") {
+					this.externalSchemaCache.set(filePath, parsed);
+					return parsed;
+				}
+			} catch (e) {
+				consola.debug(e);
+			}
+		}
+		return null;
+	}
+	resolveJsonPointer(source, pointer) {
+		if (!source || typeof source !== "object") return null;
+		if (!pointer || pointer === "/") return source;
+		const tokens = pointer.replace(/^\/+/, "").split("/").filter(Boolean).map((part) => decodeURIComponent(part.replace(/~1/g, "/").replace(/~0/g, "~")));
+		let current = source;
+		for (const token of tokens) {
+			if (!current || typeof current !== "object") return null;
+			current = current[token];
+		}
+		return current ?? null;
+	}
+	absolutizeLocalRefs(value, externalPath) {
+		if (value == null || typeof value !== "object") return value;
+		const cloneValue = structuredClone(value);
+		const walk = (node) => {
+			if (!node || typeof node !== "object") return;
+			if (Array.isArray(node)) {
+				for (const item of node) walk(item);
+				return;
+			}
+			const recordNode = node;
+			if (typeof recordNode.$ref === "string" && recordNode.$ref.startsWith("#")) recordNode.$ref = `${externalPath}${this.normalizeRef(recordNode.$ref)}`;
+			for (const nested of Object.values(recordNode)) walk(nested);
+		};
+		walk(cloneValue);
+		return cloneValue;
+	}
+	normalizeResolvedExternalSchemaRef(ref, resolved) {
+		const normalizedRef = this.normalizeRef(ref);
+		if (normalizedRef.startsWith("#")) return resolved;
+		const externalPath = normalizedRef.split("#")[0] || "";
+		if (!externalPath) return resolved;
+		return this.absolutizeLocalRefs(resolved, externalPath);
+	}
+	collectExternalRefCandidates(externalPath) {
+		const candidates = /* @__PURE__ */ new Set();
+		if (/^https?:\/\//i.test(externalPath)) return [];
+		if (path.isAbsolute(externalPath)) candidates.add(externalPath);
+		const inputPath = this.config.input;
+		if (typeof inputPath === "string" && inputPath) candidates.add(path.resolve(path.dirname(inputPath), externalPath));
+		for (const resolver of this.resolvers) try {
+			const resolverPaths = typeof resolver.paths === "function" ? resolver.paths() : [];
+			for (const resolverPath of resolverPaths) {
+				if (typeof resolverPath !== "string") continue;
+				if (/^https?:\/\//i.test(resolverPath)) continue;
+				candidates.add(path.resolve(path.dirname(resolverPath), externalPath));
+			}
+		} catch (e) {
+			consola.debug(e);
+		}
+		return [...candidates];
+	}
+	tryToResolveRefFromFile(ref) {
+		if (!ref || ref.startsWith("#")) return null;
+		const [externalPath = "", rawPointer = ""] = ref.split("#");
+		if (!externalPath) return null;
+		const pointer = rawPointer ? rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}` : "/";
+		const candidates = this.collectExternalRefCandidates(externalPath);
+		for (const candidate of candidates) {
+			const schema = this.readExternalSchema(candidate);
+			const resolved = this.resolveJsonPointer(schema, pointer);
+			if (resolved != null) return this.absolutizeLocalRefs(resolved, externalPath);
+		}
+		return null;
+	}
+	static async create(config, usageSchema, originalSchema) {
+		const resolvers = [];
+		const options = {
+			continueOnError: true,
+			mutateInputSchema: true,
+			dereference: {},
+			validate: {
+				schema: false,
+				spec: false
+			},
+			resolve: {
+				external: true,
+				http: {
+					...config.requestOptions,
+					headers: Object.assign({}, config.authorizationToken ? { Authorization: config.authorizationToken } : {}, config.requestOptions?.headers ?? {})
+				}
+			}
+		};
+		try {
+			resolvers.push(await SwaggerParser.resolve(originalSchema, options));
+		} catch (e) {
+			consola.debug(e);
+		}
+		try {
+			resolvers.push(await SwaggerParser.resolve(usageSchema, options));
+		} catch (e) {
+			consola.debug(e);
+		}
+		try {
+			resolvers.push(await SwaggerParser.resolve(config.url || config.input || config.spec, options));
+		} catch (e) {
+			consola.debug(e);
+		}
+		const resolvedSwaggerSchema = new ResolvedSwaggerSchema(config, usageSchema, originalSchema, resolvers);
+		await resolvedSwaggerSchema.warmUpRemoteSchemasCache();
+		return resolvedSwaggerSchema;
 	}
-	addSchema = (name, schema) => {
-		this.schemas.set(name, structuredClone(schema));
-	};
-	_isLocalRef = (ref) => {
-		return ref.startsWith("#");
-	};
-	_isRemoteRef = (ref) => {
-		return ref.startsWith("http://") || ref.startsWith("https://");
-	};
-	_getRefDataFromSchema = (schema, ref) => {
-		const refData = get(schema, ref.replace("#", "").split("/"));
-		if (refData) this.caches.set(ref, refData);
-		return refData;
-	};
 };
 
 //#endregion
@@ -2248,7 +2635,7 @@ var Request = class {
 			return await (await fetch(url, requestOptions)).text();
 		} catch (error) {
 			const message = `error while fetching data from URL "${url}"`;
-			consola.error(message, error);
+			consola$1.error(message, error);
 			return message;
 		}
 	}
@@ -2267,10 +2654,15 @@ var SwaggerSchemaResolver = class {
 	}
 	async create() {
 		const { spec, patch, input, url, authorizationToken } = this.config;
-		if (spec) return await this.convertSwaggerObject(spec, { patch });
-		const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url, authorizationToken);
-		const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
-		return await this.convertSwaggerObject(swaggerSchemaObject, { patch });
+		let swaggerSchemas;
+		if (spec) swaggerSchemas = await this.convertSwaggerObject(spec, { patch });
+		else {
+			const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url, authorizationToken);
+			const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
+			swaggerSchemas = await this.convertSwaggerObject(swaggerSchemaObject, { patch });
+		}
+		this.fixSwaggerSchemas(swaggerSchemas);
+		return ResolvedSwaggerSchema.create(this.config, swaggerSchemas.usageSchema, swaggerSchemas.originalSchema);
 	}
 	convertSwaggerObject(swaggerSchema, converterOptions) {
 		return new Promise((resolve) => {
@@ -2303,12 +2695,12 @@ var SwaggerSchemaResolver = class {
 		});
 	}
 	getSwaggerSchemaByPath = (pathToSwagger) => {
-		consola.info(`try to get swagger by path "${pathToSwagger}"`);
+		consola$1.info(`try to get swagger by path "${pathToSwagger}"`);
 		return this.fileSystem.getFileContent(pathToSwagger);
 	};
 	async fetchSwaggerSchemaFile(pathToSwagger, urlToSwagger, authToken) {
 		if (this.fileSystem.pathIsExist(pathToSwagger)) return this.getSwaggerSchemaByPath(pathToSwagger);
-		consola.info(`try to get swagger by URL "${urlToSwagger}"`);
+		consola$1.info(`try to get swagger by URL "${urlToSwagger}"`);
 		return await this.request.download({
 			url: urlToSwagger,
 			authToken
@@ -2322,7 +2714,26 @@ var SwaggerSchemaResolver = class {
 			return YAML.parse(file);
 		}
 	}
-	fixSwaggerSchema({ usageSchema, originalSchema }) {
+	normalizeRefValue(ref) {
+		const refWithoutSlashBeforeHash = ref.split("/#/").join("#/");
+		const hashIndex = refWithoutSlashBeforeHash.indexOf("#");
+		if (hashIndex === -1) return refWithoutSlashBeforeHash;
+		if (refWithoutSlashBeforeHash[hashIndex + 1] === "/") return refWithoutSlashBeforeHash;
+		return `${refWithoutSlashBeforeHash.slice(0, hashIndex + 1)}/${refWithoutSlashBeforeHash.slice(hashIndex + 1)}`;
+	}
+	normalizeRefsInSchema(schema) {
+		if (!schema || typeof schema !== "object") return;
+		if (Array.isArray(schema)) {
+			for (const value of schema) this.normalizeRefsInSchema(value);
+			return;
+		}
+		const objectSchema = schema;
+		if (typeof objectSchema.$ref === "string") objectSchema.$ref = this.normalizeRefValue(objectSchema.$ref);
+		for (const value of Object.values(objectSchema)) this.normalizeRefsInSchema(value);
+	}
+	fixSwaggerSchemas({ usageSchema, originalSchema }) {
+		this.normalizeRefsInSchema(usageSchema);
+		this.normalizeRefsInSchema(originalSchema);
 		const usagePaths = get(usageSchema, "paths") || {};
 		const originalPaths = get(originalSchema, "paths") || {};
 		for (const [route, usagePathObject] of Object.entries(usagePaths)) {
@@ -2331,9 +2742,10 @@ var SwaggerSchemaResolver = class {
 				const originalRouteInfo = get(originalPathObject, methodName) || {};
 				const usageRouteParams = get(usageRouteInfo, "parameters") || [];
 				const originalRouteParams = get(originalRouteInfo, "parameters") || [];
+				const usageAsOpenapiv2 = usageRouteInfo;
 				if (typeof usageRouteInfo === "object") {
-					usageRouteInfo.consumes = uniq(compact([...usageRouteInfo.consumes || [], ...originalRouteInfo.consumes || []]));
-					usageRouteInfo.produces = uniq(compact([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
+					usageAsOpenapiv2.consumes = uniq(compact([...usageAsOpenapiv2.consumes || [], ...originalRouteInfo.consumes || []]));
+					usageAsOpenapiv2.produces = uniq(compact([...usageAsOpenapiv2.produces || [], ...originalRouteInfo.produces || []]));
 				}
 				for (const originalRouteParam of originalRouteParams) if (!usageRouteParams.find((param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name)) usageRouteParams.push(originalRouteParam);
 			}
@@ -2353,8 +2765,8 @@ var TemplatesWorker = class {
 		this.config = config;
 		this.fileSystem = fileSystem;
 		this.getRenderTemplateData = getRenderTemplateData;
-		if (this.config.debug) consola.level = Number.MAX_SAFE_INTEGER;
-		if (this.config.silent) consola.level = 0;
+		if (this.config.debug) consola$1.level = Number.MAX_SAFE_INTEGER;
+		if (this.config.silent) consola$1.level = 0;
 	}
 	getTemplatePaths = (config) => {
 		const __dirname = path$1.dirname(url$1.fileURLToPath(import.meta.url));
@@ -2385,19 +2797,19 @@ var TemplatesWorker = class {
 		const customFullPath = templatePaths.custom && this.getTemplateFullPath(templatePaths.custom, fileName);
 		let fileContent = customFullPath && this.fileSystem.getFileContent(customFullPath);
 		if (fileContent) {
-			consola.info(`"${name.toLowerCase()}" template found in "${templatePaths.custom}"`);
+			consola$1.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.toLowerCase()}"`, "template not found in", `"${templatePaths.custom}"`);
-		else consola.info(`Code generator will use the default template for "${name.toLowerCase()}"`);
+		else if (templatePaths.custom) consola$1.warn("Code generator will use the default template:", `"${name.toLowerCase()}"`, "template not found in", `"${templatePaths.custom}"`);
+		else consola$1.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}"`);
+		if (templatePaths.custom) consola$1.info(`try to read templates from directory "${templatePaths.custom}"`);
 		return this.config.templateInfos.reduce((acc, { name, fileName }) => ({
 			...acc,
 			[name]: this.getTemplate(name, fileName)
@@ -2498,7 +2910,7 @@ var TypeNameFormatter = class {
 		const typeSuffix = schemaType === "enum-key" ? this.config.enumKeySuffix : this.config.typeSuffix;
 		const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
 		if (typeof name !== "string") {
-			consola.warn("wrong model name", name);
+			consola$1.warn("wrong model name", name);
 			return name;
 		}
 		if (/^(?!\d)([A-Z0-9_]{1,})$/g.test(name)) return compact([
@@ -2508,7 +2920,7 @@ var TypeNameFormatter = class {
 		]).join("_");
 		if (this.formattedModelNamesMap.has(hashKey)) return this.formattedModelNamesMap.get(hashKey);
 		const formattedName = startCase(`${typePrefix}_${this.fixModelName(name, { type: schemaType })}_${typeSuffix}`).replace(/\s/g, "");
-		const formattedResultName = this.config.hooks.onFormatTypeName(formattedName, name, schemaType) || formattedName;
+		const formattedResultName = this.config.hooks.onFormatTypeName?.(formattedName, name, schemaType) || formattedName;
 		this.formattedModelNamesMap.set(hashKey, formattedResultName);
 		return formattedResultName;
 	};
@@ -2550,14 +2962,14 @@ var FileSystem = class {
 			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);
+			consola$1.debug("failed to remove dir", e);
 		}
 	};
 	createDir = (path) => {
 		try {
 			fs.mkdirSync(path, { recursive: true });
 		} catch (e) {
-			consola.debug("failed to create dir", e);
+			consola$1.debug("failed to create dir", e);
 		}
 	};
 	cleanDir = (path) => {
@@ -2607,38 +3019,35 @@ var CodeGenProcess = class {
 	fileSystem;
 	codeFormatter;
 	templatesWorker;
-	schemaWalker;
 	javascriptTranslator;
+	swaggerRefs;
 	constructor(config) {
 		this.config = new CodeGenConfig(config);
 		this.fileSystem = new FileSystem();
 		this.swaggerSchemaResolver = new SwaggerSchemaResolver(this.config, this.fileSystem);
-		this.schemaWalker = new SchemaWalker(this.config, this.swaggerSchemaResolver);
 		this.schemaComponentsMap = new SchemaComponentsMap(this.config);
 		this.typeNameFormatter = new TypeNameFormatter(this.config);
 		this.templatesWorker = new TemplatesWorker(this.config, this.fileSystem, this.getRenderTemplateData);
 		this.codeFormatter = new CodeFormatter(this.config);
-		this.schemaParserFabric = new SchemaParserFabric(this.config, this.templatesWorker, this.schemaComponentsMap, this.typeNameFormatter, this.schemaWalker);
+		this.schemaParserFabric = new SchemaParserFabric(this.config, this.templatesWorker, this.schemaComponentsMap, this.typeNameFormatter);
 		this.schemaRoutes = new SchemaRoutes(this.config, this.schemaParserFabric, this.schemaComponentsMap, this.templatesWorker, this.typeNameFormatter);
 		this.javascriptTranslator = new JavascriptTranslator(this.config, this.codeFormatter);
 	}
 	async start() {
 		this.config.update({ templatePaths: this.templatesWorker.getTemplatePaths(this.config) });
 		this.config.update({ templatesToRender: this.templatesWorker.getTemplates(this.config) });
-		const swagger = await this.swaggerSchemaResolver.create();
-		this.swaggerSchemaResolver.fixSwaggerSchema(swagger);
+		const resolvedSwaggerSchema = await this.swaggerSchemaResolver.create();
 		this.config.update({
-			swaggerSchema: swagger.usageSchema,
-			originalSchema: swagger.originalSchema
+			resolvedSwaggerSchema,
+			swaggerSchema: resolvedSwaggerSchema.usageSchema,
+			originalSchema: resolvedSwaggerSchema.originalSchema
 		});
-		this.schemaWalker.addSchema("$usage", swagger.usageSchema);
-		this.schemaWalker.addSchema("$original", swagger.originalSchema);
-		consola.info("start generating your typescript api");
-		this.config.update(this.config.hooks.onInit(this.config, this) || this.config);
-		if (this.config.swaggerSchema) swagger.usageSchema = this.config.swaggerSchema;
-		if (this.config.originalSchema) swagger.originalSchema = this.config.originalSchema;
+		consola$1.info("start generating your typescript api");
+		this.config.update(this.config.hooks.onInit?.(this.config, this) || this.config);
+		if (this.config.swaggerSchema) resolvedSwaggerSchema.usageSchema = this.config.swaggerSchema;
+		if (this.config.originalSchema) resolvedSwaggerSchema.originalSchema = this.config.originalSchema;
 		this.schemaComponentsMap.clear();
-		for (const [componentName, component] of Object.entries(swagger.usageSchema.components || {})) for (const [typeName, rawTypeData] of Object.entries(component)) this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
+		for (const [componentName, component] of Object.entries(resolvedSwaggerSchema.usageSchema.components || {})) for (const [typeName, rawTypeData] of Object.entries(component)) this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
 			"components",
 			componentName,
 			typeName
@@ -2650,12 +3059,9 @@ var CodeGenProcess = class {
 			schemaComponent.typeData = parsed;
 			return parsed;
 		});
-		this.schemaRoutes.attachSchema({
-			usageSchema: swagger.usageSchema,
-			parsedSchemas
-		});
+		this.schemaRoutes.attachSchema(resolvedSwaggerSchema, parsedSchemas);
 		const rawConfiguration = {
-			apiConfig: this.createApiConfig(swagger.usageSchema),
+			apiConfig: this.createApiConfig(resolvedSwaggerSchema.usageSchema),
 			config: this.config,
 			modelTypes: this.collectModelTypes(),
 			hasSecurityRoutes: this.schemaRoutes.hasSecurityRoutes,
@@ -2669,14 +3075,14 @@ var CodeGenProcess = class {
 			customTranslator: this.config.customTranslator ? new this.config.customTranslator() : null,
 			utils: this.getRenderTemplateData().utils
 		};
-		const configuration = this.config.hooks.onPrepareConfig(rawConfiguration) || rawConfiguration;
+		const configuration = this.config.hooks.onPrepareConfig?.(rawConfiguration) || rawConfiguration;
 		if (this.fileSystem.pathIsExist(this.config.output)) {
 			if (this.config.cleanOutput) {
-				consola.debug("cleaning dir", this.config.output);
+				consola$1.debug("cleaning dir", this.config.output);
 				this.fileSystem.cleanDir(this.config.output);
 			}
 		} else {
-			consola.debug(`path ${this.config.output} is not exist. creating dir by this path`);
+			consola$1.debug(`path ${this.config.output} is not exist. creating dir by this path`);
 			this.fileSystem.createDir(this.config.output);
 		}
 		const files = await this.generateOutputFiles({ configuration });
@@ -2687,7 +3093,7 @@ var CodeGenProcess = class {
 				content: file.fileContent,
 				withPrefix: true
 			});
-			consola.success("api file", `"${file.fileName}${file.fileExtension}"`, `created in ${this.config.output}`);
+			consola$1.success("api file", `"${file.fileName}${file.fileExtension}"`, `created in ${this.config.output}`);
 		}
 		return {
 			files,
@@ -2703,6 +3109,7 @@ var CodeGenProcess = class {
 			utils: {
 				Ts: this.config.Ts,
 				formatDescription: this.schemaParserFabric.schemaFormatters.formatDescription,
+				escapeJSDocContent: this.schemaParserFabric.schemaFormatters.escapeJSDocContent,
 				internalCase: camelCase,
 				classNameCase: pascalCase,
 				pascalCase,
@@ -2831,7 +3238,7 @@ var CodeGenProcess = class {
 		const fileName = this.fileSystem.cropExtension(fileNameFull);
 		const fileExtension = typescript.Extension.Ts;
 		if (configuration.translateToJavaScript) {
-			consola.debug("using js translator for", fileName);
+			consola$1.debug("using js translator for", fileName);
 			return await this.javascriptTranslator.translate({
 				fileName,
 				fileExtension,
@@ -2839,14 +3246,14 @@ var CodeGenProcess = class {
 			});
 		}
 		if (configuration.customTranslator) {
-			consola.debug("using custom translator for", fileName);
+			consola$1.debug("using custom translator for", fileName);
 			return await configuration.customTranslator.translate({
 				fileName,
 				fileExtension,
 				fileContent: content
 			});
 		}
-		consola.debug("generating output for", `${fileName}${fileExtension}`);
+		consola$1.debug("generating output for", `${fileName}${fileExtension}`);
 		return [{
 			fileName,
 			fileExtension,
@@ -2920,7 +3327,7 @@ var TemplatesGenConfig = class {
 		this.update(config);
 	}
 	update = (update) => {
-		Object.assign(this, update);
+		objectAssign(this, update);
 	};
 };
 
@@ -2947,10 +3354,10 @@ var TemplatesGenProcess = class {
 		this.fileSystem = new FileSystem();
 	}
 	async start() {
-		consola.info("start generating source templates \".ejs\" for code generator");
+		consola$1.info("start generating source templates \".ejs\" for code generator");
 		const templates = this.getTemplates();
 		if (this.config.output) {
-			consola.info("preparing output directory for source templates");
+			consola$1.info("preparing output directory for source templates");
 			const outputPath = path.resolve(process.cwd(), this.config.output);
 			if (this.fileSystem.pathIsExist(outputPath)) {
 				if (this.config.cleanOutput) this.fileSystem.cleanDir(outputPath);
@@ -2982,7 +3389,7 @@ var TemplatesGenProcess = class {
 					});
 				}
 			}
-			consola.success(`source templates has been successfully created in "${outputPath}"`);
+			consola$1.success(`source templates has been successfully created in "${outputPath}"`);
 		}
 		return {
 			files: templates,
@@ -3029,11 +3436,11 @@ var TemplatesGenProcess = class {
 //#endregion
 //#region src/commands/generate-templates/index.ts
 async function generateTemplates(config) {
-	if (config.debug) consola.level = Number.MAX_SAFE_INTEGER;
-	if (config.silent) consola.level = 0;
+	if (config.debug) consola$1.level = Number.MAX_SAFE_INTEGER;
+	if (config.silent) consola$1.level = 0;
 	return await new TemplatesGenProcess(config).start();
 }
 
 //#endregion
 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-BO-5CKCm.mjs.map
+//# sourceMappingURL=generate-templates-BaT2BiRR.mjs.map