swagger-typescript-api 13.1.3 → 13.2.0

package/dist/src-BzzyC03Z.js

@@ -1,3066 +0,0 @@
-import { __export } from "./chunk-Cl8Af3a2.js";
-import { consola } from "consola";
-import lodash from "lodash";
-import * as typescript$3 from "typescript";
-import * as typescript$2 from "typescript";
-import * as typescript$1 from "typescript";
-import * as typescript from "typescript";
-import * as path$3 from "node:path";
-import * as path$2 from "node:path";
-import * as path$1 from "node:path";
-import path from "node:path";
-import { Biome, Distribution } from "@biomejs/js-api";
-import * as nanoid$1 from "nanoid";
-import * as nanoid from "nanoid";
-import * as yaml from "js-yaml";
-import * as swagger2openapi from "swagger2openapi";
-import * as url$2 from "node:url";
-import * as url$1 from "node:url";
-import url from "node:url";
-import * as Eta from "eta";
-import * as fs from "node:fs";
-
-//#region src/code-formatter.ts
-var CodeFormatter = class {
-	constructor(config) {
-		this.removeUnusedImports = (content) => {
-			const tempFileName = "file.ts";
-			const host = new TsLanguageServiceHost(tempFileName, content);
-			const languageService = typescript$3.createLanguageService(host);
-			const fileTextChanges = languageService.organizeImports({
-				type: "file",
-				fileName: tempFileName
-			}, { newLineCharacter: typescript$3.sys.newLine }, void 0)[0];
-			if (fileTextChanges?.textChanges.length) return fileTextChanges.textChanges.reduceRight((content$1, { span, newText }) => `${content$1.slice(0, span.start)}${newText}${content$1.slice(span.start + span.length)}`, content);
-			return content;
-		};
-		this.format = async (content) => {
-			const biome = await Biome.create({ distribution: Distribution.NODE });
-			biome.applyConfiguration({
-				files: { maxSize: Number.MAX_SAFE_INTEGER },
-				formatter: { indentStyle: "space" }
-			});
-			const formatted = biome.formatContent(content, { filePath: path$3.format({
-				name: nanoid$1.nanoid(),
-				ext: "ts"
-			}) });
-			return formatted.content;
-		};
-		this.formatCode = async (code, { removeUnusedImports = true, format = true } = {}) => {
-			if (removeUnusedImports) code = this.removeUnusedImports(code);
-			if (format) code = await this.format(code);
-			return code;
-		};
-		this.config = config;
-	}
-};
-var TsLanguageServiceHost = class {
-	constructor(fileName, content) {
-		this.fileName = fileName;
-		this.content = content;
-		const tsconfig = typescript$3.findConfigFile(fileName, typescript$3.sys.fileExists);
-		this.compilerOptions = tsconfig ? typescript$3.convertCompilerOptionsFromJson(typescript$3.readConfigFile(tsconfig, typescript$3.sys.readFile).config.compilerOptions, "").options : typescript$3.getDefaultCompilerOptions();
-	}
-	getNewLine() {
-		return "newLine" in typescript$3.sys ? typescript$3.sys.newLine : "\n";
-	}
-	getScriptFileNames() {
-		return [this.fileName];
-	}
-	getCompilationSettings() {
-		return this.compilerOptions;
-	}
-	getDefaultLibFileName() {
-		return typescript$3.getDefaultLibFileName(this.getCompilationSettings());
-	}
-	getCurrentDirectory() {
-		return process.cwd();
-	}
-	getScriptVersion() {
-		return typescript$3.version;
-	}
-	getScriptSnapshot() {
-		return typescript$3.ScriptSnapshot.fromString(this.content);
-	}
-	readFile(fileName, encoding) {
-		if (fileName === this.fileName) return this.content;
-		return typescript$3.sys.readFile(fileName, encoding);
-	}
-	fileExists(path$4) {
-		return typescript$3.sys.fileExists(path$4);
-	}
-};
-
-//#endregion
-//#region src/util/name-resolver.ts
-var NameResolver = class {
-	constructor(config, reservedNames, getFallbackName) {
-		this.reservedNames = [];
-		this.config = config;
-		this.getFallbackName = getFallbackName;
-		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);
-	}
-	unreserve(names) {
-		this.reservedNames.filter((reservedName) => !names.some((name$1) => name$1 === reservedName));
-	}
-	isReserved(name$1) {
-		return this.reservedNames.some((reservedName) => reservedName === name$1);
-	}
-	resolve(variants, resolver, extras, shouldReserve = true) {
-		if (typeof resolver === "function") {
-			let usageName = null;
-			while (usageName === null) {
-				const variant = resolver(variants, extras);
-				if (variant === void 0) {
-					consola.warn("unable to resolve name. current reserved names: ", ...this.reservedNames);
-					return null;
-				}
-				if (!shouldReserve || !this.isReserved(variant)) usageName = variant;
-			}
-			shouldReserve && this.reserve([usageName]);
-			return usageName;
-		}
-		if (Array.isArray(variants)) {
-			let usageName = null;
-			const uniqVariants = lodash.uniq(lodash.compact(variants));
-			for (const variant of uniqVariants) if (!usageName && (!shouldReserve || !this.isReserved(variant))) usageName = variant;
-			if (usageName) {
-				shouldReserve && this.reserve([usageName]);
-				return usageName;
-			}
-			consola.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);
-		return null;
-	}
-};
-
-//#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));
-};
-
-//#endregion
-//#region src/component-type-name-resolver.ts
-var ComponentTypeNameResolver = class extends NameResolver {
-	constructor(config, reservedNames) {
-		super(config, reservedNames, (variants) => {
-			const randomVariant = variants[getRandomInt(0, variants.length - 1)];
-			if (randomVariant) {
-				if (!this.countersByVariant.has(randomVariant)) this.countersByVariant.set(randomVariant, 0);
-				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);
-				return dirtyResolvedName;
-			}
-			const fallbackName = `${this.config.componentTypeNameResolver}${this.fallbackNameCounter++}`;
-			consola.debug("generated fallback type name for component - ", fallbackName);
-			return fallbackName;
-		});
-		this.counter = 1;
-		this.fallbackNameCounter = 1;
-		this.countersByVariant = new Map();
-	}
-};
-
-//#endregion
-//#region package.json
-var name = "swagger-typescript-api";
-var version = "13.1.3";
-var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
-var homepage = "https://github.com/acacode/swagger-typescript-api";
-var bugs = "https://github.com/acacode/swagger-typescript-api/issues";
-var repository = "github:acacode/swagger-typescript-api";
-var license = "MIT";
-var author = "Sergey Volkov <js2me@outlook.com>";
-var maintainers = ["Sora Morimoto <sora@morimoto.io>"];
-var type = "module";
-var exports = { ".": {
-	"import": {
-		"types": "./dist/lib.d.ts",
-		"default": "./dist/lib.js"
-	},
-	"require": {
-		"types": "./dist/lib.d.cts",
-		"default": "./dist/lib.cjs"
-	}
-} };
-var main = "./dist/lib.cjs";
-var module = "./dist/lib.js";
-var types = "./dist/lib.d.cts";
-var bin = {
-	"sta": "./dist/cli.js",
-	"swagger-typescript-api": "./dist/cli.js"
-};
-var files = ["dist", "templates"];
-var scripts = {
-	"build": "tsdown",
-	"cli:help": "node index.js -h",
-	"cli:json": "node index.js -r -d -p ./swagger-test-cli.json -n swagger-test-cli.ts",
-	"cli:yaml": "node index.js -r -d -p ./swagger-test-cli.yaml -n swagger-test-cli.ts",
-	"format": "biome format --write .",
-	"format:check": "biome format .",
-	"lint": "biome check",
-	"prepack": "tsdown",
-	"test": "vitest run",
-	"typedoc": "typedoc"
-};
-var dependencies = {
-	"@biomejs/js-api": "^0.7.1",
-	"@biomejs/wasm-nodejs": "^1.9.4",
-	"@types/swagger-schema-official": "^2.0.25",
-	"c12": "^3.0.3",
-	"citty": "^0.1.6",
-	"consola": "^3.4.2",
-	"eta": "^2.2.0",
-	"js-yaml": "^4.1.0",
-	"lodash": "^4.17.21",
-	"nanoid": "^5.1.5",
-	"swagger-schema-official": "2.0.0-bab6bed",
-	"swagger2openapi": "^7.0.8",
-	"typescript": "~5.8.3"
-};
-var devDependencies = {
-	"@biomejs/biome": "2.0.0-beta.2",
-	"@changesets/changelog-github": "0.5.1",
-	"@changesets/cli": "2.29.2",
-	"@tsconfig/node18": "18.2.4",
-	"@tsconfig/strictest": "2.0.5",
-	"@types/js-yaml": "4.0.9",
-	"@types/lodash": "4.17.16",
-	"@types/node": "22.15.3",
-	"@types/swagger2openapi": "7.0.4",
-	"axios": "1.9.0",
-	"openapi-types": "12.1.3",
-	"tsdown": "0.10.2",
-	"typedoc": "0.28.3",
-	"vitest": "3.1.2"
-};
-var packageManager = "yarn@4.9.1";
-var engines = { "node": ">=18.0.0" };
-var publishConfig = {
-	"access": "public",
-	"provenance": true,
-	"registry": "https://registry.npmjs.org"
-};
-var typedocOptions = {
-	"entryPoints": ["src/index.ts"],
-	"skipErrorChecking": true
-};
-var package_default = {
-	name,
-	version,
-	description,
-	homepage,
-	bugs,
-	repository,
-	license,
-	author,
-	maintainers,
-	type,
-	exports,
-	main,
-	module,
-	types,
-	bin,
-	files,
-	scripts,
-	dependencies,
-	devDependencies,
-	packageManager,
-	engines,
-	publishConfig,
-	typedocOptions
-};
-
-//#endregion
-//#region src/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
-	DEFAULT_BODY_ARG_NAME: () => DEFAULT_BODY_ARG_NAME,
-	FILE_PREFIX: () => FILE_PREFIX$1,
-	HTTP_CLIENT: () => HTTP_CLIENT,
-	PROJECT_VERSION: () => PROJECT_VERSION,
-	RESERVED_BODY_ARG_NAMES: () => RESERVED_BODY_ARG_NAMES,
-	RESERVED_HEADER_ARG_NAMES: () => RESERVED_HEADER_ARG_NAMES,
-	RESERVED_PATH_ARG_NAMES: () => RESERVED_PATH_ARG_NAMES,
-	RESERVED_QUERY_ARG_NAMES: () => RESERVED_QUERY_ARG_NAMES,
-	RESERVED_REQ_PARAMS_ARG_NAMES: () => RESERVED_REQ_PARAMS_ARG_NAMES,
-	SCHEMA_TYPES: () => SCHEMA_TYPES
-});
-const DEFAULT_BODY_ARG_NAME = "data";
-const FILE_PREFIX$1 = `/* eslint-disable */
-/* tslint:disable */
-// @ts-nocheck
-/*
- * ---------------------------------------------------------------
- * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
- * ##                                                           ##
- * ## AUTHOR: acacode                                           ##
- * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
- * ---------------------------------------------------------------
- */
-
-`;
-const HTTP_CLIENT = {
-	FETCH: "fetch",
-	AXIOS: "axios"
-};
-const PROJECT_VERSION = package_default.version;
-const RESERVED_BODY_ARG_NAMES = [
-	"data",
-	"body",
-	"reqBody"
-];
-const RESERVED_HEADER_ARG_NAMES = ["headers", "headersParams"];
-const RESERVED_PATH_ARG_NAMES = ["path", "pathParams"];
-const RESERVED_QUERY_ARG_NAMES = [
-	"query",
-	"queryParams",
-	"queryArg"
-];
-const RESERVED_REQ_PARAMS_ARG_NAMES = [
-	"params",
-	"requestParams",
-	"reqParams",
-	"httpParams"
-];
-const SCHEMA_TYPES = {
-	ARRAY: "array",
-	OBJECT: "object",
-	ENUM: "enum",
-	REF: "$ref",
-	PRIMITIVE: "primitive",
-	COMPLEX: "complex",
-	DISCRIMINATOR: "discriminator",
-	COMPLEX_ONE_OF: "oneOf",
-	COMPLEX_ANY_OF: "anyOf",
-	COMPLEX_ALL_OF: "allOf",
-	COMPLEX_NOT: "not",
-	COMPLEX_UNKNOWN: "__unknown"
-};
-
-//#endregion
-//#region src/util/object-assign.ts
-const objectAssign = (target, updater) => {
-	if (!updater) return;
-	const update = typeof updater === "function" ? updater(target) : updater;
-	const undefinedKeys = lodash.map(update, (value, key) => value === void 0 && key).filter((key) => typeof key === "string");
-	Object.assign(target, lodash.merge(target, update));
-	for (const key of undefinedKeys) target[key] = void 0;
-};
-
-//#endregion
-//#region src/configuration.ts
-const TsKeyword = {
-	Number: "number",
-	String: "string",
-	Boolean: "boolean",
-	Any: "any",
-	Void: "void",
-	Unknown: "unknown",
-	Null: "null",
-	Undefined: "undefined",
-	Object: "object",
-	File: "File",
-	Date: "Date",
-	Type: "type",
-	Enum: "enum",
-	Interface: "interface",
-	Array: "Array",
-	Record: "Record",
-	Intersection: "&",
-	Union: "|"
-};
-const TsCodeGenKeyword = { UtilRequiredKeys: "UtilRequiredKeys" };
-var CodeGenConfig = class {
-	constructor({ codeGenConstructs, primitiveTypeConstructs, constants, templateInfos, hooks,...otherConfig }) {
-		this.version = PROJECT_VERSION;
-		this.templates = "";
-		this.generateResponses = false;
-		this.defaultResponseAsSuccess = false;
-		this.generateRouteTypes = false;
-		this.generateClient = true;
-		this.generateUnionEnums = false;
-		this.addReadonly = false;
-		this.enumNamesAsValues = false;
-		this.swaggerSchema = null;
-		this.originalSchema = null;
-		this.componentsMap = {};
-		this.convertedFromSwagger2 = false;
-		this.moduleNameIndex = 0;
-		this.moduleNameFirstTag = false;
-		this.extractRequestParams = false;
-		this.extractRequestBody = false;
-		this.extractResponseBody = false;
-		this.extractResponseError = false;
-		this.extractResponses = false;
-		this.extractEnums = false;
-		this.fileNames = {
-			dataContracts: "data-contracts",
-			routeTypes: "route-types",
-			httpClient: "http-client",
-			outOfModuleApi: "Common"
-		};
-		this.routeNameDuplicatesMap = new Map();
-		this.hooks = {
-			onPreBuildRoutePath: (_routePath) => void 0,
-			onBuildRoutePath: (_routeData) => void 0,
-			onInsertPathParam: (_pathParam) => void 0,
-			onCreateComponent: (schema) => schema,
-			onPreParseSchema: (_originalSchema, _typeName, _schemaType) => void 0,
-			onParseSchema: (_originalSchema, parsedSchema) => parsedSchema,
-			onCreateRoute: (routeData) => routeData,
-			onInit: (config, _codeGenProcess) => config,
-			onPrepareConfig: (apiConfig) => apiConfig,
-			onCreateRequestParams: (_rawType) => {},
-			onCreateRouteName: () => {},
-			onFormatTypeName: (_typeName, _rawTypeName, _schemaType) => {},
-			onFormatRouteName: (_routeInfo, _templateRouteName) => {}
-		};
-		this.singleHttpClient = false;
-		this.httpClientType = HTTP_CLIENT.FETCH;
-		this.unwrapResponseData = false;
-		this.disableThrowOnError = false;
-		this.sortTypes = false;
-		this.sortRoutes = false;
-		this.templatePaths = {
-			base: "",
-			default: "",
-			modular: "",
-			original: "",
-			custom: ""
-		};
-		this.templatesToRender = {
-			api: "",
-			dataContracts: "",
-			dataContractJsDoc: "",
-			interfaceDataContract: "",
-			typeDataContract: "",
-			enumDataContract: "",
-			objectFieldJsDoc: "",
-			httpClient: "",
-			routeTypes: "",
-			routeName: ""
-		};
-		this.schemaParsers = {};
-		this.toJS = false;
-		this.silent = false;
-		this.typePrefix = "";
-		this.typeSuffix = "";
-		this.enumKeyPrefix = "";
-		this.enumKeySuffix = "";
-		this.patch = false;
-		this.apiClassName = "Api";
-		this.debug = false;
-		this.anotherArrayType = false;
-		this.internalTemplateOptions = { addUtilRequiredKeysType: false };
-		this.extraTemplates = [];
-		this.input = "";
-		this.modular = false;
-		this.output = "";
-		this.url = "";
-		this.cleanOutput = false;
-		this.spec = null;
-		this.fileName = "Api.ts";
-		this.requestOptions = null;
-		this.jsPrimitiveTypes = [];
-		this.jsEmptyTypes = [];
-		this.fixInvalidTypeNamePrefix = "Type";
-		this.fixInvalidEnumKeyPrefix = "Value";
-		this.enumKeyResolverName = "Value";
-		this.typeNameResolverName = "ComponentType";
-		this.specificArgNameResolverName = "arg";
-		this.successResponseStatusRange = [200, 299];
-		this.extractingOptions = {
-			requestBodySuffix: [
-				"Payload",
-				"Body",
-				"Input"
-			],
-			requestParamsSuffix: ["Params"],
-			responseBodySuffix: [
-				"Data",
-				"Result",
-				"Output"
-			],
-			responseErrorSuffix: [
-				"Error",
-				"Fail",
-				"Fails",
-				"ErrorData",
-				"HttpError",
-				"BadResponse"
-			],
-			enumSuffix: ["Enum"],
-			discriminatorMappingSuffix: [
-				"Mapping",
-				"Mapper",
-				"MapType"
-			],
-			discriminatorAbstractPrefix: [
-				"Base",
-				"Abstract",
-				"Discriminator",
-				"Internal",
-				"Polymorph"
-			]
-		};
-		this.compilerTsConfig = {
-			module: typescript$2.ModuleKind.ESNext,
-			noImplicitReturns: true,
-			alwaysStrict: true,
-			target: typescript$2.ScriptTarget.ESNext,
-			declaration: true,
-			noImplicitAny: false,
-			sourceMap: false,
-			removeComments: false,
-			disableSizeLimit: true,
-			esModuleInterop: true,
-			emitDecoratorMetadata: true,
-			skipLibCheck: true
-		};
-		this.Ts = {
-			Keyword: structuredClone(TsKeyword),
-			CodeGenKeyword: structuredClone(TsCodeGenKeyword),
-			ArrayType: (content) => {
-				if (this.anotherArrayType) return this.Ts.TypeWithGeneric(this.Ts.Keyword.Array, [content]);
-				return `${this.Ts.ExpressionGroup(content)}[]`;
-			},
-			StringValue: (content) => `"${content}"`,
-			BooleanValue: (content) => `${content}`,
-			NumberValue: (content) => `${content}`,
-			NullValue: () => "null",
-			UnionType: (contents) => lodash.join(lodash.uniq(contents), ` ${this.Ts.Keyword.Union} `),
-			ExpressionGroup: (content) => content ? `(${content})` : "",
-			IntersectionType: (contents) => lodash.join(lodash.uniq(contents), ` ${this.Ts.Keyword.Intersection} `),
-			RecordType: (key, value) => this.Ts.TypeWithGeneric(this.Ts.Keyword.Record, [key, value]),
-			TypeField: ({ readonly, key, optional, value }) => lodash.compact([
-				readonly && "readonly ",
-				key,
-				optional && "?",
-				": ",
-				value
-			]).join(""),
-			InterfaceDynamicField: (key, value) => `[key: ${key}]: ${value}`,
-			EnumUsageKey: (enumStruct, key) => `${enumStruct}.${key}`,
-			EnumField: (key, value) => `${key} = ${value}`,
-			EnumFieldsWrapper: (contents) => lodash.map(contents, ({ key, value }) => `  ${this.Ts.EnumField(key, value)}`).join(",\n"),
-			ObjectWrapper: (content) => `{\n${content}\n}`,
-			MultilineComment: (contents, formatFn) => [...contents.length === 1 ? [`/** ${contents[0]} */`] : [
-				"/**",
-				...contents.map((content) => ` * ${content}`),
-				" */"
-			]].map((part) => `${formatFn ? formatFn(part) : part}\n`),
-			TypeWithGeneric: (typeName, genericArgs) => {
-				return `${typeName}${genericArgs.length ? `<${genericArgs.join(",")}>` : ""}`;
-			},
-			Tuple: (values) => {
-				return `[${values.join(", ")}]`;
-			}
-		};
-		this.primitiveTypes = {
-			integer: () => this.Ts.Keyword.Number,
-			number: () => this.Ts.Keyword.Number,
-			boolean: () => this.Ts.Keyword.Boolean,
-			object: () => this.Ts.Keyword.Object,
-			file: () => this.Ts.Keyword.File,
-			string: {
-				$default: this.Ts.Keyword.String,
-				binary: () => this.Ts.Keyword.File,
-				file: () => this.Ts.Keyword.File,
-				"date-time": () => this.Ts.Keyword.String,
-				time: () => this.Ts.Keyword.String,
-				date: () => this.Ts.Keyword.String,
-				duration: () => this.Ts.Keyword.String,
-				email: () => this.Ts.Keyword.String,
-				"idn-email": () => this.Ts.Keyword.String,
-				"idn-hostname": () => this.Ts.Keyword.String,
-				ipv4: () => this.Ts.Keyword.String,
-				ipv6: () => this.Ts.Keyword.String,
-				uuid: () => this.Ts.Keyword.String,
-				uri: () => this.Ts.Keyword.String,
-				"uri-reference": () => this.Ts.Keyword.String,
-				"uri-template": () => this.Ts.Keyword.String,
-				"json-pointer": () => this.Ts.Keyword.String,
-				"relative-json-pointer": () => this.Ts.Keyword.String,
-				regex: () => this.Ts.Keyword.String
-			}
-		};
-		this.templateInfos = [
-			{
-				name: "api",
-				fileName: "api"
-			},
-			{
-				name: "dataContracts",
-				fileName: "data-contracts"
-			},
-			{
-				name: "dataContractJsDoc",
-				fileName: "data-contract-jsdoc"
-			},
-			{
-				name: "interfaceDataContract",
-				fileName: "interface-data-contract"
-			},
-			{
-				name: "typeDataContract",
-				fileName: "type-data-contract"
-			},
-			{
-				name: "enumDataContract",
-				fileName: "enum-data-contract"
-			},
-			{
-				name: "objectFieldJsDoc",
-				fileName: "object-field-jsdoc"
-			},
-			{
-				name: "httpClient",
-				fileName: "http-client"
-			},
-			{
-				name: "routeTypes",
-				fileName: "route-types"
-			},
-			{
-				name: "routeName",
-				fileName: "route-name"
-			}
-		];
-		this.templateExtensions = [".eta", ".ejs"];
-		this.update = (update) => {
-			objectAssign(this, update);
-		};
-		objectAssign(this.Ts, codeGenConstructs);
-		objectAssign(this.primitiveTypes, primitiveTypeConstructs);
-		this.defaultResponseType = this.Ts.Keyword.Void;
-		this.update({
-			...otherConfig,
-			hooks: lodash.merge(this.hooks, hooks || {}),
-			constants: {
-				...constants_exports,
-				...constants
-			},
-			templateInfos: templateInfos || this.templateInfos
-		});
-		this.jsPrimitiveTypes = [
-			this.Ts.Keyword.Number,
-			this.Ts.Keyword.String,
-			this.Ts.Keyword.Boolean
-		];
-		this.jsEmptyTypes = [this.Ts.Keyword.Null, this.Ts.Keyword.Undefined];
-		this.componentTypeNameResolver = new ComponentTypeNameResolver(this, []);
-	}
-};
-
-//#endregion
-//#region src/schema-components-map.ts
-var SchemaComponentsMap = class {
-	constructor(config) {
-		this._data = [];
-		this.createRef = (paths) => {
-			return ["#", ...paths].join("/");
-		};
-		this.parseRef = (ref) => {
-			return ref.split("/");
-		};
-		this.config = config;
-	}
-	clear() {
-		this._data = [];
-	}
-	createComponent($ref, rawTypeData) {
-		const parsed = this.parseRef($ref);
-		const typeName = parsed[parsed.length - 1];
-		const componentName = parsed[parsed.length - 2];
-		const componentSchema = {
-			$ref,
-			typeName,
-			rawTypeData,
-			componentName,
-			typeData: null
-		};
-		const usageComponent = this.config.hooks.onCreateComponent(componentSchema) || componentSchema;
-		const refIndex = this._data.findIndex((c) => c.$ref === $ref);
-		if (refIndex === -1) this._data.push(usageComponent);
-		else this._data[refIndex] = usageComponent;
-		return usageComponent;
-	}
-	getComponents() {
-		return this._data;
-	}
-	filter(...componentNames) {
-		return this._data.filter((it) => componentNames.some((componentName) => it.$ref.startsWith(`#/components/${componentName}`)));
-	}
-	get($ref) {
-		return this._data.find((c) => c.$ref === $ref) || null;
-	}
-	enumsFirst() {
-		this._data.sort((a, b) => {
-			if (Object.keys(a.rawTypeData || {}).includes("enum")) return -1;
-			if (Object.keys(b.rawTypeData || {}).includes("enum")) return 1;
-			return 0;
-		});
-	}
-};
-
-//#endregion
-//#region src/schema-parser/schema-formatters.ts
-var SchemaFormatters = class {
-	constructor(schemaParser) {
-		this.base = {
-			[SCHEMA_TYPES.ENUM]: (parsedSchema) => {
-				if (this.config.generateUnionEnums) return {
-					...parsedSchema,
-					$content: parsedSchema.content,
-					content: this.config.Ts.UnionType(parsedSchema.content.map(({ value }) => value))
-				};
-				return {
-					...parsedSchema,
-					$content: parsedSchema.content,
-					content: this.config.Ts.EnumFieldsWrapper(parsedSchema.content)
-				};
-			},
-			[SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
-				if (parsedSchema.nullable) return this.inline[SCHEMA_TYPES.OBJECT](parsedSchema);
-				return {
-					...parsedSchema,
-					$content: parsedSchema.content,
-					content: this.formatObjectContent(parsedSchema.content)
-				};
-			},
-			[SCHEMA_TYPES.PRIMITIVE]: (parsedSchema) => {
-				return {
-					...parsedSchema,
-					$content: parsedSchema.content
-				};
-			}
-		};
-		this.inline = {
-			[SCHEMA_TYPES.ENUM]: (parsedSchema) => {
-				return {
-					...parsedSchema,
-					content: parsedSchema.$ref ? parsedSchema.typeName : this.config.Ts.UnionType(lodash.compact([...parsedSchema.content.map(({ value }) => `${value}`), parsedSchema.nullable && this.config.Ts.Keyword.Null])) || this.config.Ts.Keyword.Any
-				};
-			},
-			[SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
-				if (typeof parsedSchema.content === "string") return {
-					...parsedSchema,
-					typeIdentifier: this.config.Ts.Keyword.Type,
-					content: this.schemaUtils.safeAddNullToType(parsedSchema.content)
-				};
-				return {
-					...parsedSchema,
-					typeIdentifier: this.config.Ts.Keyword.Type,
-					content: this.schemaUtils.safeAddNullToType(parsedSchema, parsedSchema.content.length ? this.config.Ts.ObjectWrapper(this.formatObjectContent(parsedSchema.content)) : this.config.Ts.RecordType(this.config.Ts.Keyword.String, this.config.Ts.Keyword.Any))
-				};
-			}
-		};
-		this.formatSchema = (parsedSchema, formatType = "base") => {
-			const schemaType = lodash.get(parsedSchema, ["schemaType"]) || lodash.get(parsedSchema, ["$parsed", "schemaType"]);
-			const formatterFn = lodash.get(this, [formatType, schemaType]);
-			return formatterFn?.(parsedSchema) || parsedSchema;
-		};
-		this.formatDescription = (description$1, inline) => {
-			if (!description$1) return "";
-			const hasMultipleLines = description$1.includes("\n");
-			if (!hasMultipleLines) 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, "");
-		};
-		this.formatObjectContent = (content) => {
-			const fields = [];
-			for (const part of content) {
-				const extraSpace = "  ";
-				const result = `${extraSpace}${part.field},\n`;
-				const renderedJsDoc = this.templatesWorker.renderTemplate(this.config.templatesToRender.dataContractJsDoc, { data: part });
-				const routeNameFromTemplate = renderedJsDoc.split("\n").map((c) => `${extraSpace}${c}`).join("\n");
-				if (routeNameFromTemplate) fields.push(`${routeNameFromTemplate}${result}`);
-				else fields.push(`${result}`);
-			}
-			return fields.join("");
-		};
-		this.config = schemaParser.config;
-		this.schemaUtils = schemaParser.schemaUtils;
-		this.templatesWorker = schemaParser.templatesWorker;
-	}
-};
-
-//#endregion
-//#region src/util/sort-by-property.ts
-const sortByProperty = (propertyName) => (o1, o2) => {
-	if (o1[propertyName] > o2[propertyName]) return 1;
-	if (o1[propertyName] < o2[propertyName]) return -1;
-	return 0;
-};
-
-//#endregion
-//#region src/schema-parser/mono-schema-parser.ts
-var MonoSchemaParser = class {
-	constructor(schemaParser, schema, typeName = null, schemaPath = []) {
-		this.buildTypeNameFromPath = () => {
-			return this.schemaUtils.buildTypeNameFromPath(this.schemaPath);
-		};
-		this.schemaParser = schemaParser;
-		this.schemaParserFabric = schemaParser.schemaParserFabric;
-		this.schema = schema;
-		this.typeName = typeName;
-		this.typeNameFormatter = schemaParser.typeNameFormatter;
-		this.schemaPath = schemaPath;
-		this.schemaComponentsMap = this.schemaParser.schemaComponentsMap;
-		this.schemaUtils = this.schemaParser.schemaUtils;
-		this.config = this.schemaParser.config;
-		this.schemaFormatters = this.schemaParser.schemaFormatters;
-	}
-	parse() {
-		throw new Error("not implemented");
-	}
-};
-
-//#endregion
-//#region src/schema-parser/base-schema-parsers/array.ts
-var ArraySchemaParser = class extends MonoSchemaParser {
-	parse() {
-		let contentType;
-		const { type: type$1, description: description$1, items } = this.schema || {};
-		if (Array.isArray(items) && type$1 === SCHEMA_TYPES.ARRAY) {
-			const tupleContent = [];
-			for (const item of items) tupleContent.push(this.schemaParserFabric.createSchemaParser({
-				schema: item,
-				schemaPath: this.schemaPath
-			}).getInlineParseContent());
-			contentType = this.config.Ts.Tuple(tupleContent);
-		} else {
-			const content = this.schemaParserFabric.createSchemaParser({
-				schema: items,
-				schemaPath: this.schemaPath
-			}).getInlineParseContent();
-			contentType = this.config.Ts.ArrayType(content);
-		}
-		return {
-			...typeof this.schema === "object" ? this.schema : {},
-			$schemaPath: this.schemaPath.slice(),
-			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.PRIMITIVE,
-			type: SCHEMA_TYPES.PRIMITIVE,
-			typeIdentifier: this.config.Ts.Keyword.Type,
-			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(description$1),
-			content: this.schemaUtils.safeAddNullToType(this.schema, contentType)
-		};
-	}
-};
-
-//#endregion
-//#region src/schema-parser/base-schema-parsers/complex.ts
-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 complexSchemaContent = this.schemaParser._complexSchemaParsers[complexType](this.schema);
-		return {
-			...typeof this.schema === "object" ? this.schema : {},
-			$schemaPath: this.schemaPath.slice(),
-			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.COMPLEX,
-			type: SCHEMA_TYPES.PRIMITIVE,
-			typeIdentifier: this.config.Ts.Keyword.Type,
-			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(this.schema.description || lodash.compact(lodash.map(this.schema[complexType], "description"))[0] || ""),
-			content: this.config.Ts.IntersectionType(lodash.compact([this.config.Ts.ExpressionGroup(complexSchemaContent), this.schemaUtils.getInternalSchemaType(simpleSchema) === SCHEMA_TYPES.OBJECT && this.config.Ts.ExpressionGroup(this.schemaParserFabric.createSchemaParser({
-				schema: simpleSchema,
-				schemaPath: this.schemaPath
-			}).getInlineParseContent())])) || this.config.Ts.Keyword.Any
-		};
-	}
-};
-
-//#endregion
-//#region src/schema-parser/base-schema-parsers/discriminator.ts
-var DiscriminatorSchemaParser = class extends MonoSchemaParser {
-	constructor(..._args) {
-		super(..._args);
-		this.createDiscriminatorSchema = ({ skipMappingType, abstractSchemaStruct }) => {
-			const ts = this.config.Ts;
-			const refPath = this.schemaComponentsMap.createRef([
-				"components",
-				"schemas",
-				this.typeName
-			]);
-			const { discriminator } = this.schema;
-			const mappingEntries = lodash.entries(discriminator.mapping);
-			const ableToCreateMappingType = !skipMappingType && !!(abstractSchemaStruct?.typeName && mappingEntries.length);
-			const mappingContents = [];
-			let mappingTypeName;
-			/** { mapping_key: SchemaEnum.MappingKey, ... } */
-			const mappingPropertySchemaEnumKeysMap = this.createMappingPropertySchemaEnumKeys({
-				abstractSchemaStruct,
-				discPropertyName: discriminator.propertyName
-			});
-			if (ableToCreateMappingType) {
-				const rawTypeName = `${abstractSchemaStruct.typeName}_${discriminator.propertyName}`;
-				const generatedTypeName = this.schemaUtils.resolveTypeName(rawTypeName, {
-					suffixes: this.config.extractingOptions.discriminatorMappingSuffix,
-					resolver: this.config.extractingOptions.discriminatorMappingNameResolver
-				});
-				const content$1 = ts.IntersectionType([ts.ObjectWrapper(ts.TypeField({
-					key: ts.StringValue(discriminator.propertyName),
-					value: "Key"
-				})), "Type"]);
-				const component = this.schemaParserFabric.createParsedComponent({
-					typeName: generatedTypeName,
-					schema: {
-						type: "object",
-						properties: {},
-						genericArgs: [{ name: "Key" }, { name: "Type" }],
-						internal: true
-					}
-				});
-				component.typeData.content = content$1;
-				mappingTypeName = this.typeNameFormatter.format(component.typeName);
-			}
-			/** returns (GenericType<"mapping_key", MappingType>) or ({ discriminatorProperty: "mapping_key" } & MappingType) */
-			const createMappingContent = (mappingSchema, mappingKey) => {
-				const content$1 = this.schemaParserFabric.createSchemaParser({
-					schema: mappingSchema,
-					schemaPath: this.schemaPath
-				}).getInlineParseContent();
-				const mappingUsageKey = mappingPropertySchemaEnumKeysMap[mappingKey] || ts.StringValue(mappingKey);
-				if (ableToCreateMappingType) return ts.TypeWithGeneric(mappingTypeName, [mappingUsageKey, content$1]);
-				return ts.ExpressionGroup(ts.IntersectionType([ts.ObjectWrapper(ts.TypeField({
-					key: discriminator.propertyName,
-					value: mappingUsageKey
-				})), content$1]));
-			};
-			for (const [mappingKey, schema] of mappingEntries) {
-				const mappingSchema = typeof schema === "string" ? { $ref: schema } : schema;
-				this.mutateMappingDependentSchema({
-					discPropertyName: discriminator.propertyName,
-					abstractSchemaStruct,
-					mappingSchema,
-					refPath,
-					mappingPropertySchemaEnumKeysMap
-				});
-				mappingContents.push(createMappingContent(mappingSchema, mappingKey));
-			}
-			if (skipMappingType) return null;
-			const content = ts.ExpressionGroup(ts.UnionType(mappingContents));
-			return { content };
-		};
-		this.createMappingPropertySchemaEnumKeys = ({ abstractSchemaStruct, discPropertyName }) => {
-			const ts = this.config.Ts;
-			let mappingPropertySchemaEnumKeysMap = {};
-			let mappingPropertySchema = lodash.get(abstractSchemaStruct?.component?.rawTypeData, ["properties", discPropertyName]);
-			if (this.schemaUtils.isRefSchema(mappingPropertySchema)) mappingPropertySchema = this.schemaUtils.getSchemaRefType(mappingPropertySchema);
-			if (mappingPropertySchema?.rawTypeData?.$parsed?.type === SCHEMA_TYPES.ENUM) mappingPropertySchemaEnumKeysMap = lodash.reduce(mappingPropertySchema.rawTypeData.$parsed.enum, (acc, key, index) => {
-				const enumKey = mappingPropertySchema.rawTypeData.$parsed.content[index].key;
-				acc[key] = ts.EnumUsageKey(mappingPropertySchema.rawTypeData.$parsed.typeName, enumKey);
-				return acc;
-			}, {});
-			return mappingPropertySchemaEnumKeysMap;
-		};
-		this.mutateMappingDependentSchema = ({ discPropertyName, abstractSchemaStruct, mappingSchema, refPath, mappingPropertySchemaEnumKeysMap }) => {
-			const complexSchemaKeys = lodash.keys(this.schemaParser._complexSchemaParsers);
-			if (mappingSchema.$ref && abstractSchemaStruct?.component?.$ref) {
-				const mappingRefSchema = this.schemaUtils.getSchemaRefType(mappingSchema)?.rawTypeData;
-				if (mappingRefSchema) {
-					for (const schemaKey of complexSchemaKeys) if (Array.isArray(mappingRefSchema[schemaKey])) mappingRefSchema[schemaKey] = mappingRefSchema[schemaKey].map((schema) => {
-						if (schema.$ref === refPath) return {
-							...schema,
-							$ref: abstractSchemaStruct.component.$ref
-						};
-						if (this.schemaUtils.getInternalSchemaType(schema) === SCHEMA_TYPES.OBJECT) for (const schemaPropertyName in schema.properties) {
-							const schemaProperty = schema.properties[schemaPropertyName];
-							if (schemaPropertyName === discPropertyName && this.schemaUtils.getInternalSchemaType(schemaProperty) === SCHEMA_TYPES.ENUM && schemaProperty.enum.length === 1 && mappingPropertySchemaEnumKeysMap[schemaProperty.enum[0]]) schema.properties[schemaPropertyName] = this.schemaParserFabric.createSchema({ content: mappingPropertySchemaEnumKeysMap[schemaProperty.enum[0]] });
-						}
-						return schema;
-					});
-				}
-			}
-		};
-		this.createAbstractSchemaStruct = () => {
-			const { discriminator,...noDiscriminatorSchema } = this.schema;
-			const complexSchemaKeys = lodash.keys(this.schemaParser._complexSchemaParsers);
-			const schema = lodash.omit(structuredClone(noDiscriminatorSchema), complexSchemaKeys);
-			const schemaIsAny = this.schemaParserFabric.getInlineParseContent(structuredClone(schema)) === this.config.Ts.Keyword.Any;
-			const schemaIsEmpty = !lodash.keys(schema).length;
-			if (schemaIsEmpty || schemaIsAny) return null;
-			const typeName = this.schemaUtils.resolveTypeName(this.typeName, {
-				prefixes: this.config.extractingOptions.discriminatorAbstractPrefix,
-				resolver: this.config.extractingOptions.discriminatorAbstractResolver
-			});
-			const component = this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
-				"components",
-				"schemas",
-				typeName
-			]), {
-				...schema,
-				internal: true
-			});
-			const content = this.schemaParserFabric.createSchemaParser({
-				schema: component,
-				schemaPath: this.schemaPath
-			}).getInlineParseContent();
-			return {
-				typeName,
-				component,
-				content
-			};
-		};
-		this.createComplexSchemaStruct = () => {
-			const ts = this.config.Ts;
-			const complexType = this.schemaUtils.getComplexType(this.schema);
-			if (complexType === SCHEMA_TYPES.COMPLEX_UNKNOWN) return null;
-			return { content: ts.ExpressionGroup(this.schemaParser._complexSchemaParsers[complexType](this.schema)) };
-		};
-	}
-	parse() {
-		const ts = this.config.Ts;
-		const { discriminator,...noDiscriminatorSchema } = this.schema;
-		if (!discriminator.mapping) return this.schemaParserFabric.createSchemaParser({
-			schema: noDiscriminatorSchema,
-			typeName: this.typeName,
-			schemaPath: this.schemaPath
-		}).parseSchema();
-		const skipMappingType = false;
-		const abstractSchemaStruct = this.createAbstractSchemaStruct();
-		const discriminatorSchemaStruct = this.createDiscriminatorSchema({
-			skipMappingType,
-			abstractSchemaStruct
-		});
-		const schemaContent = ts.IntersectionType([abstractSchemaStruct?.content, discriminatorSchemaStruct?.content].filter(Boolean));
-		return {
-			...typeof this.schema === "object" ? this.schema : {},
-			$schemaPath: this.schemaPath.slice(),
-			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.COMPLEX,
-			type: SCHEMA_TYPES.PRIMITIVE,
-			typeIdentifier: ts.Keyword.Type,
-			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(this.schema.description),
-			content: schemaContent
-		};
-	}
-};
-
-//#endregion
-//#region src/schema-parser/util/enum-key-resolver.ts
-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);
-			return generatedVariant;
-		});
-		this.counter = 1;
-	}
-};
-
-//#endregion
-//#region src/schema-parser/base-schema-parsers/enum.ts
-var EnumSchemaParser = class extends MonoSchemaParser {
-	constructor(...args) {
-		super(...args);
-		this.extractEnum = (pathTypeName) => {
-			const generatedTypeName = this.schemaUtils.resolveTypeName(pathTypeName, {
-				suffixes: this.config.extractingOptions.enumSuffix,
-				resolver: this.config.extractingOptions.enumNameResolver
-			});
-			const customComponent = this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
-				"components",
-				"schemas",
-				generatedTypeName
-			]), { ...this.schema });
-			return this.schemaParserFabric.parseSchema(customComponent);
-		};
-		this.formatEnumKey = ({ key, value }) => {
-			let formatted;
-			if (key) formatted = this.typeNameFormatter.format(key, { type: "enum-key" });
-			if (!formatted) formatted = this.typeNameFormatter.format(`${value}`, { type: "enum-key" });
-			return this.enumKeyResolver.resolve([formatted]);
-		};
-		this.enumKeyResolver = new EnumKeyResolver(this.config, []);
-	}
-	parse() {
-		const pathTypeName = this.buildTypeNameFromPath();
-		if (this.config.extractEnums && !this.typeName && pathTypeName != null) return this.extractEnum(pathTypeName);
-		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) => ({
-			type: "array",
-			items: enumNames$1.map((enumName) => ({
-				type: "string",
-				enum: [enumName]
-			}))
-		})) }, this.typeName, this.schemaPath);
-		const keyType = this.schemaUtils.getSchemaType(this.schema);
-		const enumNames = this.schemaUtils.getEnumNames(this.schema);
-		let content = null;
-		const formatValue = (value) => {
-			if (value === null) return this.config.Ts.NullValue(value);
-			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "number" }))) return this.config.Ts.NumberValue(value);
-			if (keyType.includes(this.schemaUtils.getSchemaType({ type: "boolean" }))) return this.config.Ts.BooleanValue(value);
-			return this.config.Ts.StringValue(value);
-		};
-		if (Array.isArray(enumNames) && lodash.size(enumNames)) content = enumNames.map((enumName, index) => {
-			const enumValue = lodash.get(this.schema.enum, index);
-			const formattedKey = this.formatEnumKey({
-				key: enumName,
-				value: enumValue
-			});
-			if (this.config.enumNamesAsValues || enumValue === void 0) return {
-				key: formattedKey,
-				type: this.config.Ts.Keyword.String,
-				value: this.config.Ts.StringValue(enumName)
-			};
-			return {
-				key: formattedKey,
-				type: keyType,
-				value: formatValue(enumValue)
-			};
-		});
-		else content = this.schema.enum.map((value) => {
-			return {
-				key: this.formatEnumKey({ value }),
-				type: keyType,
-				value: formatValue(value)
-			};
-		});
-		return {
-			...typeof this.schema === "object" ? this.schema : {},
-			$ref,
-			typeName: this.typeName || $ref && refType.typeName || null,
-			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.ENUM,
-			type: SCHEMA_TYPES.ENUM,
-			keyType,
-			typeIdentifier: this.config.generateUnionEnums ? this.config.Ts.Keyword.Type : this.config.Ts.Keyword.Enum,
-			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(this.schema.description),
-			content
-		};
-	}
-};
-
-//#endregion
-//#region src/schema-parser/base-schema-parsers/object.ts
-var ObjectSchemaParser = class extends MonoSchemaParser {
-	constructor(..._args) {
-		super(..._args);
-		this.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 nullable = !!(rawTypeData.nullable || property.nullable);
-				const fieldName = this.typeNameFormatter.isValidName(name$1) ? name$1 : this.config.Ts.StringValue(name$1);
-				const fieldValue = this.schemaParserFabric.createSchemaParser({
-					schema: property,
-					schemaPath: [...this.schemaPath, name$1]
-				}).getInlineParseContent();
-				const readOnly = property.readOnly;
-				return {
-					...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] || "",
-					isRequired: required,
-					isNullable: nullable,
-					name: fieldName,
-					value: fieldValue,
-					field: this.config.Ts.TypeField({
-						readonly: readOnly && this.config.addReadonly,
-						optional: !required,
-						key: fieldName,
-						value: fieldValue
-					})
-				};
-			});
-			if (additionalProperties) propertiesContent.push({
-				$$raw: { additionalProperties },
-				description: "",
-				isRequired: false,
-				field: this.config.Ts.InterfaceDynamicField(this.config.Ts.Keyword.String, this.config.Ts.Keyword.Any)
-			});
-			return propertiesContent;
-		};
-	}
-	parse() {
-		const contentProperties = this.getObjectSchemaContent(this.schema);
-		return {
-			...typeof this.schema === "object" ? this.schema : {},
-			$schemaPath: this.schemaPath.slice(),
-			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.OBJECT,
-			type: SCHEMA_TYPES.OBJECT,
-			typeIdentifier: this.config.Ts.Keyword.Interface,
-			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(this.schema.description),
-			allFieldsAreOptional: !contentProperties.some((part) => part.isRequired),
-			content: contentProperties
-		};
-	}
-};
-
-//#endregion
-//#region src/schema-parser/base-schema-parsers/primitive.ts
-var PrimitiveSchemaParser = class extends MonoSchemaParser {
-	parse() {
-		let contentType = null;
-		const { additionalProperties, type: type$1, description: description$1, items } = this.schema || {};
-		if (type$1 === this.config.Ts.Keyword.Object && additionalProperties) {
-			const fieldType = typeof additionalProperties === "object" ? this.schemaParserFabric.createSchemaParser({
-				schema: additionalProperties,
-				schemaPath: this.schemaPath
-			}).getInlineParseContent() : this.config.Ts.Keyword.Any;
-			contentType = this.config.Ts.RecordType(this.config.Ts.Keyword.String, fieldType);
-		}
-		if (Array.isArray(type$1) && type$1.length) contentType = this.schemaParser._complexSchemaParsers.oneOf({
-			...typeof this.schema === "object" ? this.schema : {},
-			oneOf: type$1.map((type$2) => ({ type: type$2 }))
-		});
-		if (Array.isArray(items) && type$1 === SCHEMA_TYPES.ARRAY) contentType = this.config.Ts.Tuple(items.map((item) => this.schemaParserFabric.createSchemaParser({
-			schema: item,
-			schemaPath: this.schemaPath
-		}).getInlineParseContent()));
-		return {
-			...typeof this.schema === "object" ? this.schema : {},
-			$schemaPath: this.schemaPath.slice(),
-			$parsedSchema: true,
-			schemaType: SCHEMA_TYPES.PRIMITIVE,
-			type: SCHEMA_TYPES.PRIMITIVE,
-			typeIdentifier: this.config.Ts.Keyword.Type,
-			name: this.typeName,
-			description: this.schemaFormatters.formatDescription(description$1),
-			content: type$1 === this.config.Ts.Keyword.Null ? type$1 : contentType || this.schemaUtils.getSchemaType(this.schema)
-		};
-	}
-};
-
-//#endregion
-//#region src/schema-parser/complex-schema-parsers/all-of.ts
-var AllOfSchemaParser = class extends MonoSchemaParser {
-	parse() {
-		const ignoreTypes = [this.config.Ts.Keyword.Any];
-		const combined = this.schema.allOf.map((childSchema) => this.schemaParserFabric.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(this.schema, childSchema), null, this.schemaPath));
-		const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
-		const type$1 = this.config.Ts.IntersectionType(filtered);
-		return this.schemaUtils.safeAddNullToType(this.schema, type$1);
-	}
-};
-
-//#endregion
-//#region src/schema-parser/complex-schema-parsers/any-of.ts
-var AnyOfSchemaParser = class extends MonoSchemaParser {
-	parse() {
-		const ignoreTypes = [this.config.Ts.Keyword.Any];
-		const combined = this.schema.anyOf.map((childSchema) => this.schemaParserFabric.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(this.schema, childSchema), null, this.schemaPath));
-		const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
-		const type$1 = this.config.Ts.UnionType(filtered);
-		return this.schemaUtils.safeAddNullToType(this.schema, type$1);
-	}
-};
-
-//#endregion
-//#region src/schema-parser/complex-schema-parsers/not.ts
-var NotSchemaParser = class extends MonoSchemaParser {
-	parse() {
-		return this.config.Ts.Keyword.Any;
-	}
-};
-
-//#endregion
-//#region src/schema-parser/complex-schema-parsers/one-of.ts
-var OneOfSchemaParser = class extends MonoSchemaParser {
-	parse() {
-		const ignoreTypes = [this.config.Ts.Keyword.Any];
-		const combined = this.schema.oneOf.map((childSchema) => this.schemaParserFabric.getInlineParseContent(this.schemaUtils.makeAddRequiredToChildSchema(this.schema, childSchema), null, this.schemaPath));
-		const filtered = this.schemaUtils.filterSchemaContents(combined, (content) => !ignoreTypes.includes(content));
-		const type$1 = this.config.Ts.UnionType(filtered);
-		return this.schemaUtils.safeAddNullToType(this.schema, type$1);
-	}
-};
-
-//#endregion
-//#region src/schema-parser/schema-parser.ts
-var SchemaParser = class {
-	constructor(schemaParserFabric, { typeName, schema, schemaPath } = {}) {
-		this.schemaPath = [];
-		this._complexSchemaParsers = {
-			[SCHEMA_TYPES.COMPLEX_ONE_OF]: (schema$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.complexOneOf || OneOfSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, null, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.COMPLEX_ALL_OF]: (schema$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.complexAllOf || AllOfSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, null, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.COMPLEX_ANY_OF]: (schema$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.complexAnyOf || AnyOfSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, null, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.COMPLEX_NOT]: (schema$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.complexNot || NotSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, null, this.schemaPath);
-				return schemaParser.parse();
-			}
-		};
-		this._baseSchemaParsers = {
-			[SCHEMA_TYPES.ENUM]: (schema$1, typeName$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.enum || EnumSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, typeName$1, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.OBJECT]: (schema$1, typeName$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.object || ObjectSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, typeName$1, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.COMPLEX]: (schema$1, typeName$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.complex || ComplexSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, typeName$1, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.PRIMITIVE]: (schema$1, typeName$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.primitive || PrimitiveSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, typeName$1, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.DISCRIMINATOR]: (schema$1, typeName$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.discriminator || DiscriminatorSchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, typeName$1, this.schemaPath);
-				return schemaParser.parse();
-			},
-			[SCHEMA_TYPES.ARRAY]: (schema$1, typeName$1) => {
-				const SchemaParser$1 = this.config.schemaParsers.array || ArraySchemaParser;
-				const schemaParser = new SchemaParser$1(this, schema$1, typeName$1, this.schemaPath);
-				return schemaParser.parse();
-			}
-		};
-		this.parseSchema = () => {
-			if (!this.schema) return this._baseSchemaParsers[SCHEMA_TYPES.PRIMITIVE](null, this.typeName);
-			let schemaType = null;
-			let parsedSchema = null;
-			if (typeof this.schema === "string") return this.schema;
-			if (!this.schema.$parsed) {
-				if (!this.typeName && this.schemaUtils.isRefSchema(this.schema)) this.typeName = this.schemaUtils.getSchemaType(this.schema);
-				if (this.schema.items && !Array.isArray(this.schema.items) && !this.schema.type) this.schema.type = SCHEMA_TYPES.ARRAY;
-				if (Array.isArray(this.schema.enum) && this.schema.enum.length === 1 && this.schema.enum[0] == null) {
-					consola.debug("invalid enum schema", this.schema);
-					this.schema = { type: this.config.Ts.Keyword.Null };
-				}
-				if ("content" in this.schema && typeof this.schema.content === "object") {
-					const schema$1 = this.extractSchemaFromResponseStruct(this.schema);
-					const schemaParser = this.schemaParserFabric.createSchemaParser({
-						schema: schema$1,
-						typeName: this.typeName,
-						schemaPath: this.schemaPath
-					});
-					this.schema.$parsed = schemaParser.parseSchema();
-					return this.schema.$parsed;
-				}
-				schemaType = this.schemaUtils.getInternalSchemaType(this.schema);
-				this.schemaPath.push(this.typeName);
-				lodash.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"));
-			}
-			this.schemaPath.pop();
-			return this.schema.$parsed;
-		};
-		this.getInlineParseContent = () => {
-			const parsedSchema = this.parseSchema();
-			const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "inline");
-			return formattedSchema.content;
-		};
-		this.getParseContent = () => {
-			const parsedSchema = this.parseSchema();
-			const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "base");
-			return formattedSchema.content;
-		};
-		this.extractSchemaFromResponseStruct = (responseStruct) => {
-			const { content,...extras } = responseStruct;
-			const firstResponse = lodash.first(lodash.values(content));
-			const firstSchema = lodash.get(firstResponse, "schema");
-			if (!firstSchema) return;
-			return {
-				...extras,
-				...lodash.omit(firstResponse, "schema"),
-				...firstSchema
-			};
-		};
-		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;
-		this.schema = schema;
-		this.schemaPath = [...schemaPath || []];
-	}
-};
-
-//#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));
-}
-
-//#endregion
-//#region src/schema-parser/schema-utils.ts
-var SchemaUtils = class {
-	constructor({ config, schemaComponentsMap, typeNameFormatter, schemaWalker }) {
-		this.getRequiredProperties = (schema) => {
-			return lodash.uniq(schema && Array.isArray(schema.required) && schema.required || []);
-		};
-		this.isRefSchema = (schema) => {
-			return !!schema?.$ref;
-		};
-		this.getEnumNames = (schema) => {
-			return schema["x-enumNames"] || schema.xEnumNames || schema["x-enumnames"] || schema["x-enum-varnames"];
-		};
-		this.getSchemaRefType = (schema) => {
-			if (!this.isRefSchema(schema)) return null;
-			return this.schemaComponentsMap.get(schema.$ref);
-		};
-		this.isPropertyRequired = (name$1, 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;
-			if (this.config.convertedFromSwagger2) return typeof propertySchema.nullable === this.config.Ts.Keyword.Undefined ? isRequired : !propertySchema.nullable;
-			return isRequired;
-		};
-		this.isNullMissingInType = (schema, type$1) => {
-			const { nullable, type: schemaType } = schema || {};
-			return (nullable || !!lodash.get(schema, "x-nullable") || schemaType === this.config.Ts.Keyword.Null) && typeof type$1 === "string" && !type$1.includes(` ${this.config.Ts.Keyword.Null}`) && !type$1.includes(`${this.config.Ts.Keyword.Null} `);
-		};
-		this.safeAddNullToType = (schema, type$1) => {
-			if (this.isNullMissingInType(schema, type$1)) return this.config.Ts.UnionType([type$1, this.config.Ts.Keyword.Null]);
-			return type$1;
-		};
-		this.getSchemaPrimitiveType = (rawSchema) => {
-			const schema = rawSchema || {};
-			if (schema.type) return internalCase(schema.type);
-			if (schema.enum) {
-				const enumFieldType = typeof schema.enum[0];
-				if (enumFieldType === this.config.Ts.Keyword.Undefined) return;
-				return internalCase(enumFieldType);
-			}
-			if (lodash.keys(schema.properties).length) return SCHEMA_TYPES.OBJECT;
-			if (schema.items) return SCHEMA_TYPES.ARRAY;
-			return null;
-		};
-		this.checkAndAddRequiredKeys = (schema, resultType) => {
-			if ("$$requiredKeys" in schema && schema.$$requiredKeys.length) {
-				this.config.update({ internalTemplateOptions: { addUtilRequiredKeysType: true } });
-				return this.config.Ts.TypeWithGeneric(this.config.Ts.CodeGenKeyword.UtilRequiredKeys, [resultType, this.config.Ts.UnionType(schema.$$requiredKeys.map(this.config.Ts.StringValue))]);
-			}
-			return resultType;
-		};
-		this.makeAddRequiredToChildSchema = (parentSchema, childSchema) => {
-			if (!childSchema) return childSchema;
-			const required = lodash.uniq([...this.getRequiredProperties(parentSchema), ...this.getRequiredProperties(childSchema)]);
-			const refData = this.getSchemaRefType(childSchema);
-			if (refData) {
-				const refObjectProperties = lodash.keys(refData.rawTypeData?.properties || {});
-				const existedRequiredKeys = refObjectProperties.filter((key) => required.includes(key));
-				if (!existedRequiredKeys.length) return childSchema;
-				return {
-					...childSchema,
-					$$requiredKeys: existedRequiredKeys
-				};
-			}
-			if (childSchema.properties) {
-				const childSchemaProperties = lodash.keys(childSchema.properties);
-				const existedRequiredKeys = childSchemaProperties.filter((key) => required.includes(key));
-				if (!existedRequiredKeys.length) return childSchema;
-				return {
-					required: lodash.uniq([...this.getRequiredProperties(childSchema), ...existedRequiredKeys]),
-					...childSchema
-				};
-			}
-			return childSchema;
-		};
-		this.filterSchemaContents = (contents, filterFn) => {
-			return lodash.uniq(contents.filter((type$1) => filterFn(type$1)));
-		};
-		this.resolveTypeName = (typeName, { suffixes, resolver, prefixes, shouldReserve = true }) => {
-			if (resolver) return this.config.componentTypeNameResolver.resolve([], (reserved) => {
-				return resolver(pascalCase(typeName), reserved);
-			});
-			return this.config.componentTypeNameResolver.resolve([...(prefixes || []).map((prefix) => pascalCase(`${prefix} ${typeName}`)), ...(suffixes || []).map((suffix) => pascalCase(`${typeName} ${suffix}`))], shouldReserve);
-		};
-		this.getComplexType = (schema) => {
-			if (schema.oneOf) return SCHEMA_TYPES.COMPLEX_ONE_OF;
-			if (schema.allOf) return SCHEMA_TYPES.COMPLEX_ALL_OF;
-			if (schema.anyOf) return SCHEMA_TYPES.COMPLEX_ANY_OF;
-			if (schema.not) return SCHEMA_TYPES.COMPLEX_NOT;
-			return SCHEMA_TYPES.COMPLEX_UNKNOWN;
-		};
-		this.getInternalSchemaType = (schema) => {
-			if (!lodash.isEmpty(schema.enum) || !lodash.isEmpty(this.getEnumNames(schema))) return SCHEMA_TYPES.ENUM;
-			if (schema.discriminator) return SCHEMA_TYPES.DISCRIMINATOR;
-			if (schema.allOf || schema.oneOf || schema.anyOf || schema.not) return SCHEMA_TYPES.COMPLEX;
-			if (!lodash.isEmpty(schema.properties)) return SCHEMA_TYPES.OBJECT;
-			if (schema.type === SCHEMA_TYPES.ARRAY) return SCHEMA_TYPES.ARRAY;
-			return SCHEMA_TYPES.PRIMITIVE;
-		};
-		this.getSchemaType = (schema) => {
-			if (!schema) return this.config.Ts.Keyword.Any;
-			const refTypeInfo = this.getSchemaRefType(schema);
-			if (refTypeInfo) return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, this.typeNameFormatter.format(refTypeInfo.typeName)));
-			let resultType;
-			if (this.isConstantSchema(schema)) resultType = this.formatJsValue(schema.const);
-			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];
-				if (typeof typeAlias === "function") resultType = typeAlias(schema, this);
-				else resultType = typeAlias || primitiveType;
-			}
-			if (!resultType) return this.config.Ts.Keyword.Any;
-			return this.checkAndAddRequiredKeys(schema, this.safeAddNullToType(schema, resultType));
-		};
-		this.buildTypeNameFromPath = (schemaPath) => {
-			schemaPath = lodash.uniq(lodash.compact(schemaPath));
-			if (!schemaPath || !schemaPath[0]) return null;
-			return pascalCase(lodash.camelCase(lodash.uniq([schemaPath[0], schemaPath[schemaPath.length - 1]]).join("_")));
-		};
-		this.formatJsValue = (value) => {
-			switch (typeof value) {
-				case "string": return this.config.Ts.StringValue(value);
-				case "boolean": return this.config.Ts.BooleanValue(value);
-				case "number": return this.config.Ts.NumberValue(value);
-				default: {
-					if (value === null) return this.config.Ts.NullValue(value);
-					return this.config.Ts.Keyword.Any;
-				}
-			}
-		};
-		this.config = config;
-		this.schemaComponentsMap = schemaComponentsMap;
-		this.typeNameFormatter = typeNameFormatter;
-		this.schemaWalker = schemaWalker;
-	}
-	isConstantSchema(schema) {
-		return "const" in schema;
-	}
-};
-
-//#endregion
-//#region src/schema-parser/schema-parser-fabric.ts
-var SchemaParserFabric = class {
-	constructor(config, templatesWorker, schemaComponentsMap, typeNameFormatter, schemaWalker) {
-		this.createSchemaParser = ({ schema, typeName, schemaPath }) => {
-			return new SchemaParser(this, {
-				schema,
-				typeName,
-				schemaPath
-			});
-		};
-		this.createSchema = ({ content, linkedSchema = {}, linkedComponent, schemaPath,...otherSchemaProps }) => {
-			const parser = this.createSchemaParser({
-				schema: linkedComponent || linkedSchema,
-				schemaPath
-			});
-			const parsed = parser.parseSchema();
-			parsed.content = content;
-			Object.assign(parsed, otherSchemaProps);
-			if (linkedComponent) linkedComponent.typeData = parsed;
-			return parser.schema;
-		};
-		this.createParsedComponent = ({ typeName, schema, schemaPath }) => {
-			const schemaCopy = structuredClone(schema);
-			const customComponent = this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
-				"components",
-				"schemas",
-				typeName
-			]), schemaCopy);
-			const parsed = this.parseSchema(schemaCopy, null, schemaPath);
-			parsed.name = typeName;
-			customComponent.typeData = parsed;
-			return customComponent;
-		};
-		this.parseSchema = (schema, typeName = null, schemaPath = []) => {
-			const schemaParser = this.createSchemaParser({
-				schema,
-				typeName,
-				schemaPath
-			});
-			return schemaParser.parseSchema();
-		};
-		this.getInlineParseContent = (schema, typeName, schemaPath) => {
-			const parser = this.createSchemaParser({
-				schema,
-				typeName,
-				schemaPath
-			});
-			return parser.getInlineParseContent();
-		};
-		this.getParseContent = (schema, typeName, schemaPath) => {
-			const parser = this.createSchemaParser({
-				schema,
-				typeName,
-				schemaPath
-			});
-			return parser.getParseContent();
-		};
-		this.config = config;
-		this.schemaComponentsMap = schemaComponentsMap;
-		this.typeNameFormatter = typeNameFormatter;
-		this.templatesWorker = templatesWorker;
-		this.schemaWalker = schemaWalker;
-		this.schemaUtils = new SchemaUtils(this);
-		this.schemaFormatters = new SchemaFormatters(this);
-	}
-};
-
-//#endregion
-//#region src/util/id.ts
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
-const generateId = nanoid.customAlphabet(ALPHABET, 12);
-
-//#endregion
-//#region src/schema-routes/util/specific-arg-name-resolver.ts
-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);
-			return generatedVariant;
-		});
-		this.counter = 1;
-	}
-};
-
-//#endregion
-//#region src/schema-routes/schema-routes.ts
-const CONTENT_KIND = {
-	JSON: "JSON",
-	URL_ENCODED: "URL_ENCODED",
-	FORM_DATA: "FORM_DATA",
-	IMAGE: "IMAGE",
-	OTHER: "OTHER",
-	TEXT: "TEXT"
-};
-var SchemaRoutes = class {
-	constructor(config, schemaParserFabric, schemaComponentsMap, templatesWorker, typeNameFormatter) {
-		this.FORM_DATA_TYPES = [];
-		this.routes = [];
-		this.hasSecurityRoutes = false;
-		this.hasQueryRoutes = false;
-		this.hasFormDataRoutes = false;
-		this.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] = {
-					...requestInfo,
-					parameters: lodash.compact(lodash.concat(parameters, requestInfo.parameters))
-				};
-				return acc;
-			}, {});
-		};
-		this.parseRouteName = (originalRouteName) => {
-			const routeName = this.config.hooks.onPreBuildRoutePath(originalRouteName) || originalRouteName;
-			const pathParamMatches = (routeName || "").match(/({[\w[\\\]^`][-_.\w]*})|(:[\w[\\\]^`][-_.\w]*:?)/g);
-			const pathParams = lodash.reduce(pathParamMatches, (pathParams$1, match) => {
-				const paramName = match.replace(/\{|\}|:/g, "");
-				if (!paramName) return pathParams$1;
-				if (paramName.includes("-")) consola.warn("wrong path param name", paramName);
-				pathParams$1.push({
-					$match: match,
-					name: lodash.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}}`);
-			}, 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(","));
-				for (const paramName of paramNames) {
-					if (paramName.includes("-")) consola.warn("wrong query param name", paramName);
-					queryParams.push({
-						$match: paramName,
-						name: lodash.camelCase(paramName),
-						required: true,
-						type: "string",
-						description: "",
-						schema: { type: "string" },
-						in: "query"
-					});
-				}
-			}
-			const result = {
-				originalRoute: originalRouteName || "",
-				route: fixedRoute,
-				pathParams,
-				queryParams
-			};
-			return this.config.hooks.onBuildRoutePath(result) || result;
-		};
-		this.getRouteParams = (routeInfo, pathParamsFromRouteName, queryParamsFromRouteName) => {
-			const { parameters } = routeInfo;
-			const routeParams = {
-				path: [],
-				header: [],
-				body: [],
-				query: [],
-				formData: [],
-				cookie: []
-			};
-			lodash.each(parameters, (parameter) => {
-				const refTypeInfo = this.schemaParserFabric.schemaUtils.getSchemaRefType(parameter);
-				let routeParam = null;
-				if (refTypeInfo?.rawTypeData.in && refTypeInfo.rawTypeData) {
-					if (!routeParams[refTypeInfo.rawTypeData.in]) routeParams[refTypeInfo.rawTypeData.in] = [];
-					routeParam = {
-						...refTypeInfo.rawTypeData,
-						...refTypeInfo.rawTypeData.schema || {}
-					};
-				} else {
-					if (!parameter.in) return;
-					if (!routeParams[parameter.in]) routeParams[parameter.in] = [];
-					routeParam = {
-						...parameter,
-						...parameter.schema || {}
-					};
-				}
-				if (routeParam.in === "path") {
-					if (!routeParam.name) return;
-					routeParam.name = lodash.camelCase(routeParam.name);
-				}
-				if (routeParam) routeParams[routeParam.in].push(routeParam);
-			});
-			for (const pathParam of pathParamsFromRouteName) {
-				const alreadyExist = routeParams.path.some((parameter) => parameter.name === pathParam.name);
-				if (!alreadyExist) routeParams.path.push(pathParam);
-			}
-			for (const queryParam of queryParamsFromRouteName) {
-				const alreadyExist = routeParams.query.some((parameter) => parameter.name === queryParam.name);
-				if (!alreadyExist) routeParams.query.push(queryParam);
-			}
-			return routeParams;
-		};
-		this.getContentTypes = (requestInfo, extraContentTypes) => lodash.uniq(lodash.compact([...extraContentTypes || [], ...lodash.flatten(lodash.map(requestInfo, (requestInfoData) => requestInfoData && lodash.keys(requestInfoData.content)))]));
-		this.getContentKind = (contentTypes) => {
-			if (contentTypes.some((contentType) => contentType.startsWith("application/json")) || contentTypes.some((contentType) => contentType.endsWith("+json"))) return CONTENT_KIND.JSON;
-			if (contentTypes.includes("application/x-www-form-urlencoded")) return CONTENT_KIND.URL_ENCODED;
-			if (contentTypes.includes("multipart/form-data")) return CONTENT_KIND.FORM_DATA;
-			if (contentTypes.some((contentType) => contentType.includes("image/"))) return CONTENT_KIND.IMAGE;
-			if (contentTypes.some((contentType) => contentType.startsWith("text/"))) return CONTENT_KIND.TEXT;
-			return CONTENT_KIND.OTHER;
-		};
-		this.isSuccessStatus = (status) => this.config.defaultResponseAsSuccess && status === "default" || +status >= this.config.successResponseStatusRange[0] && +status <= this.config.successResponseStatusRange[1] || status === "2xx";
-		this.getSchemaFromRequestType = (requestInfo) => {
-			const content = lodash.get(requestInfo, "content");
-			if (!content) return null;
-			for (const dataType in content) if (content[dataType]?.schema) return {
-				...content[dataType].schema,
-				dataType
-			};
-			return null;
-		};
-		this.getTypeFromRequestInfo = ({ requestInfo, parsedSchemas, operationId, defaultType, typeName }) => {
-			const schema = this.getSchemaFromRequestType(requestInfo);
-			const refTypeInfo = this.schemaParserFabric.schemaUtils.getSchemaRefType(requestInfo);
-			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 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);
-				switch (refTypeInfo.componentName) {
-					case "schemas": return this.typeNameFormatter.format(refTypeInfo.typeName);
-					case "responses":
-					case "requestBodies": return this.schemaParserFabric.getInlineParseContent(this.getSchemaFromRequestType(refTypeInfo.rawTypeData), refTypeInfo.typeName || null, [operationId]);
-					default: return this.schemaParserFabric.getInlineParseContent(refTypeInfo.rawTypeData, refTypeInfo.typeName || null, [operationId]);
-				}
-			}
-			return defaultType || this.config.Ts.Keyword.Any;
-		};
-		this.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,
-					// @ts-expect-error TS(2345) FIXME: Argument of type '{ requestInfo: any; parsedSchema... Remove this comment to see the full error message
-					this.getTypeFromRequestInfo({
-						requestInfo,
-						parsedSchemas,
-						operationId,
-						defaultType
-					})
-),
-				description: this.schemaParserFabric.schemaFormatters.formatDescription(requestInfo.description || "", true),
-				status: Number.isNaN(+status) ? status : +status,
-				isSuccess: this.isSuccessStatus(status)
-			}];
-		}, []);
-		this.getResponseBodyInfo = (routeInfo, parsedSchemas) => {
-			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
-			});
-			const successResponse = responseInfos.find((response) => response.isSuccess);
-			const errorResponses = responseInfos.filter((response) => !response.isSuccess && response.type !== this.config.Ts.Keyword.Any);
-			const handleResponseHeaders = (src) => {
-				if (!src) return "headers: {},";
-				const headerTypes = Object.fromEntries(Object.entries(src).map(([k, v]) => {
-					return [k, this.schemaUtils.getSchemaType(v)];
-				}));
-				const r = `headers: { ${Object.entries(headerTypes).map(([k, v]) => `"${k}": ${v}`).join(",")} },`;
-				return r;
-			};
-			return {
-				contentTypes,
-				responses: responseInfos,
-				success: {
-					schema: successResponse,
-					type: successResponse?.type || this.config.Ts.Keyword.Any
-				},
-				error: {
-					schemas: errorResponses,
-					type: this.config.Ts.UnionType(errorResponses.map((response) => response.type)) || this.config.Ts.Keyword.Any
-				},
-				full: { types: this.config.Ts.UnionType(responseInfos.map((response) => `{
-      data: ${response.type}, status: ${response.status}, statusCode: ${response.status}, statusText: "${response.description}", ${handleResponseHeaders(response.headers)} config: {} }`)) || this.config.Ts.Keyword.Any }
-			};
-		};
-		this.convertRouteParamsIntoObject = (params) => {
-			return params.reduce((objectSchema, schemaPart) => {
-				if (!schemaPart || !schemaPart.name) return objectSchema;
-				return {
-					...objectSchema,
-					properties: {
-						...objectSchema.properties,
-						[schemaPart.name]: {
-							...schemaPart,
-							...schemaPart.schema || {}
-						}
-					}
-				};
-			}, {
-				properties: {},
-				type: "object"
-			});
-		};
-		this.getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) => {
-			const { requestBody, consumes, requestBodyName, operationId } = routeInfo;
-			let schema = null;
-			let content = null;
-			const contentTypes = this.getContentTypes([requestBody], [...consumes || [], routeInfo["x-contentType"]]);
-			let contentKind = this.getContentKind(contentTypes);
-			let typeName = null;
-			if (this.config.extractRequestBody) typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
-				suffixes: this.config.extractingOptions.requestBodySuffix,
-				resolver: this.config.extractingOptions.requestBodyNameResolver
-			});
-			if (routeParams.formData.length) {
-				contentKind = CONTENT_KIND.FORM_DATA;
-				schema = this.convertRouteParamsIntoObject(routeParams.formData);
-				content = this.schemaParserFabric.getInlineParseContent(schema, typeName, [operationId]);
-			} else if (contentKind === CONTENT_KIND.FORM_DATA) {
-				schema = this.getSchemaFromRequestType(requestBody);
-				content = this.schemaParserFabric.getInlineParseContent(schema, typeName, [operationId]);
-			} else if (requestBody) {
-				schema = this.getSchemaFromRequestType(requestBody);
-				content = this.schemaParserFabric.schemaUtils.safeAddNullToType(
-					requestBody,
-					// @ts-expect-error TS(2345) FIXME: Argument of type '{ requestInfo: any; parsedSchema... Remove this comment to see the full error message
-					this.getTypeFromRequestInfo({
-						requestInfo: requestBody,
-						parsedSchemas,
-						operationId,
-						typeName
-					})
-);
-				if (this.FORM_DATA_TYPES.some((dataType) => content.includes(`: ${dataType}`))) contentKind = CONTENT_KIND.FORM_DATA;
-			}
-			if (schema && !schema.$ref && this.config.extractRequestBody) {
-				schema = this.schemaParserFabric.createParsedComponent({
-					schema,
-					typeName,
-					schemaPath: [operationId]
-				});
-				if (schema?.typeData) schema.typeData.isExtractedRequestBody = true;
-				content = this.schemaParserFabric.getInlineParseContent({ $ref: schema.$ref });
-			}
-			return {
-				paramName: requestBodyName || requestBody?.name || DEFAULT_BODY_ARG_NAME,
-				contentTypes,
-				contentKind,
-				schema,
-				type: content,
-				required: requestBody && (typeof requestBody.required === "undefined" || !!requestBody.required)
-			};
-		};
-		this.createRequestParamsSchema = ({ queryParams, queryObjectSchema, pathArgsSchemas, extractRequestParams, routeName }) => {
-			if (!queryParams || !queryParams.length) return null;
-			const pathParams = pathArgsSchemas.reduce((acc, pathArgSchema) => {
-				if (pathArgSchema.name) acc[pathArgSchema.name] = {
-					...pathArgSchema,
-					in: "path"
-				};
-				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 schema = {
-				...queryObjectSchema,
-				properties: {
-					...fixedQueryParams,
-					...pathParams
-				}
-			};
-			const fixedSchema = this.config.hooks.onCreateRequestParams(schema);
-			if (fixedSchema) return fixedSchema;
-			if (extractRequestParams) {
-				const generatedTypeName = this.schemaUtils.resolveTypeName(routeName.usage, {
-					suffixes: this.config.extractingOptions.requestParamsSuffix,
-					resolver: this.config.extractingOptions.requestParamsNameResolver
-				});
-				const component = this.schemaParserFabric.createParsedComponent({
-					typeName: generatedTypeName,
-					schema
-				});
-				if (component.typeData) component.typeData.isExtractedRequestParams = true;
-				return component;
-			}
-			return schema;
-		};
-		this.extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
-			if (responseBodyInfo.responses.length && responseBodyInfo.success && responseBodyInfo.success.schema) {
-				const typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
-					suffixes: this.config.extractingOptions.responseBodySuffix,
-					resolver: this.config.extractingOptions.responseBodyNameResolver
-				});
-				const idx = responseBodyInfo.responses.indexOf(responseBodyInfo.success.schema);
-				const successResponse = responseBodyInfo.success;
-				if (successResponse.schema && !successResponse.schema.$ref) {
-					const contentKind = successResponse.schema.contentKind;
-					const schema = this.getSchemaFromRequestType(successResponse.schema);
-					successResponse.schema = this.schemaParserFabric.createParsedComponent({
-						schema,
-						typeName,
-						schemaPath: [routeInfo.operationId]
-					});
-					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], {
-						...successResponse.schema,
-						type: successResponse.type
-					});
-				}
-			}
-		};
-		this.extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
-			if (responseBodyInfo.responses.length && responseBodyInfo.error.schemas && responseBodyInfo.error.schemas.length) {
-				const typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
-					suffixes: this.config.extractingOptions.responseErrorSuffix,
-					resolver: this.config.extractingOptions.responseErrorNameResolver
-				});
-				const errorSchemas = responseBodyInfo.error.schemas.map(this.getSchemaFromRequestType).filter(Boolean);
-				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")
-				}, null, [routeInfo.operationId]);
-				const component = this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
-					"components",
-					"schemas",
-					typeName
-				]), { ...schema });
-				responseBodyInfo.error.schemas = [component];
-				if (component.typeData) component.typeData.isExtractedResponseError = true;
-				responseBodyInfo.error.type = this.typeNameFormatter.format(component.typeName);
-			}
-		};
-		this.getRouteName = (rawRouteInfo) => {
-			const { moduleName } = rawRouteInfo;
-			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 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.`);
-			} else routeNameDuplicatesMap.set(duplicateIdentifier, 1);
-			const duplicates = routeNameDuplicatesMap.get(duplicateIdentifier);
-			const routeNameInfo = {
-				usage: routeName + (duplicates > 1 ? duplicates : ""),
-				original: routeName,
-				duplicate: duplicates > 1
-			};
-			return this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) || routeNameInfo;
-		};
-		this.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 { 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]);
-			let hasSecurity = !!globalSecurity?.length;
-			if (security) hasSecurity = security.length > 0;
-			const routeParams = this.getRouteParams(routeInfo, pathParamsFromRouteName, queryParamsFromRouteName);
-			const pathArgs = routeParams.path.map((pathArgSchema) => ({
-				name: pathArgSchema.name,
-				optional: !pathArgSchema.required,
-				type: this.config.Ts.Keyword.Any,
-				description: pathArgSchema.description
-			}));
-			const pathArgsNames = pathArgs.map((arg) => arg.name);
-			const responseBodyInfo = this.getResponseBodyInfo(routeInfo, parsedSchemas);
-			const rawRouteInfo = {
-				...otherInfo,
-				pathArgs,
-				operationId,
-				method,
-				route: rawRouteName,
-				moduleName,
-				responsesTypes: responseBodyInfo.responses,
-				description: description$1,
-				tags,
-				summary,
-				responses,
-				produces,
-				requestBody,
-				consumes,
-				security
-			};
-			const queryObjectSchema = this.convertRouteParamsIntoObject(routeParams.query);
-			const pathObjectSchema = this.convertRouteParamsIntoObject(routeParams.path);
-			const headersObjectSchema = this.convertRouteParamsIntoObject(routeParams.header);
-			const routeName = this.getRouteName(rawRouteInfo);
-			const requestBodyInfo = this.getRequestBodyInfo(routeInfo, routeParams, parsedSchemas, routeName);
-			const requestParamsSchema = this.createRequestParamsSchema({
-				queryParams: routeParams.query,
-				pathArgsSchemas: routeParams.path,
-				queryObjectSchema,
-				extractRequestParams,
-				routeName
-			});
-			if (this.config.extractResponseBody) this.extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeName);
-			if (this.config.extractResponseError) this.extractResponseErrorIfItNeeded(routeInfo, responseBodyInfo, routeName);
-			const typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
-				suffixes: this.config.extractingOptions.requestParamsSuffix,
-				resolver: this.config.extractingOptions.requestParamsNameResolver,
-				shouldReserve: false
-			});
-			const queryType = routeParams.query.length ? this.schemaParserFabric.getInlineParseContent(queryObjectSchema, null, [typeName]) : null;
-			const pathType = routeParams.path.length ? this.schemaParserFabric.getInlineParseContent(pathObjectSchema, null, [typeName]) : null;
-			const headersType = routeParams.header.length ? this.schemaParserFabric.getInlineParseContent(headersObjectSchema, null, [typeName]) : null;
-			const nameResolver = new SpecificArgNameResolver(this.config, pathArgsNames);
-			const specificArgs = {
-				query: queryType ? {
-					name: nameResolver.resolve(RESERVED_QUERY_ARG_NAMES),
-					optional: this.schemaParserFabric.parseSchema(queryObjectSchema, null, [routeName.usage]).allFieldsAreOptional,
-					type: queryType
-				} : void 0,
-				body: requestBodyInfo.type ? {
-					name: nameResolver.resolve([requestBodyInfo.paramName, ...RESERVED_BODY_ARG_NAMES]),
-					optional: !requestBodyInfo.required,
-					type: requestBodyInfo.type
-				} : void 0,
-				pathParams: pathType ? {
-					name: nameResolver.resolve(RESERVED_PATH_ARG_NAMES),
-					optional: this.schemaParserFabric.parseSchema(pathObjectSchema, null, [routeName.usage]).allFieldsAreOptional,
-					type: pathType
-				} : void 0,
-				headers: headersType ? {
-					name: nameResolver.resolve(RESERVED_HEADER_ARG_NAMES),
-					optional: this.schemaParserFabric.parseSchema(headersObjectSchema, null, [routeName.usage]).allFieldsAreOptional,
-					type: headersType
-				} : void 0
-			};
-			pathArgs.forEach((pathArg, i) => {
-				pathArg.type = this.schemaParserFabric.getInlineParseContent(routeParams.path[i].schema, null, [typeName]);
-			});
-			return {
-				id: routeId,
-				namespace: moduleName.replace(/^(\d)/, "v$1"),
-				routeName,
-				routeParams,
-				requestBodyInfo,
-				responseBodyInfo,
-				specificArgs,
-				queryObjectSchema,
-				pathObjectSchema,
-				headersObjectSchema,
-				responseBodySchema: responseBodyInfo.success.schema,
-				requestBodySchema: requestBodyInfo.schema,
-				specificArgNameResolver: nameResolver,
-				request: {
-					contentTypes: requestBodyInfo.contentTypes,
-					parameters: pathArgs,
-					path: route,
-					formData: requestBodyInfo.contentKind === CONTENT_KIND.FORM_DATA,
-					isQueryBody: requestBodyInfo.contentKind === CONTENT_KIND.URL_ENCODED,
-					security: hasSecurity,
-					method,
-					requestParams: requestParamsSchema,
-					payload: specificArgs.body,
-					query: specificArgs.query,
-					pathParams: specificArgs.pathParams,
-					headers: specificArgs.headers
-				},
-				response: {
-					contentTypes: responseBodyInfo.contentTypes,
-					type: responseBodyInfo.success.type,
-					errorType: responseBodyInfo.error.type,
-					fullTypes: responseBodyInfo.full.types
-				},
-				raw: rawRouteInfo
-			};
-		};
-		this.attachSchema = ({ usageSchema, parsedSchemas }) => {
-			this.config.routeNameDuplicatesMap.clear();
-			const pathsEntries = lodash.entries(usageSchema.paths);
-			for (const [rawRouteName, routeInfoByMethodsMap] of pathsEntries) {
-				const routeInfosMap = this.createRequestsMap(routeInfoByMethodsMap);
-				for (const [method, routeInfo] of Object.entries(routeInfosMap)) {
-					const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, usageSchema, parsedSchemas);
-					const processedRouteInfo = this.config.hooks.onCreateRoute(parsedRouteInfo);
-					if (processedRouteInfo !== false) {
-						const route = processedRouteInfo || parsedRouteInfo;
-						if (!this.hasSecurityRoutes && route.security) this.hasSecurityRoutes = route.security;
-						if (!this.hasQueryRoutes && route.hasQuery) this.hasQueryRoutes = route.hasQuery;
-						if (!this.hasFormDataRoutes && route.hasFormDataParams) this.hasFormDataRoutes = route.hasFormDataParams;
-						this.routes.push(route);
-					}
-				}
-			}
-		};
-		this.getGroupedRoutes = () => {
-			const groupedRoutes = this.routes.reduce((modules, route) => {
-				if (route.namespace) {
-					if (!modules[route.namespace]) modules[route.namespace] = [];
-					modules[route.namespace].push(route);
-				} 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;
-			}, {});
-			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);
-				});
-			}
-			return routeGroups;
-		};
-		this.sortRoutes = (routes) => {
-			return lodash.slice(routes).sort((routeA, routeB) => routeA.routeName.usage.localeCompare(routeB.routeName.usage));
-		};
-		this.config = config;
-		this.schemaParserFabric = schemaParserFabric;
-		this.schemaUtils = this.schemaParserFabric.schemaUtils;
-		this.typeNameFormatter = typeNameFormatter;
-		this.schemaComponentsMap = schemaComponentsMap;
-		this.templatesWorker = templatesWorker;
-		this.FORM_DATA_TYPES = lodash.uniq([this.schemaUtils.getSchemaType({
-			type: "string",
-			format: "file"
-		}), this.schemaUtils.getSchemaType({
-			type: "string",
-			format: "binary"
-		})]);
-	}
-};
-
-//#endregion
-//#region src/schema-walker.ts
-var SchemaWalker = class {
-	constructor(config, swaggerSchemaResolver) {
-		this.schemas = new Map();
-		this.caches = new Map();
-		this.addSchema = (name$1, schema) => {
-			this.schemas.set(name$1, structuredClone(schema));
-		};
-		this._isLocalRef = (ref) => {
-			return ref.startsWith("#");
-		};
-		this._isRemoteRef = (ref) => {
-			return ref.startsWith("http://") || ref.startsWith("https://");
-		};
-		this._getRefDataFromSchema = (schema, ref) => {
-			const path$4 = ref.replace("#", "").split("/");
-			const refData = lodash.get(schema, path$4);
-			if (refData) this.caches.set(ref, refData);
-			return refData;
-		};
-		this.config = config;
-		this.swaggerSchemaResolver = swaggerSchemaResolver;
-	}
-};
-
-//#endregion
-//#region src/util/request.ts
-var Request = class {
-	constructor(config) {
-		this.config = config;
-	}
-	async download({ url: url$3, authToken,...options }) {
-		const requestOptions = {};
-		if (authToken) requestOptions.headers = { Authorization: authToken };
-		lodash.merge(requestOptions, options, this.config.requestOptions);
-		try {
-			const response = await fetch(url$3, requestOptions);
-			return await response.text();
-		} catch (error) {
-			const message = `error while fetching data from URL "${url$3}"`;
-			consola.error(message, error);
-			return message;
-		}
-	}
-};
-
-//#endregion
-//#region src/swagger-schema-resolver.ts
-var SwaggerSchemaResolver = class {
-	constructor(config, fileSystem) {
-		this.getSwaggerSchemaByPath = (pathToSwagger) => {
-			consola.info(`try to get swagger by path "${pathToSwagger}"`);
-			return this.fileSystem.getFileContent(pathToSwagger);
-		};
-		this.config = config;
-		this.fileSystem = fileSystem;
-		this.request = new Request(config);
-	}
-	async create() {
-		const { spec, patch, input, url: url$3, authorizationToken } = this.config;
-		if (spec) return await this.convertSwaggerObject(spec, { patch });
-		const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url$3, 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({
-				title: "No title",
-				version: ""
-			}, result.info);
-			if (!Object.hasOwn(result, "openapi")) {
-				result.paths = lodash.merge({}, result.paths);
-				swagger2openapi.convertObj(result, {
-					...converterOptions,
-					resolveInternal: true,
-					warnOnly: true,
-					refSiblings: "preserve",
-					rbname: "requestBodyName"
-				}, (err, options) => {
-					const parsedSwaggerSchema = lodash.get(err, "options.openapi", lodash.get(options, "openapi"));
-					if (!parsedSwaggerSchema && err) throw err;
-					this.config.update({ convertedFromSwagger2: true });
-					resolve({
-						usageSchema: parsedSwaggerSchema,
-						originalSchema: result
-					});
-				});
-			} else resolve({
-				usageSchema: result,
-				originalSchema: structuredClone(result)
-			});
-		});
-	}
-	async fetchSwaggerSchemaFile(pathToSwagger, urlToSwagger, authToken) {
-		if (this.fileSystem.pathIsExist(pathToSwagger)) return this.getSwaggerSchemaByPath(pathToSwagger);
-		consola.info(`try to get swagger by URL "${urlToSwagger}"`);
-		return await this.request.download({
-			url: urlToSwagger,
-			authToken
-		});
-	}
-	processSwaggerSchemaFile(file) {
-		if (typeof file !== "string") return file;
-		try {
-			return JSON.parse(file);
-		} catch (e) {
-			return yaml.load(file);
-		}
-	}
-	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", []);
-				if (typeof usageRouteInfo === "object") {
-					usageRouteInfo.consumes = lodash.uniq(lodash.compact([...usageRouteInfo.consumes || [], ...originalRouteInfo.consumes || []]));
-					usageRouteInfo.produces = lodash.uniq(lodash.compact([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
-				}
-				lodash.each(originalRouteParams, (originalRouteParam) => {
-					const existUsageParam = usageRouteParams.find((param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name);
-					if (!existUsageParam) usageRouteParams.push(originalRouteParam);
-				});
-			});
-		});
-	}
-};
-
-//#endregion
-//#region src/templates-worker.ts
-var TemplatesWorker = class {
-	constructor(config, fileSystem, getRenderTemplateData) {
-		this.getTemplatePaths = (config$1) => {
-			const __dirname$1 = path$2.dirname(url$2.fileURLToPath(import.meta.url));
-			const baseTemplatesPath = path$2.resolve(__dirname$1, "../templates/base");
-			const defaultTemplatesPath = path$2.resolve(__dirname$1, "../templates/default");
-			const modularTemplatesPath = path$2.resolve(__dirname$1, "../templates/modular");
-			const originalTemplatesPath = config$1.modular ? modularTemplatesPath : defaultTemplatesPath;
-			const customTemplatesPath = config$1.templates && path$2.resolve(process.cwd(), config$1.templates);
-			return {
-				base: baseTemplatesPath,
-				default: defaultTemplatesPath,
-				modular: modularTemplatesPath,
-				original: originalTemplatesPath,
-				custom: customTemplatesPath
-			};
-		};
-		this.cropExtension = (path$4) => this.config.templateExtensions.reduce((path$5, ext) => path$5.endsWith(ext) ? path$5.replace(ext, "") : path$5, path$4);
-		this.getTemplateFullPath = (path_, fileName) => {
-			const raw = path$2.resolve(path_, "./", this.cropExtension(fileName));
-			const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
-			return pathVariants.find((variant) => !!this.fileSystem.pathIsExist(variant));
-		};
-		this.requireFnFromTemplate = async (packageOrPath) => {
-			const isPath = packageOrPath.startsWith("./") || packageOrPath.startsWith("../");
-			if (isPath) return await import(path$2.resolve(this.config.templatePaths.custom || this.config.templatePaths.original, packageOrPath));
-			return await import(packageOrPath);
-		};
-		this.getTemplate = (name$1, fileName, path$4) => {
-			const { templatePaths } = this.config;
-			if (path$4) return this.fileSystem.getFileContent(path$4);
-			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}"`);
-				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()}"`);
-			const originalFullPath = this.getTemplateFullPath(templatePaths.original, fileName);
-			if (originalFullPath) fileContent = this.fileSystem.getFileContent(originalFullPath);
-			return fileContent;
-		};
-		this.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 }) => ({
-				...acc,
-				[name$1]: this.getTemplate(name$1, fileName)
-			}), {});
-		};
-		this.findTemplateWithExt = (path$4) => {
-			const raw = this.cropExtension(path$4);
-			const pathVariants = this.config.templateExtensions.map((extension) => `${raw}${extension}`);
-			return pathVariants.find((variant) => this.fileSystem.pathIsExist(variant));
-		};
-		this.getTemplateContent = (path_) => {
-			const foundTemplatePathKey = lodash.keys(this.config.templatePaths).find((key) => path_.startsWith(`@${key}`));
-			if (foundTemplatePathKey) {
-				const rawPath = path$2.resolve(path_.replace(`@${foundTemplatePathKey}`, lodash.get(this.config.templatePaths, foundTemplatePathKey)));
-				const fixedPath = this.findTemplateWithExt(rawPath);
-				if (fixedPath) return this.fileSystem.getFileContent(fixedPath);
-			}
-			const customPath = this.config.templatePaths.custom && this.findTemplateWithExt(path$2.resolve(this.config.templatePaths.custom, path_));
-			if (customPath) return this.fileSystem.getFileContent(customPath);
-			const originalPath = this.findTemplateWithExt(path$2.resolve(this.config.templatePaths.original, path_));
-			if (originalPath) return this.fileSystem.getFileContent(originalPath);
-			return "";
-		};
-		this.renderTemplate = (template, configuration, options = {}) => {
-			if (!template) return "";
-			return Eta.render(template, {
-				...this.getRenderTemplateData(),
-				...configuration
-			}, {
-				async: false,
-				...options,
-				includeFile: (path$4, configuration$1, options$1 = {}) => {
-					return this.renderTemplate(this.getTemplateContent(path$4), configuration$1, options$1);
-				}
-			});
-		};
-		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;
-	}
-};
-
-//#endregion
-//#region src/translators/translator.ts
-var Translator = class {
-	constructor(config, codeFormatter) {
-		this.config = config;
-		this.codeFormatter = codeFormatter;
-	}
-	translate(_input) {
-		throw new Error("not implemented");
-	}
-};
-
-//#endregion
-//#region src/translators/javascript.ts
-var JavascriptTranslator = class extends Translator {
-	constructor(..._args) {
-		super(..._args);
-		this.compileTSCode = (input) => {
-			const fileNameFull = `${input.fileName}${input.fileExtension}`;
-			const output = {};
-			const host = typescript$1.createCompilerHost(this.config.compilerTsConfig, true);
-			const fileNames = [fileNameFull];
-			const originalSourceFileGet = host.getSourceFile.bind(host);
-			host.getSourceFile = (sourceFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-				if (sourceFileName !== fileNameFull) return originalSourceFileGet(sourceFileName, languageVersion, onError, shouldCreateNewSourceFile);
-				return typescript$1.createSourceFile(sourceFileName, input.fileContent, languageVersion, true, typescript$1.ScriptKind.TS);
-			};
-			host.writeFile = (fileName, contents) => {
-				output[fileName] = contents;
-			};
-			typescript$1.createProgram(fileNames, this.config.compilerTsConfig, host).emit();
-			return output;
-		};
-		this.translate = async (input) => {
-			const compiled = this.compileTSCode(input);
-			const jsFileName = `${input.fileName}${typescript$1.Extension.Js}`;
-			const dtsFileName = `${input.fileName}${typescript$1.Extension.Dts}`;
-			const sourceContent = compiled[jsFileName];
-			const tsImportRows = input.fileContent.split("\n").filter((line) => line.startsWith("import "));
-			const declarationContent = compiled[dtsFileName].split("\n").map((line) => {
-				if (line.startsWith("import ")) return tsImportRows.shift();
-				return line;
-			}).join("\n");
-			return [{
-				fileName: input.fileName,
-				fileExtension: typescript$1.Extension.Js,
-				fileContent: await this.codeFormatter.formatCode(sourceContent)
-			}, {
-				fileName: input.fileName,
-				fileExtension: typescript$1.Extension.Dts,
-				fileContent: await this.codeFormatter.formatCode(declarationContent)
-			}];
-		};
-	}
-};
-
-//#endregion
-//#region src/type-name-formatter.ts
-var TypeNameFormatter = class {
-	constructor(config) {
-		this.formattedModelNamesMap = new Map();
-		this.format = (name$1, 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 name of the model name", name$1);
-				return name$1;
-			}
-			if (/^([A-Z_]{1,})$/g.test(name$1)) return lodash.compact([
-				typePrefix,
-				name$1,
-				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;
-			this.formattedModelNamesMap.set(hashKey, formattedResultName);
-			return formattedResultName;
-		};
-		this.isValidName = (name$1) => /^([A-Za-z$_]{1,})$/g.test(name$1);
-		this.fixModelName = (name$1, options) => {
-			if (!this.isValidName(name$1)) {
-				if (!/^[a-zA-Z_$]/g.test(name$1)) {
-					const fixPrefix = options.type === "enum-key" ? this.config.fixInvalidEnumKeyPrefix : this.config.fixInvalidTypeNamePrefix;
-					return `${fixPrefix} ${name$1}`;
-				}
-				if (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, "");
-			}
-			return name$1;
-		};
-		this.config = config;
-	}
-};
-
-//#endregion
-//#region src/util/file-system.ts
-const FILE_PREFIX = `/* eslint-disable */
-/* tslint:disable */
-// @ts-nocheck
-/*
- * ---------------------------------------------------------------
- * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
- * ##                                                           ##
- * ## AUTHOR: acacode                                           ##
- * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
- * ---------------------------------------------------------------
- */
-
-`;
-var FileSystem = class {
-	constructor() {
-		this.getFileContent = (path$4) => {
-			return fs.readFileSync(path$4, { encoding: "utf8" });
-		};
-		this.readDir = (path$4) => {
-			return fs.readdirSync(path$4);
-		};
-		this.pathIsDir = (path$4) => {
-			if (!path$4) return false;
-			try {
-				const stat = fs.statSync(path$4);
-				return stat.isDirectory();
-			} catch (e) {
-				return false;
-			}
-		};
-		this.cropExtension = (fileName) => {
-			const fileNameParts = fileName.split(".");
-			if (fileNameParts.length > 1) fileNameParts.pop();
-			return fileNameParts.join(".");
-		};
-		this.removeDir = (path$4) => {
-			try {
-				if (typeof fs.rmSync === "function") fs.rmSync(path$4, { recursive: true });
-				else fs.rmdirSync(path$4, { recursive: true });
-			} catch (e) {
-				consola.debug("failed to remove dir", e);
-			}
-		};
-		this.createDir = (path$4) => {
-			try {
-				fs.mkdirSync(path$4, { recursive: true });
-			} catch (e) {
-				consola.debug("failed to create dir", e);
-			}
-		};
-		this.cleanDir = (path$4) => {
-			this.removeDir(path$4);
-			this.createDir(path$4);
-		};
-		this.pathIsExist = (path$4) => {
-			return !!path$4 && fs.existsSync(path$4);
-		};
-		this.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 fileContent = `${withPrefix ? FILE_PREFIX : ""}${content}`;
-			return fs.writeFileSync(absolutePath, fileContent);
-		};
-	}
-};
-
-//#endregion
-//#region src/code-gen-process.ts
-const PATCHABLE_INSTANCES = [
-	"schemaWalker",
-	"swaggerSchemaResolver",
-	"schemaComponentsMap",
-	"typeNameFormatter",
-	"templatesWorker",
-	"codeFormatter",
-	"schemaParserFabric",
-	"schemaRoutes",
-	"javascriptTranslator"
-];
-var CodeGenProcess = class {
-	constructor(config) {
-		this.getRenderTemplateData = () => {
-			return {
-				utils: {
-					Ts: this.config.Ts,
-					formatDescription: this.schemaParserFabric.schemaFormatters.formatDescription,
-					internalCase,
-					classNameCase: pascalCase,
-					pascalCase,
-					getInlineParseContent: this.schemaParserFabric.getInlineParseContent,
-					getParseContent: this.schemaParserFabric.getParseContent,
-					getComponentByRef: this.schemaComponentsMap.get,
-					parseSchema: this.schemaParserFabric.parseSchema,
-					checkAndAddNull: this.schemaParserFabric.schemaUtils.safeAddNullToType,
-					safeAddNullToType: this.schemaParserFabric.schemaUtils.safeAddNullToType,
-					isNeedToAddNull: this.schemaParserFabric.schemaUtils.isNullMissingInType,
-					inlineExtraFormatters: this.schemaParserFabric.schemaFormatters.inline,
-					formatters: this.schemaParserFabric.schemaFormatters.base,
-					formatModelName: this.typeNameFormatter.format,
-					fmtToJSDocLine: (line, { eol = true }) => {
-						return ` * ${line}${eol ? "\n" : ""}`;
-					},
-					NameResolver,
-					_: lodash,
-					require: this.templatesWorker.requireFnFromTemplate
-				},
-				config: this.config
-			};
-		};
-		this.collectModelTypes = () => {
-			const components = this.schemaComponentsMap.getComponents();
-			let modelTypes = [];
-			const modelTypeComponents = lodash.compact(["schemas", this.config.extractResponses && "responses"]);
-			const getSchemaComponentsCount = () => this.schemaComponentsMap.filter(...modelTypeComponents).length;
-			let schemaComponentsCount = getSchemaComponentsCount();
-			let processedCount = 0;
-			while (processedCount < schemaComponentsCount) {
-				modelTypes = [];
-				processedCount = 0;
-				for (const component of components) if (modelTypeComponents.includes(component.componentName)) {
-					const modelType = this.prepareModelType(component);
-					if (modelType) modelTypes.push(modelType);
-					processedCount++;
-				}
-				schemaComponentsCount = getSchemaComponentsCount();
-			}
-			if (this.config.sortTypes) return modelTypes.sort(sortByProperty("name"));
-			return modelTypes;
-		};
-		this.prepareModelType = (typeInfo) => {
-			if (typeInfo.$prepared) return typeInfo.$prepared;
-			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 preparedModelType = {
-				...typeData,
-				typeIdentifier,
-				name: name$1,
-				description: description$1,
-				$content: rawTypeData.content,
-				rawContent: rawTypeData.content,
-				content,
-				typeData
-			};
-			typeInfo.$prepared = preparedModelType;
-			return preparedModelType;
-		};
-		this.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) {
-				const content = this.templatesWorker.renderTemplate(this.fileSystem.getFileContent(extraTemplate.path), configuration);
-				output.push(...await this.createOutputFileInfo(configuration, extraTemplate.name, content));
-			}
-			return output.filter((fileInfo) => !!fileInfo && !!fileInfo.fileContent);
-		};
-		this.createMultipleFileInfos = async (templatesToRender, configuration) => {
-			const { routes } = configuration;
-			const { fileNames, generateRouteTypes, generateClient } = configuration.config;
-			const modularApiFileInfos = [];
-			if (routes.$outOfModule) {
-				if (generateRouteTypes) {
-					const outOfModuleRouteContent = this.templatesWorker.renderTemplate(templatesToRender.routeTypes, {
-						...configuration,
-						route: configuration.routes.$outOfModule
-					});
-					modularApiFileInfos.push(...await this.createOutputFileInfo(configuration, fileNames.outOfModuleApi, outOfModuleRouteContent));
-				}
-				if (generateClient) {
-					const outOfModuleApiContent = this.templatesWorker.renderTemplate(templatesToRender.api, {
-						...configuration,
-						route: configuration.routes.$outOfModule
-					});
-					modularApiFileInfos.push(...await this.createOutputFileInfo(configuration, fileNames.outOfModuleApi, outOfModuleApiContent));
-				}
-			}
-			if (routes.combined) for (const route of routes.combined) {
-				if (generateRouteTypes) {
-					const routeModuleContent = this.templatesWorker.renderTemplate(templatesToRender.routeTypes, {
-						...configuration,
-						route
-					});
-					modularApiFileInfos.push(...await this.createOutputFileInfo(configuration, pascalCase(`${route.moduleName}_Route`), routeModuleContent));
-				}
-				if (generateClient) {
-					const apiModuleContent = this.templatesWorker.renderTemplate(templatesToRender.api, {
-						...configuration,
-						route
-					});
-					modularApiFileInfos.push(...await this.createOutputFileInfo(configuration, pascalCase(route.moduleName), apiModuleContent));
-				}
-			}
-			return [
-				...await this.createOutputFileInfo(configuration, fileNames.dataContracts, this.templatesWorker.renderTemplate(templatesToRender.dataContracts, configuration)),
-				...generateClient ? await this.createOutputFileInfo(configuration, fileNames.httpClient, this.templatesWorker.renderTemplate(templatesToRender.httpClient, configuration)) : [],
-				...modularApiFileInfos
-			];
-		};
-		this.createSingleFileInfo = async (templatesToRender, configuration) => {
-			const { generateRouteTypes, generateClient } = configuration.config;
-			return await this.createOutputFileInfo(configuration, configuration.fileName, lodash.compact([
-				this.templatesWorker.renderTemplate(templatesToRender.dataContracts, configuration),
-				generateRouteTypes && this.templatesWorker.renderTemplate(templatesToRender.routeTypes, configuration),
-				generateClient && this.templatesWorker.renderTemplate(templatesToRender.httpClient, configuration),
-				generateClient && this.templatesWorker.renderTemplate(templatesToRender.api, configuration)
-			]).join("\n"));
-		};
-		this.createOutputFileInfo = async (configuration, fileNameFull, content) => {
-			const fileName = this.fileSystem.cropExtension(fileNameFull);
-			const fileExtension = typescript.Extension.Ts;
-			if (configuration.translateToJavaScript) {
-				consola.debug("using js translator for", fileName);
-				return await this.javascriptTranslator.translate({
-					fileName,
-					fileExtension,
-					fileContent: content
-				});
-			}
-			if (configuration.customTranslator) {
-				consola.debug("using custom translator for", fileName);
-				return await configuration.customTranslator.translate({
-					fileName,
-					fileExtension,
-					fileContent: content
-				});
-			}
-			consola.debug("generating output for", `${fileName}${fileExtension}`);
-			return [{
-				fileName,
-				fileExtension,
-				fileContent: await this.codeFormatter.formatCode(content)
-			}];
-		};
-		this.createApiConfig = (swaggerSchema) => {
-			const { info, servers, host, basePath, externalDocs, tags } = swaggerSchema;
-			const server = servers?.[0] || { url: "" };
-			const { title = "No title", version: version$1 } = info || {};
-			const { url: serverUrl } = server;
-			return {
-				info: info || {},
-				servers: servers || [],
-				basePath,
-				host,
-				externalDocs: lodash.merge({
-					url: "",
-					description: ""
-				}, externalDocs),
-				tags: lodash.compact(tags),
-				baseUrl: serverUrl,
-				title,
-				version: version$1
-			};
-		};
-		this.injectClassInstance = (key, value) => {
-			this[key] = value;
-			for (const instanceKey of PATCHABLE_INSTANCES) if (instanceKey !== key && key in this[instanceKey]) this[instanceKey][key] = value;
-		};
-		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.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);
-		this.config.update({
-			swaggerSchema: swagger.usageSchema,
-			originalSchema: swagger.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);
-		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);
-		}));
-		this.schemaComponentsMap.enumsFirst();
-		const componentsToParse = this.schemaComponentsMap.filter(lodash.compact(["schemas", this.config.extractResponses && "responses"]));
-		const parsedSchemas = componentsToParse.map((schemaComponent) => {
-			const parsed = this.schemaParserFabric.parseSchema(schemaComponent.rawTypeData, schemaComponent.typeName);
-			schemaComponent.typeData = parsed;
-			return parsed;
-		});
-		this.schemaRoutes.attachSchema({
-			usageSchema: swagger.usageSchema,
-			parsedSchemas
-		});
-		const rawConfiguration = {
-			apiConfig: this.createApiConfig(swagger.usageSchema),
-			config: this.config,
-			modelTypes: this.collectModelTypes(),
-			hasSecurityRoutes: this.schemaRoutes.hasSecurityRoutes,
-			hasQueryRoutes: this.schemaRoutes.hasQueryRoutes,
-			hasFormDataRoutes: this.schemaRoutes.hasFormDataRoutes,
-			generateResponses: this.config.generateResponses,
-			routes: this.schemaRoutes.getGroupedRoutes(),
-			extraTemplates: this.config.extraTemplates,
-			fileName: this.config.fileName,
-			translateToJavaScript: this.config.toJS,
-			customTranslator: this.config.customTranslator ? new this.config.customTranslator() : null,
-			utils: this.getRenderTemplateData().utils
-		};
-		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);
-				this.fileSystem.cleanDir(this.config.output);
-			}
-		} else {
-			consola.debug(`path ${this.config.output} is not exist. creating dir by this path`);
-			this.fileSystem.createDir(this.config.output);
-		}
-		const files$1 = await this.generateOutputFiles({ configuration });
-		const isDirPath = this.fileSystem.pathIsDir(this.config.output);
-		if (isDirPath) for (const file of files$1) {
-			this.fileSystem.createFile({
-				path: this.config.output,
-				fileName: `${file.fileName}${file.fileExtension}`,
-				content: file.fileContent,
-				withPrefix: true
-			});
-			consola.success("api file", `"${file.fileName}${file.fileExtension}"`, `created in ${this.config.output}`);
-		}
-		return {
-			files: files$1,
-			configuration,
-			getTemplate: this.templatesWorker.getTemplate,
-			renderTemplate: this.templatesWorker.renderTemplate,
-			createFile: this.fileSystem.createFile,
-			formatTSContent: this.codeFormatter.formatCode
-		};
-	}
-};
-
-//#endregion
-//#region src/commands/generate-templates/configuration.ts
-var TemplatesGenConfig = class {
-	constructor(config) {
-		this.cleanOutput = false;
-		this.debug = false;
-		this.httpClientType = HTTP_CLIENT.FETCH;
-		this.modular = false;
-		this.output = void 0;
-		this.rewrite = false;
-		this.silent = false;
-		this.version = PROJECT_VERSION;
-		this.update = (update) => {
-			objectAssign(this, update);
-		};
-		this.update(config);
-	}
-};
-
-//#endregion
-//#region src/commands/generate-templates/templates-gen-process.ts
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-var TemplatesGenProcess = class {
-	constructor(config) {
-		this.rootDir = path.resolve(__dirname, "..");
-		this.paths = {
-			baseTemplates: "templates/base",
-			httpClientTemplates: "templates/base/http-clients",
-			moduleApiTemplates: "templates/modular",
-			defaultApiTemplates: "templates/default"
-		};
-		this.importTemplatePrefixes = [
-			"@base",
-			"@modular",
-			"@default"
-		];
-		this.getTemplates = () => {
-			const outputFiles = [];
-			const baseTemplates = this.getTemplateNamesFromDir(this.paths.baseTemplates);
-			const httpClientTemplates = this.getTemplateNamesFromDir(this.paths.httpClientTemplates);
-			const apiTemplatesPath = this.config.modular ? this.paths.moduleApiTemplates : this.paths.defaultApiTemplates;
-			const apiTemplates = this.getTemplateNamesFromDir(apiTemplatesPath);
-			const usingHttpClientTemplate = httpClientTemplates.find((template) => template.startsWith(`${this.config.httpClientType}-`));
-			let httpClientTemplateContent = "";
-			if (usingHttpClientTemplate) httpClientTemplateContent = this.fixTemplateContent(this.getTemplateContent(`${this.paths.httpClientTemplates}/${usingHttpClientTemplate}`));
-			for (const fileName of baseTemplates) {
-				const templateContent = fileName === "http-client.ejs" && httpClientTemplateContent || this.fixTemplateContent(this.getTemplateContent(`${this.paths.baseTemplates}/${fileName}`));
-				outputFiles.push({
-					name: fileName,
-					content: templateContent
-				});
-			}
-			for (const fileName of apiTemplates) outputFiles.push({
-				name: fileName,
-				content: this.fixTemplateContent(this.getTemplateContent(`${apiTemplatesPath}/${fileName}`))
-			});
-			return outputFiles;
-		};
-		this.fixTemplateContent = (content) => {
-			const importsRegExp1 = new RegExp(`includeFile\\("(${this.importTemplatePrefixes.map((v) => `(${v})`).join("|")})/`, "g");
-			const importsRegExp2 = new RegExp(`includeFile\\(\`(${this.importTemplatePrefixes.map((v) => `(${v})`).join("|")})/`, "g");
-			const importsRegExp3 = new RegExp(`includeFile\\('(${this.importTemplatePrefixes.map((v) => `(${v})`).join("|")})/`, "g");
-			return content.replace(importsRegExp1, "includeFile(\"./").replace(importsRegExp2, "includeFile(`./").replace(importsRegExp3, "includeFile('./");
-		};
-		this.getTemplateNamesFromDir = (dir) => {
-			return this.fileSystem.readDir(path.resolve(this.rootDir, dir)).filter((file) => file.endsWith(".ejs"));
-		};
-		this.getTemplateContent = (pathToFile) => {
-			return this.fileSystem.getFileContent(path.resolve(this.rootDir, pathToFile));
-		};
-		this.config = new TemplatesGenConfig(config);
-		this.fileSystem = new FileSystem();
-	}
-	async start() {
-		consola.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");
-			const outputPath = path.resolve(process.cwd(), this.config.output);
-			if (this.fileSystem.pathIsExist(outputPath)) {
-				if (this.config.cleanOutput) this.fileSystem.cleanDir(outputPath);
-			} else this.fileSystem.createDir(outputPath);
-			for (const template of templates) {
-				const templateName = this.fileSystem.cropExtension(template.name);
-				const templateEjsPath = path.resolve(outputPath, `${templateName}.ejs`);
-				const templateEtaPath = path.resolve(outputPath, `${templateName}.eta`);
-				const templateEjsPathExist = this.fileSystem.pathIsExist(templateEjsPath);
-				const templateEtaPathExist = this.fileSystem.pathIsExist(templateEtaPath);
-				const templateNotExist = !templateEjsPathExist && !templateEtaPathExist;
-				if (templateNotExist) this.fileSystem.createFile({
-					path: outputPath,
-					fileName: template.name,
-					content: template.content,
-					withPrefix: false
-				});
-				else if (this.config.rewrite) {
-					if (templateEjsPathExist) this.fileSystem.createFile({
-						path: outputPath,
-						fileName: `${templateName}.ejs`,
-						content: template.content,
-						withPrefix: false
-					});
-					else if (templateEtaPathExist) this.fileSystem.createFile({
-						path: outputPath,
-						fileName: `${templateName}.eta`,
-						content: template.content,
-						withPrefix: false
-					});
-				}
-			}
-			consola.success(`source templates has been successfully created in "${outputPath}"`);
-		}
-		return {
-			files: templates,
-			configuration: this.config,
-			createFile: this.fileSystem.createFile
-		};
-	}
-};
-
-//#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;
-	const codeGenProcess = new TemplatesGenProcess(config);
-	return await codeGenProcess.start();
-}
-
-//#endregion
-//#region src/index.ts
-async function generateApi(config) {
-	if (config.debug) consola.level = Number.MAX_SAFE_INTEGER;
-	if (config.silent) consola.level = 0;
-	const codeGenProcess = new CodeGenProcess(config);
-	return await codeGenProcess.start();
-}
-
-//#endregion
-export { CodeGenConfig, HTTP_CLIENT, TemplatesGenConfig, constants_exports, generateApi, generateTemplates, package_default };
-//# sourceMappingURL=src-BzzyC03Z.js.map