keq 2.9.0 → 2.10.0

package/packages/cli/dist/plugins-CgMhaNZq.cjs

@@ -1,3558 +0,0 @@
-const require_logger = require("./logger-D7PyVZo3.cjs");
-let tapable = require("tapable");
-let fs_extra = require("fs-extra");
-fs_extra = require_logger.__toESM(fs_extra, 1);
-let path = require("path");
-path = require_logger.__toESM(path, 1);
-let ramda = require("ramda");
-ramda = require_logger.__toESM(ramda, 1);
-let eslint = require("eslint");
-let child_process = require("child_process");
-let util = require("util");
-let change_case = require("change-case");
-change_case = require_logger.__toESM(change_case, 1);
-let jsonpath_plus = require("jsonpath-plus");
-let jsonpointer = require("jsonpointer");
-jsonpointer = require_logger.__toESM(jsonpointer, 1);
-let _scalar_openapi_parser = require("@scalar/openapi-parser");
-let ts_custom_error = require("ts-custom-error");
-let word_wrap = require("word-wrap");
-word_wrap = require_logger.__toESM(word_wrap, 1);
-let swagger_fix = require("swagger-fix");
-let fs_promises = require("fs/promises");
-fs_promises = require_logger.__toESM(fs_promises, 1);
-let js_yaml = require("js-yaml");
-js_yaml = require_logger.__toESM(js_yaml, 1);
-let url = require("url");
-let _opendoc_openapi_shaking = require("@opendoc/openapi-shaking");
-let inquirer_select_pro = require("inquirer-select-pro");
-let _listr2_prompt_adapter_inquirer = require("@listr2/prompt-adapter-inquirer");
-let ajv_dist_2020_js = require("ajv/dist/2020.js");
-ajv_dist_2020_js = require_logger.__toESM(ajv_dist_2020_js, 1);
-//#region src/constants/qs-array-format.ts
-let QsArrayFormat = /* @__PURE__ */ function(QsArrayFormat) {
-	QsArrayFormat["brackets"] = "brackets";
-	QsArrayFormat["indices"] = "indices";
-	QsArrayFormat["repeat"] = "repeat";
-	QsArrayFormat["comma"] = "comma";
-	QsArrayFormat["space"] = "space";
-	QsArrayFormat["pipe"] = "pipe";
-	return QsArrayFormat;
-}({});
-//#endregion
-//#region src/constants/supported-methods.ts
-const SupportedMethods = [
-	"get",
-	"post",
-	"put",
-	"delete",
-	"patch",
-	"head",
-	"options"
-];
-//#endregion
-//#region src/models/plugin-metadata-storage.ts
-/**
-* A WeakMap-backed metadata storage for plugins.
-*
-* When a `key` is provided, the underlying WeakMap is stored in `globalThis` via
-* `Symbol.for(key)`, ensuring the same instance is shared across CJS and ESM module
-* boundaries. This is required for plugins that are imported by user config files
-* (e.g. via `@keq-request/cli/plugins`) and need to interoperate with the CLI's
-* internal plugins.
-*
-* When no `key` is provided, a plain `new WeakMap()` is used, which is sufficient
-* for plugins that always run within the same module system.
-*/
-var PluginMetadataStorage = class {
-	storage;
-	constructor(key) {
-		if (key !== void 0) {
-			const storageKey = Symbol.for(key);
-			const g = globalThis;
-			if (!g[storageKey]) g[storageKey] = /* @__PURE__ */ new WeakMap();
-			this.storage = g[storageKey];
-		} else this.storage = /* @__PURE__ */ new WeakMap();
-	}
-	has(key) {
-		return this.storage.has(key);
-	}
-	get(key) {
-		return this.storage.get(key);
-	}
-	set(key, value) {
-		this.storage.set(key, value);
-		return this;
-	}
-	delete(key) {
-		return this.storage.delete(key);
-	}
-};
-//#endregion
-//#region src/plugins/eslint/constants/metadata-storage.ts
-const MetadataStorage$12 = new PluginMetadataStorage("@keq-request/cli:EslintPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/eslint/eslint.plugin.ts
-var EslintPlugin = class EslintPlugin {
-	constructor(options = {}) {
-		this.options = options;
-	}
-	apply(compiler) {
-		if (!compiler.options.build) return;
-		const metadata = EslintPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		if (this.options.disable && this.options.disable.length > 0) {
-			const $rules = [...this.options.disable.map((rule) => `/* eslint-disable ${rule} */`)].join("\n");
-			compiler.hooks.afterCompile.tap(EslintPlugin.name, () => {
-				const artifacts = compiler.context.artifacts || [];
-				for (const artifact of artifacts) artifact.anchor.append("file:start", $rules);
-			});
-		}
-		compiler.hooks.afterPersist.tapPromise(EslintPlugin.name, async (task) => {
-			const files = compiler.context.assets || [];
-			if (files.length === 0) return;
-			const results = await new eslint.ESLint({ fix: true }).lintFiles(files.map((file) => file.path));
-			await eslint.ESLint.outputFixes(results);
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$12.has(compiler)) MetadataStorage$12.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$12.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/prettier/constants/metadata-storage.ts
-const MetadataStorage$11 = new PluginMetadataStorage("@keq-request/cli:PrettierPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/prettier/prettier.plugin.ts
-const execAsync = (0, util.promisify)(child_process.exec);
-var PrettierPlugin = class PrettierPlugin {
-	apply(compiler) {
-		if (!compiler.options.build) return;
-		const metadata = PrettierPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.afterPersist.tapPromise(PrettierPlugin.name, async () => {
-			const files = compiler.context.assets || [];
-			if (files.length === 0) return;
-			await execAsync(`prettier --write ${files.map((file) => file.path).join(" ")}`);
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$11.has(compiler)) MetadataStorage$11.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$11.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/utils/json-schema-utils/is-array.ts
-function isArray(schema) {
-	return schema.type === "array";
-}
-//#endregion
-//#region src/utils/json-schema-utils/is-mixed.ts
-function isMixed(schema) {
-	return Array.isArray(schema.type);
-}
-//#endregion
-//#region src/utils/json-schema-utils/is-non-array.ts
-function isNonArray(schema) {
-	return typeof schema.type === "string" && schema.type !== "array";
-}
-//#endregion
-//#region src/utils/json-schema-utils/is-ref.ts
-function isRef(schema) {
-	return "$ref" in schema;
-}
-//#endregion
-//#region src/utils/json-schema-utils/index.ts
-var JsonSchemaUtils = class {
-	static isRef = isRef;
-	static isArray = isArray;
-	static isNonArray = isNonArray;
-	static isMixed = isMixed;
-};
-//#endregion
-//#region src/plugins/generate-micro-function/constants/metadata-storage.ts
-const MetadataStorage$10 = new PluginMetadataStorage("@keq-request/cli:GenerateMicroFunctionPlugin:MetadataStorage");
-//#endregion
-//#region src/models/anchor.ts
-var AnchorBlock = class {
-	constructor(artifact) {
-		this.artifact = artifact;
-	}
-	/**
-	* Append content to the end of the anchor block.
-	*/
-	append(anchorName, content) {
-		const lines = this.artifact.content.split("\n");
-		const anchor = `@anchor:${anchorName}:end`;
-		const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-		if (anchorIndex === -1) throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-		lines.splice(anchorIndex, 0, content);
-		this.artifact.content = lines.join("\n");
-	}
-	prepend(anchorName, content) {
-		const lines = this.artifact.content.split("\n");
-		const anchor = `@anchor:${anchorName}:start`;
-		const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-		if (anchorIndex === -1) throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-		lines.splice(anchorIndex + 1, 0, content);
-		this.artifact.content = lines.join("\n");
-	}
-	replace(anchorName, content) {
-		const lines = this.artifact.content.split("\n");
-		const startIndex = lines.findIndex((line) => line.includes(`/* @anchor:${anchorName}:start */`));
-		const endIndex = lines.findIndex((line) => line.includes(`/* @anchor:${anchorName}:end */`));
-		if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) throw new Error(`"@anchor:${anchorName}:start" or "@anchor:${anchorName}:end" not found in artifact "${this.artifact.filepath}".`);
-		lines.splice(startIndex + 1, endIndex - startIndex - 1, content);
-		this.artifact.content = lines.join("\n");
-	}
-};
-var Anchor = class {
-	block;
-	constructor(artifact) {
-		this.artifact = artifact;
-		this.block = new AnchorBlock(artifact);
-	}
-	append(anchorName, content) {
-		const lines = this.artifact.content.split("\n");
-		const anchor = `@anchor:${anchorName}`;
-		const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-		if (anchorIndex === -1) throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-		lines.splice(anchorIndex + 1, 0, content);
-		this.artifact.content = lines.join("\n");
-	}
-	prepend(anchorName, content) {
-		const lines = this.artifact.content.split("\n");
-		const anchor = `@anchor:${anchorName}`;
-		const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-		if (anchorIndex === -1) throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-		lines.splice(anchorIndex, 0, content);
-		this.artifact.content = lines.join("\n");
-	}
-};
-//#endregion
-//#region src/models/artifact.ts
-const HeaderComment = [
-	"// Code generated by @keq-request/cli. DO NOT EDIT.",
-	"// Code generated by @keq-request/cli. DO NOT EDIT.",
-	"// Code generated by @keq-request/cli. DO NOT EDIT.",
-	"",
-	""
-].join("\n");
-var Artifact = class {
-	id;
-	filepath;
-	content;
-	extensionName;
-	anchor = new Anchor(this);
-	constructor(options) {
-		this.id = options.id;
-		this.filepath = options.filepath;
-		this.extensionName = options.extensionName || path.extname(options.filepath);
-		this.content = options.content;
-	}
-	get dirname() {
-		return path.dirname(this.filepath);
-	}
-	renderer() {
-		return `${HeaderComment}${this.content}`;
-	}
-};
-//#endregion
-//#region src/models/module-definition.ts
-var ModuleDefinition = class ModuleDefinition {
-	name;
-	address;
-	constructor(name, address) {
-		this.name = name;
-		if (typeof address === "string") this.address = {
-			url: address,
-			headers: {},
-			encoding: "utf8"
-		};
-		else this.address = address;
-	}
-	static unknown() {
-		return new ModuleDefinition("", {
-			url: "",
-			headers: {},
-			encoding: "utf8"
-		});
-	}
-};
-//#endregion
-//#region src/utils/is-keywords.ts
-const keywords = [
-	"break",
-	"case",
-	"catch",
-	"continue",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"in",
-	"instanceof",
-	"new",
-	"return",
-	"switch",
-	"this",
-	"throw",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"while",
-	"with"
-];
-function isKeywords(str) {
-	return keywords.includes(str);
-}
-//#endregion
-//#region src/utils/is-reserved-word.ts
-const reservedWords = [
-	"abstract",
-	"boolean",
-	"byte",
-	"char",
-	"class",
-	"const",
-	"debugger",
-	"double",
-	"enum",
-	"export",
-	"extends",
-	"final",
-	"float",
-	"goto",
-	"implements",
-	"import",
-	"int",
-	"interface",
-	"long",
-	"native",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"short",
-	"static",
-	"super",
-	"synchronized",
-	"throws",
-	"transient",
-	"volatile"
-];
-function isReservedWord(str) {
-	return reservedWords.includes(str);
-}
-//#endregion
-//#region src/models/schema-definition.ts
-var SchemaDefinition = class SchemaDefinition {
-	name;
-	schema;
-	module;
-	document;
-	get id() {
-		return `${this.module.address.url}#/components/schemas/${this.name}`;
-	}
-	constructor(args) {
-		this.module = args.module;
-		this.name = args.name;
-		this.schema = args.schema;
-		this.document = args.document;
-	}
-	getDependencies() {
-		return ramda.uniq((0, jsonpath_plus.JSONPath)({
-			path: "$..*['$ref']",
-			json: this.schema
-		})).filter((ref) => typeof ref === "string" && !!ref.trim()).map((ref) => {
-			const definition = this.document.dereference(ref);
-			if (definition instanceof SchemaDefinition) return definition;
-			return SchemaDefinition.unknown();
-		}).filter((dep) => dep.id !== this.id);
-	}
-	static unknown() {
-		return new SchemaDefinition({
-			name: "",
-			schema: {},
-			module: ModuleDefinition.unknown(),
-			document: ApiDocumentV3_1.unknown()
-		});
-	}
-	static isUnknown(definition) {
-		return definition.name === "";
-	}
-};
-//#endregion
-//#region src/models/response-definition.ts
-var ResponseDefinition = class ResponseDefinition {
-	name;
-	response;
-	module;
-	document;
-	get id() {
-		return `${this.module.address.url}#/components/responses/${this.name}`;
-	}
-	constructor(args) {
-		this.module = args.module;
-		this.name = args.name;
-		this.response = args.response;
-		this.document = args.document;
-	}
-	getDependencies() {
-		return ramda.uniq((0, jsonpath_plus.JSONPath)({
-			path: "$.content..schema..$['$ref']",
-			json: this.response
-		})).filter((ref) => typeof ref === "string" && !!ref.trim()).map((ref) => {
-			const definition = this.document.dereference(ref);
-			if (definition instanceof SchemaDefinition) return definition;
-			return SchemaDefinition.unknown();
-		}).filter((dep) => dep.id !== this.id);
-	}
-	static unknown() {
-		return new ResponseDefinition({
-			name: "",
-			response: { description: "" },
-			module: ModuleDefinition.unknown(),
-			document: ApiDocumentV3_1.unknown()
-		});
-	}
-	static isUnknown(definition) {
-		return definition.name === "";
-	}
-};
-//#endregion
-//#region src/models/operation-definition.ts
-var OperationDefinition = class {
-	module;
-	operationId;
-	method;
-	pathname;
-	operation;
-	document;
-	get id() {
-		return `${this.module.address.url}#/paths/${this.pathname}/${this.method}`;
-	}
-	constructor(args) {
-		this.module = args.module;
-		this.method = args.method.toLowerCase();
-		this.pathname = args.pathname;
-		this.document = args.document;
-		this.operationId = this.formatOperationId(args.method, args.pathname, args.operation);
-		this.operation = {
-			...args.operation,
-			operationId: this.operationId
-		};
-	}
-	formatOperationId(method, pathname, operation) {
-		const operationId = operation.operationId;
-		if (operationId && operationId !== "index" && !isKeywords(operationId) && !isReservedWord(operationId)) return operationId;
-		return `${method}_${pathname}`.replace(/\//g, "_").replace(/-/g, "_").replace(/:/g, "$$").replace(/{(.+)}/, "$$$1");
-	}
-	getDependencies() {
-		return ramda.uniq([
-			...(0, jsonpath_plus.JSONPath)({
-				path: "$.requestBody.content..schema..$ref",
-				json: this.operation
-			}),
-			...(0, jsonpath_plus.JSONPath)({
-				path: "$.responses..content..schema..$ref",
-				json: this.operation
-			}),
-			...(0, jsonpath_plus.JSONPath)({
-				path: "$.parameters..schema..$ref",
-				json: this.operation
-			})
-		]).filter((ref) => typeof ref === "string" && ref).map((ref) => {
-			const definition = this.document.dereference(ref);
-			if (definition instanceof SchemaDefinition) return definition;
-			return SchemaDefinition.unknown();
-		});
-	}
-	getResponseDependencies() {
-		const responses = this.operation.responses || {};
-		return ramda.uniqBy((dep) => dep.id, Object.values(responses).filter((response) => JsonSchemaUtils.isRef(response)).map((response) => {
-			const definition = this.document.dereference(response.$ref);
-			if (definition instanceof ResponseDefinition) return definition;
-			return ResponseDefinition.unknown();
-		}).filter((dep) => !ResponseDefinition.isUnknown(dep)));
-	}
-};
-//#endregion
-//#region src/models/api-document_v3_1.ts
-var ApiDocumentV3_1 = class ApiDocumentV3_1 {
-	module;
-	specification;
-	constructor(specification, module) {
-		this.module = module;
-		this.specification = specification;
-	}
-	get schemas() {
-		const module = this.module;
-		return Object.entries(this.specification.components?.schemas || {}).map(([name, schema]) => new SchemaDefinition({
-			name,
-			schema,
-			module,
-			document: this
-		}));
-	}
-	get responses() {
-		const module = this.module;
-		return Object.entries(this.specification.components?.responses || {}).filter((entry) => {
-			const [, response] = entry;
-			return typeof response === "object" && !("$ref" in response);
-		}).map(([name, response]) => new ResponseDefinition({
-			name,
-			response,
-			module,
-			document: this
-		}));
-	}
-	get operations() {
-		const module = this.module;
-		return Object.entries(this.specification.paths || {}).flatMap(([pathname, pathItem]) => Object.entries(pathItem || {}).filter(([method]) => SupportedMethods.includes(method.toLowerCase())).map(([method, operation]) => new OperationDefinition({
-			method,
-			pathname,
-			operation,
-			module,
-			document: this
-		})));
-	}
-	isEmpty() {
-		return ramda.isEmpty(this.specification.paths);
-	}
-	dereference($ref) {
-		if ($ref.startsWith("#/")) {
-			if ($ref.startsWith("#/components/responses/")) return this.responses.find((response) => response.id.endsWith($ref));
-			return this.schemas.find((schema) => schema.id.endsWith($ref));
-		}
-		require_logger.logger.warn(`The $ref(${$ref}) is not defined in ${this.module.name} openapi/swagger.`);
-	}
-	isRefDefined($ref) {
-		if ($ref.startsWith("#/")) {
-			const path = $ref.replace("#/", "").split("/");
-			return ramda.path(path, this.specification) !== void 0;
-		}
-		return false;
-	}
-	static unknown() {
-		return new ApiDocumentV3_1({}, ModuleDefinition.unknown());
-	}
-};
-//#endregion
-//#region src/models/asset.ts
-var Asset = class {
-	path;
-	constructor(path) {
-		this.path = path;
-	}
-};
-//#endregion
-//#region src/models/file-tracker.ts
-/**
-* Passive file change tracker based on mtime comparison.
-* Instead of actively watching filesystem events, it checks for changes on demand,
-* suitable for lazy reload of config files in long-lived processes.
-*/
-var FileTracker = class {
-	files = [];
-	reloadPromise = null;
-	async track(filepath) {
-		let mtimeMs = 0;
-		try {
-			mtimeMs = (await fs_extra.default.stat(filepath)).mtimeMs;
-		} catch {}
-		this.files.push({
-			filepath,
-			mtimeMs
-		});
-	}
-	async ensureFresh(reload) {
-		if (!await this.isChanged()) return;
-		if (this.reloadPromise) {
-			await this.reloadPromise;
-			return;
-		}
-		if (!await this.isChanged()) return;
-		this.reloadPromise = reload().finally(() => {
-			this.reloadPromise = null;
-		});
-		await this.reloadPromise;
-	}
-	async forceReload(reload) {
-		if (this.reloadPromise) await this.reloadPromise;
-		this.reloadPromise = reload().finally(() => {
-			this.reloadPromise = null;
-		});
-		await this.reloadPromise;
-	}
-	async snapshot() {
-		for (const file of this.files) try {
-			file.mtimeMs = (await fs_extra.default.stat(file.filepath)).mtimeMs;
-		} catch {
-			file.mtimeMs = 0;
-		}
-	}
-	async isChanged() {
-		for (const file of this.files) try {
-			if ((await fs_extra.default.stat(file.filepath)).mtimeMs !== file.mtimeMs) return true;
-		} catch {
-			if (file.mtimeMs !== 0) return true;
-		}
-		return false;
-	}
-};
-//#endregion
-//#region src/transformers/json-schema/comment.renderer.ts
-var CommentRenderer$1 = class {
-	constructor(schema) {
-		this.schema = schema;
-	}
-	render() {
-		const schema = this.schema;
-		const lines = ["/**"];
-		if (schema.description) {
-			const description = schema.description.replace("*/", "*\\/").replace(/\t/g, "  ").replace(/\r\n?/g, "\n");
-			lines.push(...description.split("\n").map((line) => ` * ${line.trimEnd()}`));
-		}
-		if (schema.deprecated) lines.push(" * @deprecated");
-		if (schema.readOnly) lines.push(" * @readonly");
-		if (schema.format) lines.push(` * @format ${schema.format}`);
-		lines.push(" */");
-		if (lines.length === 2) return "";
-		return lines.join("\n");
-	}
-};
-//#endregion
-//#region src/utils/indent.ts
-function indent(space, text) {
-	if (text === "") return "";
-	const indentation = " ".repeat(space);
-	return text.split("\n").map((line) => line ? `${indentation}${line}` : line).join("\n");
-}
-//#endregion
-//#region src/transformers/json-schema/reference.transformer.ts
-var ReferenceTransformer = class {
-	static toDeclaration(schema, alias = ramda.identity) {
-		if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
-		const parts = schema.$ref.split("/");
-		return alias(parts[parts.length - 1]) || "unknown";
-	}
-	/**
-	* Render the case where the $ref target does not exist
-	*/
-	static toNotFoundDeclaration(schema, hint) {
-		const safeRef = schema.$ref.replace("*/", "*\\/");
-		return `unknown /* ${hint ? `Cannot find $ref "${safeRef}". ${hint}` : `Cannot find $ref "${safeRef}"`} */`;
-	}
-	/**
-	* Render the case where the $ref format is invalid
-	*/
-	static toInvalidDeclaration(schema, hint) {
-		const safeRef = schema.$ref.replace("*/", "*\\/");
-		return `unknown /* ${hint ? `Invalid $ref "${safeRef}". ${hint}` : `Invalid $ref "${safeRef}"`} */`;
-	}
-};
-//#endregion
-//#region src/transformers/json-schema/declaration.renderer.ts
-var DeclarationRenderer$1 = class {
-	constructor(schema, options = {}) {
-		this.schema = schema;
-		this.options = options;
-	}
-	render() {
-		return this.renderSchema(this.schema);
-	}
-	renderSchema(schema) {
-		if (typeof schema === "boolean") return "unknown";
-		if (JsonSchemaUtils.isRef(schema)) return this.renderReference(schema);
-		if (JsonSchemaUtils.isMixed(schema)) return this.renderMixed(schema);
-		if (JsonSchemaUtils.isArray(schema)) return this.renderArray(schema);
-		if (schema.type === "object") return this.renderObject(schema);
-		if (schema.enum) return this.renderEnum(schema);
-		if (schema.oneOf) return this.renderOneOf(schema);
-		if (schema.anyOf) return this.renderAnyOf(schema);
-		if (schema.allOf) return this.renderAllOf(schema);
-		if (schema.type === "string") return this.renderString(schema);
-		if (schema.type === "number") return this.renderNumber(schema);
-		if (schema.type === "boolean") return this.renderBoolean(schema);
-		if (schema.type === "null") return this.renderNull(schema);
-		if (schema.type === "integer") return this.renderInteger(schema);
-		return "unknown";
-	}
-	renderMixed(schema) {
-		if (Array.isArray(schema.type)) return schema.type.map((type) => ({
-			...schema,
-			type
-		})).map((schema) => this.renderSchema(schema)).join(" | ");
-		return "unknown";
-	}
-	renderReference(schema) {
-		if (!this.options.referenceTransformer) return ReferenceTransformer.toDeclaration(schema);
-		return this.options.referenceTransformer(schema);
-	}
-	renderArray(schema) {
-		if (schema.items && Array.isArray(schema.items)) return `[${schema.items.map((s) => this.renderSchema(s)).join(", ")}]`;
-		if (schema.items && typeof schema.items === "object") return `${this.renderSchema(schema.items)}[]`;
-		return "any[]";
-	}
-	renderObject(schema) {
-		const hasProperties = schema.properties && !ramda.isEmpty(schema.properties);
-		const apType = this.options.additionalPropertiesType ?? "unknown";
-		if (!hasProperties) {
-			if (schema.additionalProperties === false) return "Record<string, never>";
-			if (typeof schema.additionalProperties === "object") return `Record<string, ${this.renderSchema(schema.additionalProperties)}>`;
-			return `Record<string, ${apType}>`;
-		}
-		const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
-			let $comment = new CommentRenderer$1(propertySchema).render();
-			if ($comment) $comment += "\n";
-			const $key = `"${propertyName}"${schema.required?.includes(propertyName) ? "" : "?"}`;
-			const $value = this.renderSchema(propertySchema);
-			return indent(2, `${$comment}${$key}: ${$value}`);
-		});
-		if (schema.additionalProperties !== false) if (typeof schema.additionalProperties === "object") $properties.push(indent(2, `[key: string]: ${this.renderSchema(schema.additionalProperties)}`));
-		else $properties.push(indent(2, `[key: string]: ${apType}`));
-		return [
-			"{",
-			...$properties,
-			"}"
-		].join("\n");
-	}
-	renderOneOf(schema) {
-		if (!schema.oneOf) return "unknown";
-		return schema.oneOf.map((s) => this.renderSchema(s)).join(" | ");
-	}
-	renderAnyOf(schema) {
-		if (!schema.anyOf) return "unknown";
-		return schema.anyOf.map((s) => this.renderSchema(s)).join(" | ");
-	}
-	renderAllOf(schema) {
-		if (!schema.allOf) return "unknown";
-		return schema.allOf.map((s) => this.renderSchema(s)).join(" & ");
-	}
-	renderEnum(schema) {
-		if (!schema.enum) return "unknown";
-		return `(${schema.enum.map((v) => JSON.stringify(v)).join(" | ")})`;
-	}
-	renderString(schema) {
-		if (schema.contentMediaType === "application/octet-stream") return "Blob | Buffer";
-		if (schema.format === "binary") return "Blob | Buffer";
-		return "string";
-	}
-	renderNumber(schema) {
-		return "number";
-	}
-	renderBoolean(schema) {
-		return "boolean";
-	}
-	renderNull(schema) {
-		return "null";
-	}
-	renderInteger(schema) {
-		return "number";
-	}
-};
-//#endregion
-//#region src/transformers/json-schema/valibot.renderer.ts
-var ValibotRenderer = class {
-	constructor(schema, options = {}) {
-		this.schema = schema;
-		this.options = options;
-	}
-	render() {
-		return this.renderSchema(this.schema);
-	}
-	renderSchema(schema) {
-		if (typeof schema === "boolean") return "v.unknown()";
-		if (JsonSchemaUtils.isRef(schema)) return this.renderReference(schema);
-		if (JsonSchemaUtils.isMixed(schema)) return this.renderMixed(schema);
-		if (JsonSchemaUtils.isArray(schema)) return this.renderArray(schema);
-		if (schema.type === "object") return this.renderObject(schema);
-		if (schema.enum) return this.renderEnum(schema);
-		if (schema.oneOf) return this.renderOneOf(schema);
-		if (schema.anyOf) return this.renderAnyOf(schema);
-		if (schema.allOf) return this.renderAllOf(schema);
-		if (schema.type === "string") return this.renderString(schema);
-		if (schema.type === "number") return this.renderNumber(schema);
-		if (schema.type === "boolean") return this.renderBoolean(schema);
-		if (schema.type === "null") return this.renderNull(schema);
-		if (schema.type === "integer") return this.renderInteger(schema);
-		return "v.unknown()";
-	}
-	renderMixed(schema) {
-		if (Array.isArray(schema.type)) return `v.union([${schema.type.map((type) => ({
-			...schema,
-			type
-		})).map((schema) => this.renderSchema(schema)).join(", ")}])`;
-		return "v.unknown()";
-	}
-	renderReference(schema) {
-		if (!this.options.referenceTransformer) return ReferenceTransformer.toDeclaration(schema, (name) => `${name}Schema`);
-		return this.options.referenceTransformer(schema);
-	}
-	renderArray(schema) {
-		let result;
-		if (schema.items && Array.isArray(schema.items)) result = `v.tuple([${schema.items.map((s) => this.renderSchema(s)).join(", ")}])`;
-		else if (schema.items && typeof schema.items === "object") result = `v.array(${this.renderSchema(schema.items)})`;
-		else result = "v.array(v.any())";
-		const constraints = [];
-		if (schema.minItems !== void 0) constraints.push(`v.minLength(${schema.minItems})`);
-		if (schema.maxItems !== void 0) constraints.push(`v.maxLength(${schema.maxItems})`);
-		if (constraints.length > 0) result = `v.pipe(${result}, ${constraints.join(", ")})`;
-		return result;
-	}
-	renderObject(schema) {
-		const hasProperties = schema.properties && !ramda.isEmpty(schema.properties);
-		const apType = this.options.additionalPropertiesType ?? "unknown";
-		if (!hasProperties) {
-			if (schema.additionalProperties === false) return "v.object({})";
-			if (typeof schema.additionalProperties === "object") return `v.record(v.string(), ${this.renderSchema(schema.additionalProperties)})`;
-			return `v.record(v.string(), v.${apType}())`;
-		}
-		let result = [
-			"v.object({",
-			...Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
-				let $comment = new CommentRenderer$1(propertySchema).render();
-				if ($comment) $comment += "\n";
-				const $key = `"${propertyName}"`;
-				let $value = this.renderSchema(propertySchema);
-				if (!schema.required?.includes(propertyName)) $value = `v.optional(${$value})`;
-				return indent(2, `${$comment}${$key}: ${$value},`);
-			}),
-			"})"
-		].join("\n");
-		if (schema.additionalProperties !== false) if (typeof schema.additionalProperties === "object") {
-			const $value = this.renderSchema(schema.additionalProperties);
-			result = `v.intersect([${result}, v.record(v.string(), ${$value})])`;
-		} else result = result.replace("v.object({", "v.looseObject({");
-		return result;
-	}
-	renderOneOf(schema) {
-		if (!schema.oneOf) return "v.unknown()";
-		return `v.union([${schema.oneOf.map((s) => this.renderSchema(s)).join(", ")}])`;
-	}
-	renderAnyOf(schema) {
-		if (!schema.anyOf) return "v.unknown()";
-		return `v.union([${schema.anyOf.map((s) => this.renderSchema(s)).join(", ")}])`;
-	}
-	renderAllOf(schema) {
-		if (!schema.allOf || schema.allOf.length === 0) return "v.unknown()";
-		return `v.intersect([${schema.allOf.map((s) => this.renderSchema(s)).join(", ")}])`;
-	}
-	renderEnum(schema) {
-		if (!schema.enum || schema.enum.length === 0) return "v.unknown()";
-		if (schema.enum.length === 1) return `v.literal(${JSON.stringify(schema.enum[0])})`;
-		if (schema.enum.every((v) => typeof v === "string")) return `v.picklist([${schema.enum.map((v) => JSON.stringify(v)).join(", ")}])`;
-		return `v.union([${schema.enum.map((v) => `v.literal(${JSON.stringify(v)})`).join(", ")}])`;
-	}
-	renderString(schema) {
-		if (schema.contentMediaType === "application/octet-stream") return "v.union([v.instance(Blob), v.instance(Buffer)])";
-		if (schema.format === "binary") return "v.union([v.instance(Blob), v.instance(Buffer)])";
-		let result = "v.string()";
-		const constraints = [];
-		if (schema.format === "email") constraints.push("v.email()");
-		else if (schema.format === "uri" || schema.format === "url") constraints.push("v.url()");
-		else if (schema.format === "uuid") constraints.push("v.uuid()");
-		else if (schema.format === "date-time") constraints.push("v.isoDateTime()");
-		else if (schema.format === "date") constraints.push("v.isoDate()");
-		else if (schema.format === "time") constraints.push("v.isoTime()");
-		if (schema.minLength !== void 0) constraints.push(`v.minLength(${schema.minLength})`);
-		if (schema.maxLength !== void 0) constraints.push(`v.maxLength(${schema.maxLength})`);
-		if (schema.pattern) {
-			const escapedPattern = schema.pattern.replace(/\\/g, "\\\\");
-			constraints.push(`v.regex(/${escapedPattern}/)`);
-		}
-		if (constraints.length > 0) result = `v.pipe(${result}, ${constraints.join(", ")})`;
-		return result;
-	}
-	renderNumber(schema) {
-		let result = "v.number()";
-		const constraints = [];
-		if (schema.minimum !== void 0) if (schema.exclusiveMinimum) constraints.push(`v.minValue(${schema.minimum + Number.EPSILON})`);
-		else constraints.push(`v.minValue(${schema.minimum})`);
-		if (schema.maximum !== void 0) if (schema.exclusiveMaximum) constraints.push(`v.maxValue(${schema.maximum - Number.EPSILON})`);
-		else constraints.push(`v.maxValue(${schema.maximum})`);
-		if (schema.multipleOf !== void 0) constraints.push(`v.multipleOf(${schema.multipleOf})`);
-		if (constraints.length > 0) result = `v.pipe(${result}, ${constraints.join(", ")})`;
-		return result;
-	}
-	renderBoolean(schema) {
-		return "v.boolean()";
-	}
-	renderNull(schema) {
-		return "v.null()";
-	}
-	renderInteger(schema) {
-		let result = "v.number()";
-		const constraints = ["v.integer()"];
-		if (schema.minimum !== void 0) if (schema.exclusiveMinimum) constraints.push(`v.minValue(${schema.minimum + 1})`);
-		else constraints.push(`v.minValue(${schema.minimum})`);
-		if (schema.maximum !== void 0) if (schema.exclusiveMaximum) constraints.push(`v.maxValue(${schema.maximum - 1})`);
-		else constraints.push(`v.maxValue(${schema.maximum})`);
-		if (schema.multipleOf !== void 0) constraints.push(`v.multipleOf(${schema.multipleOf})`);
-		result = `v.pipe(${result}, ${constraints.join(", ")})`;
-		return result;
-	}
-};
-//#endregion
-//#region src/transformers/json-schema/json-schema.transformer.ts
-var JsonSchemaTransformer = class {
-	static toComment(schema) {
-		return new CommentRenderer$1(schema).render();
-	}
-	static toDeclaration(schema, options) {
-		return new DeclarationRenderer$1(schema, options).render();
-	}
-	static toValibot(schema, options) {
-		return new ValibotRenderer(schema, options).render();
-	}
-};
-//#endregion
-//#region src/transformers/schema-definition/schema-definition.transformer.ts
-var SchemaDefinitionTransformer = class {
-	static toDeclaration(schemaDefinition, options) {
-		const hint = `Referenced from schema definition "${schemaDefinition.name}".`;
-		const referenceTransformer = (schema) => {
-			if (!schema.$ref || !schema.$ref.startsWith("#")) return ReferenceTransformer.toInvalidDeclaration(schema, hint);
-			if (!schemaDefinition.document.isRefDefined(schema.$ref)) return ReferenceTransformer.toNotFoundDeclaration(schema, hint);
-			return ReferenceTransformer.toDeclaration(schema);
-		};
-		let $dependencies = schemaDefinition.getDependencies().filter((dep) => !SchemaDefinition.isUnknown(dep)).map((dep) => {
-			const filepath = options.getDependentSchemaDefinitionFilepath(dep);
-			return `import type { ${dep.name} } from "${filepath}"`;
-		}).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, options.esm ? " from \"$1.js\"" : " from \"$1\"")).join("\n");
-		if ($dependencies) $dependencies += "\n";
-		let $comment = JsonSchemaTransformer.toComment(schemaDefinition.schema);
-		if ($comment) $comment += "\n";
-		if (typeof schemaDefinition.schema === "boolean") return [
-			"/* @anchor:file:start */",
-			"",
-			$dependencies,
-			$comment || void 0,
-			`type ${schemaDefinition.name} = unknown`,
-			"",
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-		if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
-			const $schema = JsonSchemaTransformer.toDeclaration(schemaDefinition.schema, {
-				referenceTransformer,
-				additionalPropertiesType: options.additionalPropertiesType
-			});
-			const $declaration = $schema.startsWith("{") ? `export interface ${schemaDefinition.name} ${$schema}` : `export type ${schemaDefinition.name} = ${$schema}`;
-			return [
-				"/* @anchor:file:start */",
-				"",
-				$dependencies,
-				$comment || void 0,
-				$declaration,
-				"",
-				"/* @anchor:file:end */"
-			].filter(ramda.isNotNil).join("\n");
-		}
-		return [
-			"/* @anchor:file:start */",
-			"",
-			$dependencies,
-			$comment || void 0,
-			`export type ${schemaDefinition.name} = ${JsonSchemaTransformer.toDeclaration(schemaDefinition.schema, {
-				referenceTransformer,
-				additionalPropertiesType: options.additionalPropertiesType
-			})}`,
-			"",
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-	}
-	static toValibot(schemaDefinition, options) {
-		const hint = `Referenced from schema definition "${schemaDefinition.name}".`;
-		const referenceTransformer = (schema) => {
-			if (!schema.$ref || !schema.$ref.startsWith("#")) return ReferenceTransformer.toInvalidDeclaration(schema, hint).replace(/^unknown/, "v.unknown()");
-			if (!schemaDefinition.document.isRefDefined(schema.$ref)) return ReferenceTransformer.toNotFoundDeclaration(schema, hint).replace(/^unknown/, "v.unknown()");
-			return `v.lazy(() => ${ReferenceTransformer.toDeclaration(schema, (name) => `${name}Schema`)})`;
-		};
-		const declarationReferenceTransformer = (schema) => {
-			if (!schema.$ref || !schema.$ref.startsWith("#")) return ReferenceTransformer.toInvalidDeclaration(schema, hint);
-			if (!schemaDefinition.document.isRefDefined(schema.$ref)) return ReferenceTransformer.toNotFoundDeclaration(schema, hint);
-			return ReferenceTransformer.toDeclaration(schema);
-		};
-		let $dependencies = schemaDefinition.getDependencies().filter((dep) => !SchemaDefinition.isUnknown(dep)).map((dep) => {
-			const filepath = options.getDependentSchemaDefinitionFilepath(dep);
-			return `import { type ${dep.name}, ${dep.name}Schema } from "${filepath}"`;
-		}).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, options.esm ? " from \"$1.js\"" : " from \"$1\"")).join("\n");
-		if ($dependencies) $dependencies += "\n";
-		let $comment = JsonSchemaTransformer.toComment(schemaDefinition.schema);
-		if ($comment) $comment += "\n";
-		const $valibotImport = "import * as v from 'valibot'\n";
-		if (typeof schemaDefinition.schema === "boolean") return [
-			"/* @anchor:file:start */",
-			"",
-			$valibotImport,
-			$dependencies,
-			$comment || void 0,
-			`export const ${schemaDefinition.name}Schema = v.unknown()`,
-			`export type ${schemaDefinition.name} = v.InferOutput<typeof ${schemaDefinition.name}Schema>`,
-			"",
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-		const $schema = JsonSchemaTransformer.toValibot(schemaDefinition.schema, {
-			referenceTransformer,
-			additionalPropertiesType: options.additionalPropertiesType
-		});
-		const $typeSchema = JsonSchemaTransformer.toDeclaration(schemaDefinition.schema, {
-			referenceTransformer: declarationReferenceTransformer,
-			additionalPropertiesType: options.additionalPropertiesType
-		});
-		const $typeDeclaration = $typeSchema.startsWith("{") ? `export interface ${schemaDefinition.name} ${$typeSchema}` : `export type ${schemaDefinition.name} = ${$typeSchema}`;
-		return [
-			"/* @anchor:file:start */",
-			"",
-			$valibotImport,
-			$dependencies,
-			$comment || void 0,
-			$typeDeclaration,
-			`export const ${schemaDefinition.name}Schema: v.GenericSchema<${schemaDefinition.name}> = ${$schema}`,
-			"",
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-	}
-};
-//#endregion
-//#region src/utils/import-alias-manager.ts
-/**
-* Manages import alias naming with collision detection for generated TypeScript files.
-*
-* When generating `import type { X as XSchema }` statements, the alias (e.g., `XSchema`)
-* may collide with fixed names already present in the generated file (e.g., the file's own
-* `export type` name). This class tracks all used names and automatically falls back to
-* numbered suffixes (e.g., `XSchema$1`) when a collision is detected.
-*
-* Usage: call `register()` during import generation, then `resolve()` in referenceTransformer.
-* `register()` must always be called before `resolve()` for the same dependency, because
-* the first `register()` call determines the alias name.
-*/
-var ImportAliasManager = class {
-	/** "category:originalName" → alias */
-	aliasMap = /* @__PURE__ */ new Map();
-	/** All alias names + reserved names currently in use */
-	usedNames = /* @__PURE__ */ new Set();
-	/**
-	* @param reservedNames - Fixed names in the generated file that aliases must not collide with.
-	*   For example, the file's own export type name.
-	*/
-	constructor(reservedNames = []) {
-		for (const name of reservedNames) this.usedNames.add(name);
-	}
-	/**
-	* Register a dependency and return its alias. Idempotent — calling with the same
-	* category + originalName always returns the same alias.
-	*/
-	register(category, originalName) {
-		const key = `${category}:${originalName}`;
-		const existing = this.aliasMap.get(key);
-		if (existing) return existing;
-		let candidate = `${originalName}${category === "schema" ? "Schema" : "Response"}`;
-		if (this.usedNames.has(candidate)) {
-			let i = 1;
-			while (this.usedNames.has(`${candidate}$${i}`)) i++;
-			candidate = `${candidate}$${i}`;
-		}
-		this.aliasMap.set(key, candidate);
-		this.usedNames.add(candidate);
-		return candidate;
-	}
-	/**
-	* Look up alias for an already-registered dependency.
-	* Returns undefined if not yet registered.
-	*/
-	resolve(category, originalName) {
-		return this.aliasMap.get(`${category}:${originalName}`);
-	}
-};
-//#endregion
-//#region src/transformers/response-definition/response-definition.transformer.ts
-var ResponseDefinitionTransformer = class ResponseDefinitionTransformer {
-	static toDeclaration(responseDefinition, options) {
-		const hint = `Referenced from response definition "${responseDefinition.name}".`;
-		const aliasManager = new ImportAliasManager([responseDefinition.name]);
-		let $dependencies = responseDefinition.getDependencies().filter((dep) => !SchemaDefinition.isUnknown(dep)).map((dep) => {
-			const filepath = options.getDependentSchemaDefinitionFilepath(dep);
-			return `import type { ${dep.name} as ${aliasManager.register("schema", dep.name)} } from "${filepath}"`;
-		}).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, options.esm ? " from \"$1.js\"" : " from \"$1\"")).join("\n");
-		if ($dependencies) $dependencies += "\n";
-		const referenceTransformer = (schema) => {
-			if (!schema.$ref || !schema.$ref.startsWith("#")) return ReferenceTransformer.toInvalidDeclaration(schema, hint);
-			if (!responseDefinition.document.isRefDefined(schema.$ref)) return ReferenceTransformer.toNotFoundDeclaration(schema, hint);
-			return ReferenceTransformer.toDeclaration(schema, (name) => aliasManager.resolve("schema", name) ?? `${name}Schema`);
-		};
-		const $type = ResponseDefinitionTransformer.renderContentType(responseDefinition.response, {
-			referenceTransformer,
-			additionalPropertiesType: options.additionalPropertiesType
-		});
-		return [
-			"/* @anchor:file:start */",
-			"",
-			$dependencies,
-			`export type ${responseDefinition.name} = ${$type}`,
-			"",
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-	}
-	static renderContentType(response, options) {
-		const content = response.content;
-		if (!content || ramda.isEmpty(content)) return "void";
-		return Object.entries(content).map(([mediaType, mediaTypeObject]) => {
-			if (mediaType.includes("text/event-stream")) return "ReadableStream<ServerSentEvent>";
-			if (mediaType.includes("multipart/form-data")) return "FormData";
-			if (!mediaTypeObject.schema) return "unknown";
-			return JsonSchemaTransformer.toDeclaration(mediaTypeObject.schema, options);
-		}).join(" | ") || "void";
-	}
-};
-//#endregion
-//#region src/transformers/operation-definition/comment.renderer.ts
-var CommentRenderer = class {
-	constructor(operationDefinition) {
-		this.operationDefinition = operationDefinition;
-	}
-	render() {
-		const operation = this.operationDefinition.operation;
-		if (!operation.summary && !operation.description) return "";
-		const lines = ["/**"];
-		if (operation.summary && typeof operation.summary === "string") {
-			const summary = ramda.trim(operation.summary).replace(/\t/g, "  ").replace(/\r\n?/g, "\n");
-			lines.push(...summary.split("\n").map((line) => ` * ${line.trimEnd()}`));
-			lines.push(" *");
-		}
-		if (operation.description && typeof operation.description === "string") {
-			const descriptionLines = ramda.trim(operation.description).replace(/\t/g, "  ").replace(/\r\n?/g, "\n").split("\n").map((line) => line.trimEnd());
-			lines.push(` * @description ${descriptionLines[0]}`);
-			lines.push(...descriptionLines.slice(1).map((line) => ` * ${line}`));
-		}
-		lines.push(" */");
-		return lines.join("\n");
-	}
-};
-//#endregion
-//#region src/transformers/operation-definition/utils/type-name-factory.ts
-function typeNameFactory(operationDefinition) {
-	const pascalCaseOperationId = change_case.pascalCase(operationDefinition.operationId);
-	return (name) => `${pascalCaseOperationId}${name}`;
-}
-//#endregion
-//#region src/transformers/operation-definition/utils/rewrite-additional-properties-for-parameter.ts
-const PARAMETER_AP_SCHEMAS = {
-	query: { oneOf: [
-		{ type: "string" },
-		{ type: "number" },
-		{ type: "integer" },
-		{ type: "null" }
-	] },
-	path: { oneOf: [
-		{ type: "string" },
-		{ type: "number" },
-		{ type: "integer" },
-		{ type: "boolean" },
-		{ type: "null" }
-	] },
-	header: { oneOf: [
-		{ type: "string" },
-		{ type: "number" },
-		{ type: "integer" }
-	] }
-};
-/**
-* Recursively rewrite `additionalProperties` in object schemas for parameter types.
-* When additionalProperties is `true` or `undefined`, replace it with a keq-compatible schema
-* based on the parameter location (query/path/header).
-*/
-function rewriteAdditionalPropertiesForParameter(schema, parameterIn) {
-	if (JsonSchemaUtils.isRef(schema)) return schema;
-	if (typeof schema === "boolean") return schema;
-	const replacement = PARAMETER_AP_SCHEMAS[parameterIn];
-	if (!replacement) return schema;
-	const cloned = { ...schema };
-	if (cloned.type === "object" || cloned.properties) {
-		if (cloned.additionalProperties === true || cloned.additionalProperties === void 0) cloned.additionalProperties = replacement;
-		else if (typeof cloned.additionalProperties === "object" && !JsonSchemaUtils.isRef(cloned.additionalProperties)) cloned.additionalProperties = rewriteAdditionalPropertiesForParameter(cloned.additionalProperties, parameterIn);
-	}
-	if (cloned.properties) cloned.properties = Object.fromEntries(Object.entries(cloned.properties).map(([key, value]) => [key, rewriteAdditionalPropertiesForParameter(value, parameterIn)]));
-	if (cloned.items && typeof cloned.items === "object" && !Array.isArray(cloned.items)) cloned.items = rewriteAdditionalPropertiesForParameter(cloned.items, parameterIn);
-	for (const keyword of [
-		"allOf",
-		"oneOf",
-		"anyOf"
-	]) if (cloned[keyword]) cloned[keyword] = cloned[keyword].map((s) => rewriteAdditionalPropertiesForParameter(s, parameterIn));
-	return cloned;
-}
-//#endregion
-//#region src/utils/openapi-utils/dereference.ts
-function dereference($ref, swagger) {
-	let value;
-	for (const key of $ref.split("/")) {
-		if (key === "#") value = swagger;
-		else value = value[key];
-		if (!value) break;
-	}
-	return value;
-}
-//#endregion
-//#region src/utils/openapi-utils/is-ref-defined.ts
-function isRefDefined($ref, swagger) {
-	if ($ref.startsWith("#/")) {
-		const path = $ref.replace("#/", "").split("/");
-		return ramda.path(path, swagger) !== void 0;
-	}
-	return false;
-}
-//#endregion
-//#region src/utils/openapi-utils/remove-undefined-ref.ts
-function removeUndefinedRef(swagger) {
-	const shadow = ramda.clone(swagger);
-	const matches = (0, jsonpath_plus.JSONPath)({
-		path: "$..*['$ref']^",
-		json: swagger,
-		resultType: "all"
-	});
-	for (const match of matches) if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) jsonpointer.default.set(shadow, match.pointer, ramda.omit(["$ref"], match.value));
-	return shadow;
-}
-//#endregion
-//#region src/utils/openapi-utils/dereference-operation.ts
-function dereferencePathObject(swagger) {
-	const matches = (0, jsonpath_plus.JSONPath)({
-		path: "$.paths.*.$ref^",
-		json: swagger,
-		resultType: "all"
-	});
-	for (const match of matches) {
-		const value = dereference(match.value.$ref, swagger);
-		jsonpointer.default.set(swagger, match.pointer, value);
-	}
-}
-function dereferenceRequestBody(swagger) {
-	const matches = (0, jsonpath_plus.JSONPath)({
-		path: "$.paths.*.*.requestBody.$ref^",
-		json: swagger,
-		resultType: "all"
-	});
-	for (const match of matches) {
-		const value = dereference(match.value.$ref, swagger);
-		jsonpointer.default.set(swagger, match.pointer, value);
-	}
-}
-function dereferenceResponses(swagger) {
-	const responseMatches = (0, jsonpath_plus.JSONPath)({
-		path: "$.paths.*.*.responses.*.$ref^",
-		json: swagger,
-		resultType: "all"
-	});
-	for (const match of responseMatches) if (match.value.$ref && !match.value.$ref.startsWith("#/components/responses/")) {
-		const value = dereference(match.value.$ref, swagger);
-		jsonpointer.default.set(swagger, match.pointer, value);
-	}
-	const headerMatches = (0, jsonpath_plus.JSONPath)({
-		path: "$.paths.*.*.responses.*.headers.*.$ref^",
-		json: swagger,
-		resultType: "all"
-	});
-	for (const match of headerMatches) {
-		const value = dereference(match.value.$ref, swagger);
-		jsonpointer.default.set(swagger, match.pointer, value);
-	}
-}
-function dereferenceParameters(swagger) {
-	const matches = (0, jsonpath_plus.JSONPath)({
-		path: "$.paths.*.*.parameters.*.$ref^",
-		json: swagger,
-		resultType: "all"
-	});
-	for (const match of matches) {
-		const value = dereference(match.value.$ref, swagger);
-		jsonpointer.default.set(swagger, match.pointer, value);
-	}
-}
-function dereferenceOperation(swagger) {
-	const shadow = ramda.clone(swagger);
-	dereferencePathObject(shadow);
-	dereferenceRequestBody(shadow);
-	dereferenceResponses(shadow);
-	dereferenceParameters(shadow);
-	return removeUndefinedRef(shadow);
-}
-//#endregion
-//#region src/utils/openapi-utils/dereference-deep.ts
-function dereferenceDeep($ref, swagger) {
-	const stack = [$ref];
-	let value;
-	while (true) {
-		const last = stack[stack.length - 1];
-		value = dereference(last, swagger);
-		if (JsonSchemaUtils.isRef(value)) if (!stack.includes(value.$ref)) {
-			stack.push(value.$ref);
-			continue;
-		} else throw new Error(`Circular reference detected: ${stack.join(" -> ")} -> ${value.$ref}`);
-		break;
-	}
-	return value;
-}
-//#endregion
-//#region src/utils/openapi-utils/to-3_1.ts
-function To3_1(openapi) {
-	const { specification } = (0, _scalar_openapi_parser.upgrade)(openapi);
-	return specification;
-}
-//#endregion
-//#region src/utils/openapi-utils/map-operation.ts
-function mapOperation(specification, mapper) {
-	const shadow = ramda.clone(specification);
-	for (const [pathname, pathItem] of Object.entries(shadow.paths || {})) for (const m in pathItem) {
-		const method = m.toLowerCase();
-		if (!SupportedMethods.includes(method)) continue;
-		if (typeof pathItem[m] !== "object" || Array.isArray(pathItem[m]) || pathItem[m] === null) continue;
-		const operation = pathItem[m];
-		pathItem[m] = mapper(method, pathname, operation);
-	}
-	return shadow;
-}
-//#endregion
-//#region src/utils/openapi-utils/map-parameter.ts
-function mapParameter(specification, mapper) {
-	return mapOperation(specification, (method, pathname, operation) => {
-		if (!operation.parameters) return operation;
-		operation.parameters = operation.parameters.map((parameter) => mapper(method, pathname, operation, parameter));
-		return operation;
-	});
-}
-//#endregion
-//#region src/utils/openapi-utils/map-schema.ts
-function walkSchema(schema, mapper) {
-	if (!schema) return schema;
-	if (typeof schema === "boolean") return schema;
-	if ("$ref" in schema) return schema;
-	let result = mapper(schema);
-	if (result.properties) {
-		const newProperties = {};
-		for (const [key, value] of Object.entries(result.properties)) newProperties[key] = walkSchema(value, mapper);
-		result = Object.assign({}, result, { properties: newProperties });
-	}
-	if (typeof result.additionalProperties === "object" && result.additionalProperties !== null && !("$ref" in result.additionalProperties)) result = Object.assign({}, result, { additionalProperties: walkSchema(result.additionalProperties, mapper) });
-	if ("items" in result && result.items && typeof result.items === "object" && !Array.isArray(result.items)) result = Object.assign({}, result, { items: walkSchema(result.items, mapper) });
-	for (const keyword of [
-		"allOf",
-		"oneOf",
-		"anyOf"
-	]) if (result[keyword]) result = Object.assign({}, result, { [keyword]: result[keyword].map((s) => walkSchema(s, mapper)) });
-	return result;
-}
-function walkMediaTypeSchemas(content, mapper) {
-	if (!content) return;
-	for (const mediaType of Object.values(content)) if (mediaType.schema) mediaType.schema = walkSchema(mediaType.schema, mapper);
-}
-/**
-* Recursively walk and transform every non-`$ref` schema in an OpenAPI 3.1 document.
-*
-* Returns a **deep clone** of the document — the original is never mutated.
-* The `mapper` is called on each `SchemaObject` (skipping `$ref` and `boolean` schemas),
-* and then `mapSchema` continues into the mapper's return value to process nested schemas
-* (`properties`, `additionalProperties`, `items`, `allOf`/`oneOf`/`anyOf`).
-*
-* Traversal covers:
-* - `components.schemas`
-* - Inline schemas in operation parameters, request bodies, and responses
-*
-* @example
-* // Set `additionalProperties: false` on every object schema that doesn't define it
-* const patched = mapSchema(doc, (schema) => {
-*   if ((schema.type === 'object' || schema.properties) && schema.additionalProperties === undefined) {
-*     return Object.assign({}, schema, { additionalProperties: false })
-*   }
-*   return schema
-* })
-*
-* @example
-* // Add a `description` fallback to all string schemas
-* const annotated = mapSchema(doc, (schema) => {
-*   if (schema.type === 'string' && !schema.description) {
-*     return Object.assign({}, schema, { description: 'No description provided' })
-*   }
-*   return schema
-* })
-*/
-function mapSchema(specification, mapper) {
-	const shadow = ramda.clone(specification);
-	if (shadow.components?.schemas) for (const [name, schema] of Object.entries(shadow.components.schemas)) shadow.components.schemas[name] = walkSchema(schema, mapper);
-	for (const [, pathItem] of Object.entries(shadow.paths || {})) for (const m in pathItem) {
-		const method = m.toLowerCase();
-		if (!SupportedMethods.includes(method)) continue;
-		if (typeof pathItem[m] !== "object" || Array.isArray(pathItem[m]) || pathItem[m] === null) continue;
-		const operation = pathItem[m];
-		if (operation.parameters) for (const param of operation.parameters) {
-			if ("$ref" in param) continue;
-			if (param.schema) param.schema = walkSchema(param.schema, mapper);
-		}
-		if (operation.requestBody && !("$ref" in operation.requestBody)) walkMediaTypeSchemas(operation.requestBody.content, mapper);
-		if (operation.responses) for (const response of Object.values(operation.responses)) {
-			if ("$ref" in response) continue;
-			walkMediaTypeSchemas(response.content, mapper);
-		}
-	}
-	return shadow;
-}
-//#endregion
-//#region src/utils/openapi-utils/index.ts
-var OpenapiUtils = class {
-	static isRefDefined = isRefDefined;
-	static dereference = dereference;
-	static dereferenceDeep = dereferenceDeep;
-	static removeUndefinedRef = removeUndefinedRef;
-	static dereferenceOperation = dereferenceOperation;
-	static mapOperation = mapOperation;
-	static mapParameter = mapParameter;
-	static mapSchema = mapSchema;
-	static to3_1 = To3_1;
-};
-//#endregion
-//#region src/transformers/operation-definition/declaration.renderer.ts
-const alias = (name) => `${name}Schema`;
-const responseAlias = (name) => `${name}Response`;
-var DeclarationRenderer = class {
-	typeName;
-	constructor(operationDefinition, options) {
-		this.operationDefinition = operationDefinition;
-		this.options = options;
-		this.typeName = typeNameFactory(operationDefinition);
-	}
-	renderResponseBodies(operation, options) {
-		if (!operation.responses || ramda.isEmpty(operation.responses)) return `export interface ${this.typeName("ResponseBodies")} {}`;
-		const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
-			if (JsonSchemaUtils.isRef(response)) return indent(2, `${statusCode}: ${responseAlias(response.$ref.split("/").pop() || "")}`);
-			return indent(2, `${statusCode}: ${Object.entries(response.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
-				if (mediaType.includes("text/event-stream")) return "ReadableStream<ServerSentEvent>";
-				if (mediaType.includes("multipart/form-data")) return "FormData";
-				if (!schema) return "unknown";
-				return JsonSchemaTransformer.toDeclaration(schema, options);
-			}).join(" | ") || "void"}`);
-		}).join("\n");
-		return [
-			`export interface ${this.typeName("ResponseBodies")} {`,
-			$responses,
-			"}"
-		].join("\n");
-	}
-	renderRequestBodies(operation, options) {
-		let $requestBodies = `export interface ${this.typeName("RequestBodies")} {}`;
-		if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-			const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
-				if (!schema) return `${JSON.stringify(mediaType)}: unknown`;
-				return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schema, options)}`;
-			}).map((pair) => indent(2, pair));
-			$requestBodies = [
-				`export interface ${this.typeName("RequestBodies")} {`,
-				...$mediaTypes,
-				"}"
-			].join("\n");
-		}
-		return $requestBodies;
-	}
-	renderParameterBodies(operationDefinition, options) {
-		const { operation } = operationDefinition;
-		let parameterBodies = "";
-		if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-			const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schemaOrRef]) => {
-				if (!schemaOrRef) return `${JSON.stringify(mediaType)}: unknown`;
-				const schema = JsonSchemaUtils.isRef(schemaOrRef) ? OpenapiUtils.dereferenceDeep(schemaOrRef.$ref, operationDefinition.document.specification) : schemaOrRef;
-				if (schema.type === "object" || schema.properties) return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schemaOrRef, options)} & { [key: string]: any }`;
-				return `${JSON.stringify(mediaType)}: { [key: string]: any }`;
-			}).map((pair) => indent(2, pair));
-			parameterBodies = [
-				`interface ${this.typeName("ParameterBodies")} {`,
-				...$mediaTypes,
-				"}",
-				""
-			].join("\n");
-		}
-		return parameterBodies;
-	}
-	renderRequestParameters(operation, options) {
-		const mediaTypes = operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody) ? Object.keys(operation.requestBody.content || {}) : [];
-		const base = `${this.typeName("RequestQuery")} & ${this.typeName("RouteParameters")} & ${this.typeName("RequestHeaders")}`;
-		if (mediaTypes.length === 1) return `export type ${this.typeName("RequestParameters")} = ${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaTypes[0])}]`;
-		if (mediaTypes.length > 1) {
-			const unions = mediaTypes.map((mediaType) => `(${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaType)}] & { "content-type": ${JSON.stringify(mediaType)} })`).join("\n| ");
-			return `export type ${this.typeName("RequestParameters")} = ${unions}`;
-		}
-		return `export type ${this.typeName("RequestParameters")} = ${base}`;
-	}
-	rendererParameters(name, parameters, options) {
-		if (parameters.length === 0) return `export type ${name} = {}`;
-		const $parameters = parameters.map((parameter) => {
-			const parameterName = `"${parameter.name}"`;
-			const $key = parameter.required ? parameterName : `${parameterName}?`;
-			const schema = parameter.schema ? rewriteAdditionalPropertiesForParameter(parameter.schema, parameter.in) : { type: "any" };
-			return indent(2, `${$key}: ${JsonSchemaTransformer.toDeclaration(schema, options)}`);
-		}).join("\n");
-		return [
-			`export type ${name} = {`,
-			$parameters,
-			"}"
-		].filter(Boolean).join("\n");
-	}
-	renderDependencies() {
-		const $schemaDefinitions = this.operationDefinition.getDependencies().filter((schemaDefinition) => !SchemaDefinition.isUnknown(schemaDefinition)).map((schemaDefinition) => {
-			const filepath = this.options.getDependentSchemaDefinitionFilepath(schemaDefinition);
-			const schemaName = schemaDefinition.name;
-			return `import type { ${schemaName} as ${alias(schemaName)} } from "${filepath}"`;
-		}).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? " from \"$1.js\"" : " from \"$1\""));
-		const $responseDefinitions = this.operationDefinition.getResponseDependencies().filter((responseDefinition) => !ResponseDefinition.isUnknown(responseDefinition)).map((responseDefinition) => {
-			const filepath = this.options.getDependentResponseDefinitionFilepath(responseDefinition);
-			const responseName = responseDefinition.name;
-			return `import type { ${responseName} as ${responseAlias(responseName)} } from "${filepath}"`;
-		}).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? " from \"$1.js\"" : " from \"$1\""));
-		return [
-			"import type { KeqOperation, KeqPathParameterInit, KeqQueryInit, ServerSentEvent } from \"keq\"",
-			...$schemaDefinitions,
-			...$responseDefinitions
-		].join("\n");
-	}
-	render() {
-		const { operation } = this.operationDefinition;
-		if (!operation.responses) return "";
-		const hint = `Referenced from operation "${this.operationDefinition.method.toUpperCase()} ${this.operationDefinition.pathname}".`;
-		const jsonSchemaDeclarationRendererOptions = {
-			referenceTransformer: (schema) => {
-				if (schema.$ref && schema.$ref.startsWith("#") && !this.operationDefinition.document.isRefDefined(schema.$ref)) return ReferenceTransformer.toNotFoundDeclaration(schema, hint);
-				return ReferenceTransformer.toDeclaration(schema, alias);
-			},
-			additionalPropertiesType: this.options.additionalPropertiesType
-		};
-		const $dependencies = this.renderDependencies();
-		const $responseBodies = this.renderResponseBodies(operation, jsonSchemaDeclarationRendererOptions);
-		const $requestBodies = this.renderRequestBodies(operation, jsonSchemaDeclarationRendererOptions);
-		const $parameterBodies = this.renderParameterBodies(this.operationDefinition, jsonSchemaDeclarationRendererOptions);
-		const $requestParameters = this.renderRequestParameters(operation, jsonSchemaDeclarationRendererOptions);
-		return [
-			"/* @anchor:file:start */",
-			"",
-			$dependencies,
-			"",
-			$responseBodies,
-			"",
-			$requestBodies,
-			"",
-			this.rendererParameters(`${this.typeName("RequestQuery")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "query") || [], jsonSchemaDeclarationRendererOptions),
-			"",
-			this.rendererParameters(`${this.typeName("RouteParameters")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "path") || [], jsonSchemaDeclarationRendererOptions),
-			"",
-			this.rendererParameters(`${this.typeName("RequestHeaders")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "header") || [], jsonSchemaDeclarationRendererOptions),
-			"",
-			$parameterBodies || void 0,
-			$requestParameters,
-			"",
-			`export interface ${this.typeName("Operation")}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends ${$parameterBodies ? `keyof ${this.typeName("ParameterBodies")}` : "string"} > extends KeqOperation {`,
-			`  requestParams: ${this.typeName("RouteParameters")} & { [key: string]: KeqPathParameterInit }`,
-			`  requestQuery: ${this.typeName("RequestQuery")} & { [key: string]: KeqQueryInit }`,
-			`  requestHeaders: ${this.typeName("RequestHeaders")} & { [key: string]: string | number }`,
-			`  requestBody: ${$parameterBodies ? `${this.typeName("ParameterBodies")}[CONTENT_TYPE] | ` : "object | "}BodyInit`,
-			`  responseBody: ${this.typeName("ResponseBodies")}[STATUS]`,
-			"}",
-			"",
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-	}
-};
-//#endregion
-//#region src/utils/to-safe-identifier.ts
-/**
-* Check if a string is a valid JavaScript/TypeScript identifier.
-*/
-function isValidIdentifier(str) {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str);
-}
-/**
-* Convert a string to a valid JavaScript/TypeScript identifier.
-* If the string is already a valid identifier, return it as-is.
-* Otherwise, convert it to camelCase and ensure it starts with a valid character.
-*/
-function toSafeIdentifier(str) {
-	if (isValidIdentifier(str)) return str;
-	const camelCased = change_case.camelCase(str);
-	if (!camelCased) return `_${str.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
-	if (/^[0-9]/.test(camelCased)) return `_${camelCased}`;
-	if (!isValidIdentifier(camelCased)) return `_${camelCased.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
-	return camelCased;
-}
-//#endregion
-//#region src/exception.ts
-var Exception = class extends ts_custom_error.CustomError {
-	constructor(module, message) {
-		const moduleName = typeof module === "string" ? module : module.name;
-		const msg = (0, word_wrap.default)(message, {
-			width: 60,
-			indent: "    "
-		});
-		super(`${moduleName} module failed to compile:\n${msg}`);
-		Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
-	}
-};
-//#endregion
-//#region src/transformers/operation-definition/typescript-snippet.ts
-var OperationDefinitionSnippet = class {
-	typeName;
-	constructor(operationDefinition, options) {
-		this.operationDefinition = operationDefinition;
-		this.options = options;
-		this.typeName = typeNameFactory(operationDefinition);
-	}
-	getQsParameters(parameter) {
-		let arrayFormat;
-		let allowDots;
-		let indices;
-		const style = parameter.style || "form";
-		const explode = parameter.explode ?? true;
-		if ("x-qs-array-format" in parameter) arrayFormat = parameter["x-qs-array-format"];
-		else if (style === "deepObject") arrayFormat = "brackets";
-		else if (explode) arrayFormat = "repeat";
-		else if (style === "form") arrayFormat = "comma";
-		else if (style === "spaceDelimited") arrayFormat = "space";
-		else if (style === "pipeDelimited") arrayFormat = "pipe";
-		if ("x-qs-allow-dots" in parameter) allowDots = Boolean(parameter["x-qs-allow-dots"]);
-		if ("x-qs-indices" in parameter) indices = Boolean(parameter["x-qs-indices"]);
-		if (arrayFormat || allowDots !== void 0 || indices !== void 0) return {
-			...arrayFormat ? { arrayFormat } : {},
-			...allowDots !== void 0 ? { allowDots } : {},
-			...indices !== void 0 ? { indices } : {}
-		};
-	}
-	renderRequestHeaders() {
-		const { operation } = this.operationDefinition;
-		return (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "header").map((p) => `if (args && ${JSON.stringify(p.name)} in args) req.header(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).join("\n");
-	}
-	renderRequestQuery() {
-		const { operation } = this.operationDefinition;
-		return (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
-			const option = this.getQsParameters(p);
-			const $option = !option || ramda.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
-			return `if (args && ${JSON.stringify(p.name)} in args) req.query(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}]${$option})`;
-		}).join("\n");
-	}
-	renderRequestPathParameters() {
-		const { operation } = this.operationDefinition;
-		return (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "path").map((p) => `if (args && ${JSON.stringify(p.name)} in args) req.params(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).join("\n");
-	}
-	getRequestMediaTypes() {
-		const { operation } = this.operationDefinition;
-		const requestBodyContent = operation.requestBody?.content || {};
-		return Object.keys(requestBodyContent);
-	}
-	renderMediaType() {
-		const mediaTypes = this.getRequestMediaTypes();
-		if (mediaTypes.length === 1 && !mediaTypes[0].endsWith("/*")) return `req.type("${mediaTypes[0]}")\n`;
-		else if (mediaTypes.some((mediaType) => mediaType === "*/*")) {} else if (mediaTypes.some((mediaType) => mediaType.endsWith("/*"))) return "if(args?.[\"content-type\"]) req.type(args[\"content-type\"])\n";
-		else if (mediaTypes.length > 1) return "if(args?.[\"content-type\"]) req.type(args[\"content-type\"])\n";
-		return "";
-	}
-	requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType) {
-		try {
-			const $propertyName = JSON.stringify(propertyName);
-			const schema = JsonSchemaUtils.isRef(propertySchema) ? OpenapiUtils.dereferenceDeep(propertySchema.$ref, this.operationDefinition.document.specification) : propertySchema;
-			if (schema.type === "string" && schema.format === "binary" || schema.contentMediaType === "application/octet-stream") return `if (args && ${$propertyName} in args && args[${$propertyName}]) req.attach(${$propertyName}, args[${$propertyName}])`;
-			else if (schema.type === "string" || schema.type === "array" && schema.items && schema.items.type === "string") return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, args[${$propertyName}])`;
-			else if (schema.type === "number" || schema.type === "integer") return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, String(args[${$propertyName}]))`;
-			return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, String(args[${$propertyName}]) /* type is non-string in schema; triggers type coercion here */)`;
-		} catch (err) {
-			return this.renderErrorComment(err, mediaType);
-		}
-	}
-	requestBodyPropertyRenderer(propertyName, propertySchema, mediaType) {
-		if (mediaType === "application/json") {
-			const $propertyName = JSON.stringify(propertyName);
-			return `if (args && ${$propertyName} in args) req.send({ ${$propertyName}: args[${$propertyName}] })`;
-		} else if (mediaType === "multipart/form-data") return this.requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType);
-		else throw new Error(`Unsupported media type: ${mediaType}`);
-	}
-	renderRequestBody() {
-		const { operation } = this.operationDefinition;
-		const requestBodyContent = operation.requestBody?.content || {};
-		return Object.entries(requestBodyContent).map(([mediaType, mediaTypeObject]) => {
-			if (!mediaTypeObject.schema) return;
-			try {
-				const schema = JsonSchemaUtils.isRef(mediaTypeObject.schema) ? OpenapiUtils.dereferenceDeep(mediaTypeObject.schema.$ref, this.operationDefinition.document.specification) : mediaTypeObject.schema;
-				if (schema.type !== "object") return;
-				const properties = schema.properties || {};
-				return Object.entries(properties).map(([propertyName, propertySchema]) => this.requestBodyPropertyRenderer(propertyName, propertySchema, mediaType)).join("\n");
-			} catch (err) {
-				return this.renderErrorComment(err, mediaType);
-			}
-		}).filter(ramda.isNotNil).join("\n");
-	}
-	renderErrorComment(err, mediaType) {
-		const $err = String(err).split("\n").map(((line) => ` * ${line}`)).join("\n");
-		return [
-			"/**",
-			` * Unable to dereference schema for media type ${mediaType}`,
-			$err,
-			" */"
-		].join("\n");
-	}
-};
-//#endregion
-//#region src/transformers/operation-definition/micro-function.renderer.ts
-var OperationDefinitionMicroFunctionRenderer = class {
-	helper;
-	typeName;
-	constructor(operationDefinition, options) {
-		this.operationDefinition = operationDefinition;
-		this.options = options;
-		this.typeName = typeNameFactory(operationDefinition);
-		this.helper = new OperationDefinitionSnippet(operationDefinition, options);
-	}
-	get operationId() {
-		return toSafeIdentifier(this.operationDefinition.operationId);
-	}
-	render() {
-		const { operation, method, pathname } = this.operationDefinition;
-		if (!operation.responses) return "";
-		const operationId = this.operationId;
-		const $dependencies = this.renderDependencies();
-		const $comment = new CommentRenderer(this.operationDefinition).render();
-		const $method = method.toLowerCase();
-		const $queryParameters = this.helper.renderRequestQuery();
-		const $headerParameters = this.helper.renderRequestHeaders();
-		const $pathParameters = this.helper.renderRequestPathParameters();
-		const $mediaType = this.helper.renderMediaType();
-		const $requestBody = this.helper.renderRequestBody();
-		const $operationDeclaration = this.renderOperationDeclaration();
-		return [
-			"/* @anchor:file:start */",
-			"",
-			$dependencies,
-			"",
-			`const method = "${method}"`,
-			`const pathname = "${pathname}"`,
-			"",
-			$comment || void 0,
-			`export ${$operationDeclaration} {`,
-			`  const req = request.${$method}<${this.typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
-			"",
-			$mediaType ? indent(2, $mediaType) : void 0,
-			"  /* @anchor:query:start */",
-			$queryParameters ? indent(2, $queryParameters) : void 0,
-			"  /* @anchor:query:end */",
-			"",
-			"  /* @anchor:headers:start */",
-			$headerParameters ? indent(2, $headerParameters) : void 0,
-			"  /* @anchor:headers:end */",
-			"",
-			"  /* @anchor:path-parameters:start */",
-			$pathParameters ? indent(2, $pathParameters) : void 0,
-			"  /* @anchor:path-parameters:end */",
-			"",
-			"  /* @anchor:body:start */",
-			$requestBody ? indent(2, $requestBody) : void 0,
-			"  /* @anchor:body:end */",
-			"",
-			"  /* @anchor:operation-return */",
-			`  return req as ReturnType<typeof ${operationId}<STATUS${$operationDeclaration.includes("CONTENT_TYPE") ? ", CONTENT_TYPE" : ""}>>`,
-			"}",
-			"",
-			`${operationId}.pathname = pathname`,
-			`${operationId}.method = method`,
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-	}
-	renderDependencies() {
-		const declarationFilepath = this.options.getOperationDefinitionDeclarationFilepath(this.operationDefinition);
-		return [
-			"import { Keq } from \"keq\"",
-			`import { request } from "${this.options.getRequestFilepath()}"`,
-			`import type { ${this.typeName("Operation")}, ${this.typeName("ResponseBodies")}, ${this.typeName("RequestParameters")} } from "${declarationFilepath}"`,
-			`export type { ${this.typeName("RequestQuery")}, ${this.typeName("RequestHeaders")}, ${this.typeName("RequestBodies")} } from "${declarationFilepath}"`
-		].map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? " from \"$1.js\"" : " from \"$1\"")).join("\n");
-	}
-	renderOperationDeclaration() {
-		const operationId = this.operationId;
-		const mediaTypes = this.helper.getRequestMediaTypes();
-		if (mediaTypes.length === 0) return `function ${operationId}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends never = never>(args?: ${this.typeName("RequestParameters")}): Keq<${this.typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-		else if (mediaTypes.length === 1) return `function ${operationId}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends ${JSON.stringify(mediaTypes[0])} = ${JSON.stringify(mediaTypes[0])}>(args?: ${this.typeName("RequestParameters")}): Keq<${this.typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-		else if (mediaTypes.length > 1) return `function ${operationId}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends ${this.typeName("RequestParameters")}["content-type"]>(args?: Extract<${this.typeName("RequestParameters")}, { "content-type": CONTENT_TYPE }>): Keq<${this.typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-		throw new Exception(this.operationDefinition.module, "[operationDeclarationRenderer] Unreachable");
-	}
-};
-//#endregion
-//#region src/transformers/operation-definition/nestjs-method.renderer.ts
-var OperationDefinitionNestjsMethodRenderer = class {
-	helper;
-	typeName;
-	constructor(operationDefinition, options) {
-		this.operationDefinition = operationDefinition;
-		this.options = options;
-		this.typeName = typeNameFactory(operationDefinition);
-		this.helper = new OperationDefinitionSnippet(operationDefinition, options);
-	}
-	get operationId() {
-		return toSafeIdentifier(this.operationDefinition.operationId);
-	}
-	render() {
-		const pathname = this.operationDefinition.pathname;
-		const $comment = new CommentRenderer(this.operationDefinition).render();
-		const $method = this.operationDefinition.method.toLowerCase();
-		const $mediaType = this.helper.renderMediaType();
-		const $operationDeclaration = this.renderOperationDeclaration(this.operationDefinition);
-		const $queryParameters = this.helper.renderRequestQuery();
-		const $headerParameters = this.helper.renderRequestHeaders();
-		const $pathParameters = this.helper.renderRequestPathParameters();
-		const $requestBody = this.helper.renderRequestBody();
-		return [
-			$comment,
-			`${$operationDeclaration} {`,
-			`  const req = this.request.${$method}<${this.typeName("ResponseBodies")}[STATUS]>(${JSON.stringify(pathname)})`,
-			"",
-			$mediaType ? indent(2, $mediaType) : void 0,
-			"",
-			"  /* @anchor:query:start */",
-			$queryParameters ? indent(2, $queryParameters) : void 0,
-			"  /* @anchor:query:end */",
-			"",
-			"  /* @anchor:headers:start */",
-			$headerParameters ? indent(2, $headerParameters) : void 0,
-			"  /* @anchor:headers:end */",
-			"",
-			"  /* @anchor:path-parameters:start */",
-			$pathParameters ? indent(2, $pathParameters) : void 0,
-			"  /* @anchor:path-parameters:end */",
-			"",
-			"  /* @anchor:body:start */",
-			$requestBody ? indent(2, $requestBody) : void 0,
-			"  /* @anchor:body:end */",
-			"",
-			"  return req",
-			"}"
-		].filter(ramda.isNotNil).join("\n");
-	}
-	renderOperationDeclaration(operationDefinition) {
-		const operationId = this.operationId;
-		const typeName = typeNameFactory(operationDefinition);
-		const mediaTypes = this.helper.getRequestMediaTypes();
-		if (mediaTypes.length === 0) return `${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends never = never>(args?: ${typeName("RequestParameters")}): Keq<${typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-		else if (mediaTypes.length === 1) return `${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${JSON.stringify(mediaTypes[0])} = ${JSON.stringify(mediaTypes[0])}>(args?: ${typeName("RequestParameters")}): Keq<${typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-		else if (mediaTypes.length > 1) return `${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${typeName("RequestParameters")}["content-type"]>(args?: Extract<${typeName("RequestParameters")}, { "content-type": CONTENT_TYPE }>): Keq<${typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-		throw new Exception(operationDefinition.module, "[operationDeclarationRenderer] Unreachable");
-	}
-};
-//#endregion
-//#region src/transformers/operation-definition/operation-definition.transformer.ts
-var OperationDefinitionTransformer = class {
-	static toDeclaration(operationDefinition, options) {
-		return new DeclarationRenderer(operationDefinition, options).render();
-	}
-	static toMicroFunction(operationDefinition, options) {
-		return new OperationDefinitionMicroFunctionRenderer(operationDefinition, options).render();
-	}
-	static toNestjsMethod(operationDefinition, options) {
-		return new OperationDefinitionNestjsMethodRenderer(operationDefinition, options).render();
-	}
-	static toComment(operationDefinition) {
-		return new CommentRenderer(operationDefinition).render();
-	}
-};
-//#endregion
-//#region src/transformers/entrypoint/entrypoint.transformer.ts
-var EntrypointTransformer = class {
-	static toTypescript(exports, options) {
-		return [
-			"/* @anchor:file:start */",
-			"",
-			...exports.map((exportArtifact) => {
-				const relativePath = path.relative(options.dirpath, exportArtifact.filepath).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, options.esm ? ".js" : "");
-				return relativePath.startsWith(".") ? `export * from '${relativePath}'` : `export * from './${relativePath}'`;
-			}),
-			"",
-			"/* @anchor:file:end */"
-		].join("\n");
-	}
-};
-//#endregion
-//#region src/transformers/api-document/nestjs-client.renderer.ts
-var NestjsClientRenderer = class {
-	constructor(document, options) {
-		this.document = document;
-		this.options = options;
-	}
-	renderDependencies() {
-		return [
-			"import { Injectable, Logger } from \"@nestjs/common\"",
-			"import { Keq, KeqRequest } from \"keq\"",
-			...this.document.operations.map((operationDefinition) => {
-				const filepath = this.options.getOperationDefinitionDeclarationFilepath(operationDefinition);
-				const typeName = typeNameFactory(operationDefinition);
-				return `import type { ${typeName("Operation")}, ${typeName("ResponseBodies")}, ${typeName("RequestParameters")} } from "${filepath}"`;
-			}).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? " from \"$1.js\"" : " from \"$1\""))
-		].join("\n");
-	}
-	render() {
-		const moduleName = change_case.pascalCase(this.document.module.name);
-		const $dependencies = this.renderDependencies();
-		const $operations = this.document.operations.map((operation) => OperationDefinitionTransformer.toNestjsMethod(operation, { esm: this.options.esm })).join("\n\n");
-		return [
-			"/* @anchor:file:start */",
-			"",
-			$dependencies,
-			"",
-			"@Injectable()",
-			`export class ${moduleName}Client {`,
-			`  private readonly logger = new Logger(${moduleName}Client.name)`,
-			"",
-			"  constructor(",
-			"    // @anchor:client-constructor-parameters:start",
-			"    private readonly request: KeqRequest,",
-			"    // @anchor:client-constructor-parameters:end",
-			"  ) {}",
-			"",
-			indent(2, $operations),
-			"}",
-			"",
-			"/* @anchor:file:end */"
-		].filter(ramda.isNotNil).join("\n");
-	}
-};
-//#endregion
-//#region src/transformers/api-document/nestjs-module.renderer.ts
-var NestjsModuleRenderer = class {
-	constructor(document, options) {
-		this.document = document;
-		this.options = options;
-	}
-	render() {
-		const moduleName = change_case.pascalCase(this.document.module.name);
-		return [
-			"/* @anchor:file:start */",
-			"import { Module, ConfigurableModuleBuilder, Provider } from \"@nestjs/common\"",
-			"import { KeqRequest } from \"keq\"",
-			"import { KeqModule, type KeqModuleOptions } from \"@keq-request/nestjs\"",
-			`import { ${moduleName}Client } from "${this.options.getNestjsClientFilepath(this.document).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, this.options.esm ? ".js" : "")}"`,
-			"",
-			"",
-			`export interface ${moduleName}ModuleOptions extends KeqModuleOptions {`,
-			"  /**",
-			"   * Whether to register the module globally.",
-			"   * @default false",
-			"   */",
-			"  isGlobal?: boolean",
-			"}",
-			"",
-			`const KEQ_REQUEST_TOKEN = Symbol("${moduleName}KeqRequest")`,
-			"",
-			`const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBuilder<${moduleName}ModuleOptions>()`,
-			"  .setExtras({ isGlobal: false }, (definition, extras) => ({",
-			"    ...definition,",
-			"    global: extras.isGlobal,",
-			"  }))",
-			"  .build()",
-			"",
-			"const REQUEST_PROVIDER: Provider = {",
-			"  provide: KEQ_REQUEST_TOKEN,",
-			`  useFactory: (options: ${moduleName}ModuleOptions, globalRequest?: KeqRequest) => {`,
-			"",
-			"    if (!options.isolate && !globalRequest) {",
-			`      console.warn("${moduleName}Module: No global KeqRequest found, creating an isolated instance. Import KeqModule globally or set { isolate: true } to suppress this warning.")`,
-			"    }",
-			"",
-			"    const request = (!options.isolate && globalRequest)",
-			"      ? globalRequest.fork()",
-			"      : new KeqRequest()",
-			"",
-			"    if (options.middlewares) {",
-			"      for (const middleware of options.middlewares) {",
-			"        request.use(middleware)",
-			"      }",
-			"    }",
-			"",
-			"    return request",
-			"  },",
-			"  inject: [",
-			"    MODULE_OPTIONS_TOKEN,",
-			"    { token: KeqRequest, optional: true },",
-			"  ],",
-			"}",
-			"",
-			"const CLIENT_PROVIDER: Provider = {",
-			`  provide: ${moduleName}Client,`,
-			`  useFactory: (request: KeqRequest) => new ${moduleName}Client(request),`,
-			"  inject: [KEQ_REQUEST_TOKEN],",
-			"}",
-			"",
-			"/**",
-			` * NestJS module that provides the {@link ${moduleName}Client} for dependency injection.`,
-			" *",
-			" * This module requires a `KeqRequest` instance, which can be provided in two ways:",
-			" *",
-			" * **Option 1: Use the global `KeqModule` (recommended)**",
-			" *",
-			" * Import `KeqModule` globally, then register this module.",
-			" * The module will fork from the global KeqRequest and inherit its middlewares.",
-			" *",
-			" * ```typescript",
-			" * // app.module.ts",
-			" * import { KeqModule } from '@keq-request/nestjs'",
-			" * ",
-			" * @Module({",
-			" *   imports: [",
-			" *     KeqModule,",
-			` *     ${moduleName}Module.register({`,
-			" *       isGlobal: true, // optional, default false",
-			" *       middlewares: [], // module-level middlewares",
-			" *     }),",
-			" *   ],",
-			" * })",
-			" * export class AppModule {}",
-			" * ```",
-			" *",
-			" * **Option 2: Provide an isolated `KeqRequest` instance**",
-			" *",
-			" * ```typescript",
-			" * @Module({",
-			" *   imports: [",
-			` *     ${moduleName}Module.register({`,
-			" *       isolate: true, // no inherited middlewares",
-			" *     }),",
-			" *   ],",
-			" * })",
-			" * export class SomeFeatureModule {}",
-			" * ```",
-			" *",
-			" * Then inject `" + moduleName + "Client` in your services:",
-			" *",
-			" * ```typescript",
-			" * @Injectable()",
-			" * export class SomeService {",
-			` *   constructor(private readonly client: ${moduleName}Client) {}`,
-			" * }",
-			" * ```",
-			" */",
-			"@Module({",
-			"  imports: [KeqModule],",
-			"  providers: [REQUEST_PROVIDER, CLIENT_PROVIDER],",
-			`  exports: [${moduleName}Client],`,
-			"})",
-			`export class ${moduleName}Module extends ConfigurableModuleClass {`,
-			`  static readonly KEQ_REQUEST = KEQ_REQUEST_TOKEN`,
-			"}",
-			"",
-			"/* @anchor:file:end */"
-		].join("\n");
-	}
-};
-//#endregion
-//#region src/transformers/api-document/api-document.transformer.ts
-var ApiDocumentTransformer = class {
-	static toNestjsModule(document, options) {
-		return new NestjsModuleRenderer(document, options).render();
-	}
-	static toNestjsClient(document, options) {
-		return new NestjsClientRenderer(document, options).render();
-	}
-};
-//#endregion
-//#region src/plugins/generate-declaration/constants/metadata-storage.ts
-const MetadataStorage$9 = new PluginMetadataStorage("@keq-request/cli:GenerateDeclarationPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
-const SCHEMA_GENERATOR = "schemaGenerator";
-var SchemaDeclarationGenerator = class SchemaDeclarationGenerator {
-	async compile(compiler, task) {
-		const context = compiler.context;
-		const metadata = MetadataStorage$9.get(compiler);
-		const rc = context.rc;
-		const schemaDefinitions = context.documents.flatMap((document) => document.schemas);
-		const artifactMap = new Map(await Promise.all(schemaDefinitions.map(async (schemaDefinition) => [schemaDefinition, await metadata.hooks.afterSchemaDeclarationArtifactGenerated.promise(this.generateSchemaDefinitionsArtifact(schemaDefinition, rc), schemaDefinition, task)])));
-		if (!rc.rendering.entrypoint) return [...artifactMap.values()];
-		const entrypoints = ramda.collectBy((schemaDefinition) => schemaDefinition.module.name, schemaDefinitions).map((schemaDefinitions) => [schemaDefinitions[0].module, schemaDefinitions.map((schemaDefinition) => artifactMap.get(schemaDefinition)).filter((artifact) => Boolean(artifact))]).map(([moduleDefinition, artifacts]) => this.generateEntrypointArtifact(moduleDefinition, artifacts, rc));
-		return [...artifactMap.values(), ...entrypoints];
-	}
-	generateSchemaDefinitionsArtifact(schemaDefinition, rc) {
-		const filepath = SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(schemaDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: SchemaDeclarationGenerator.getSchemaDefinitionArtifactId(schemaDefinition),
-			filepath,
-			content: SchemaDefinitionTransformer.toDeclaration(schemaDefinition, {
-				esm: rc.rendering.esm,
-				additionalPropertiesType: rc.rendering.additionalPropertiesType,
-				getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-					const relativePath = path.relative(dirpath, SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				}
-			}),
-			extensionName: ".schema.ts"
-		});
-	}
-	generateEntrypointArtifact(moduleDefinition, exports, rc) {
-		const filepath = SchemaDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: SchemaDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
-			filepath,
-			content: EntrypointTransformer.toTypescript(exports, { dirpath })
-		});
-	}
-	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
-		return [
-			".",
-			change_case[fileNamingStyle](moduleDefinition.name),
-			"types",
-			"components",
-			"schemas",
-			"index.ts"
-		].join("/");
-	}
-	static getEntrypointArtifactId(moduleDefinition) {
-		return `${moduleDefinition.address.url}/components/schemas/entrypoint?generator=${SCHEMA_GENERATOR}`;
-	}
-	static getSchemaDefinitionArtifactFilepath(schemaDefinition, fileNamingStyle) {
-		const filename = `${change_case[fileNamingStyle](schemaDefinition.name)}.schema.ts`;
-		return [
-			".",
-			change_case[fileNamingStyle](schemaDefinition.module.name),
-			"types",
-			"components",
-			"schemas",
-			filename
-		].join("/");
-	}
-	static getSchemaDefinitionArtifactId(schemaDefinition) {
-		return `${schemaDefinition.id}?generator=${SCHEMA_GENERATOR}`;
-	}
-};
-//#endregion
-//#region src/plugins/generate-declaration/generators/response-declaration/response.generator.ts
-const RESPONSE_GENERATOR = "responseGenerator";
-var ResponseDeclarationGenerator = class ResponseDeclarationGenerator {
-	async compile(compiler, task) {
-		const context = compiler.context;
-		const metadata = MetadataStorage$9.get(compiler);
-		const rc = context.rc;
-		const responseDefinitions = context.documents.flatMap((document) => document.responses);
-		if (responseDefinitions.length === 0) return [];
-		const artifactMap = new Map(await Promise.all(responseDefinitions.map(async (responseDefinition) => [responseDefinition, await metadata.hooks.afterResponseDeclarationArtifactGenerated.promise(this.generateResponseDefinitionArtifact(responseDefinition, rc), responseDefinition, task)])));
-		if (!rc.rendering.entrypoint) return [...artifactMap.values()];
-		const entrypoints = ramda.collectBy((responseDefinition) => responseDefinition.module.name, responseDefinitions).map((responseDefinitions) => [responseDefinitions[0].module, responseDefinitions.map((responseDefinition) => artifactMap.get(responseDefinition)).filter((artifact) => Boolean(artifact))]).map(([moduleDefinition, artifacts]) => this.generateEntrypointArtifact(moduleDefinition, artifacts, rc));
-		return [...artifactMap.values(), ...entrypoints];
-	}
-	generateResponseDefinitionArtifact(responseDefinition, rc) {
-		const filepath = ResponseDeclarationGenerator.getResponseDefinitionArtifactFilepath(responseDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: ResponseDeclarationGenerator.getResponseDefinitionArtifactId(responseDefinition),
-			filepath,
-			content: ResponseDefinitionTransformer.toDeclaration(responseDefinition, {
-				esm: rc.rendering.esm,
-				additionalPropertiesType: rc.rendering.additionalPropertiesType,
-				getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-					const relativePath = path.relative(dirpath, SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				}
-			}),
-			extensionName: ".response.ts"
-		});
-	}
-	generateEntrypointArtifact(moduleDefinition, exports, rc) {
-		const filepath = ResponseDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: ResponseDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
-			filepath,
-			content: EntrypointTransformer.toTypescript(exports, { dirpath })
-		});
-	}
-	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
-		return [
-			".",
-			change_case[fileNamingStyle](moduleDefinition.name),
-			"types",
-			"components",
-			"responses",
-			"index.ts"
-		].join("/");
-	}
-	static getEntrypointArtifactId(moduleDefinition) {
-		return `${moduleDefinition.address.url}/components/responses/entrypoint?generator=${RESPONSE_GENERATOR}`;
-	}
-	static getResponseDefinitionArtifactFilepath(responseDefinition, fileNamingStyle) {
-		const filename = `${change_case[fileNamingStyle](responseDefinition.name)}.response.ts`;
-		return [
-			".",
-			change_case[fileNamingStyle](responseDefinition.module.name),
-			"types",
-			"components",
-			"responses",
-			filename
-		].join("/");
-	}
-	static getResponseDefinitionArtifactId(responseDefinition) {
-		return `${responseDefinition.id}?generator=${RESPONSE_GENERATOR}`;
-	}
-};
-//#endregion
-//#region src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
-const OPERATION_GENERATOR = "operationDeclarationGenerator";
-var OperationDeclarationGenerator = class OperationDeclarationGenerator {
-	async compile(compiler, task) {
-		const context = compiler.context;
-		const metadata = MetadataStorage$9.get(compiler);
-		const rc = context.rc;
-		const operationDefinitions = context.documents.flatMap((document) => document.operations);
-		const artifactMap = new Map(await Promise.all(operationDefinitions.map(async (operationDefinition) => [operationDefinition, await metadata.hooks.afterOperationDeclarationArtifactGenerated.promise(this.generateOperationDefinitionArtifact(operationDefinition, rc), operationDefinition, task)])));
-		return Array.from(artifactMap.values());
-	}
-	generateOperationDefinitionArtifact(operationDefinition, rc) {
-		const filepath = OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: OperationDeclarationGenerator.getOperationDefinitionArtifactId(operationDefinition),
-			filepath,
-			content: OperationDefinitionTransformer.toDeclaration(operationDefinition, {
-				esm: rc.rendering.esm,
-				additionalPropertiesType: rc.rendering.additionalPropertiesType,
-				getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-					const relativePath = path.relative(dirpath, SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				},
-				getDependentResponseDefinitionFilepath(dependentResponseDefinition) {
-					const relativePath = path.relative(dirpath, ResponseDeclarationGenerator.getResponseDefinitionArtifactFilepath(dependentResponseDefinition, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				}
-			}),
-			extensionName: ".type.ts"
-		});
-	}
-	generateEntrypointArtifact(moduleDefinition, exports, rc) {
-		const filepath = OperationDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: OperationDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
-			filepath,
-			content: EntrypointTransformer.toTypescript(exports, { dirpath })
-		});
-	}
-	static getOperationDefinitionArtifactFilepath(operationDefinition, fileNamingStyle) {
-		const filename = `${change_case[fileNamingStyle](operationDefinition.operationId)}.type.ts`;
-		return [
-			".",
-			change_case[fileNamingStyle](operationDefinition.module.name),
-			"types",
-			"operations",
-			filename
-		].join("/");
-	}
-	static getOperationDefinitionArtifactId(operationDefinition) {
-		return `${operationDefinition.id}?generator=${OPERATION_GENERATOR}`;
-	}
-	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
-		return [
-			".",
-			change_case[fileNamingStyle](moduleDefinition.name),
-			"types",
-			"operations",
-			"index.ts"
-		].join("/");
-	}
-	static getEntrypointArtifactId(moduleDefinition) {
-		return `${moduleDefinition.address.url}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
-	}
-};
-//#endregion
-//#region src/plugins/generate-declaration/generate-declaration.plugin.ts
-const DECLARATION_GENERATOR = "declarationGenerator";
-var GenerateDeclarationPlugin = class GenerateDeclarationPlugin {
-	name = DECLARATION_GENERATOR;
-	operationGenerator = new OperationDeclarationGenerator();
-	schemaGenerator = new SchemaDeclarationGenerator();
-	responseGenerator = new ResponseDeclarationGenerator();
-	constructor() {}
-	apply(compiler) {
-		const metadata = GenerateDeclarationPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.compile.tapPromise(GenerateDeclarationPlugin.name, async (task) => {
-			compiler.context.artifacts?.push(...await this.schemaGenerator.compile(compiler, task), ...await this.responseGenerator.compile(compiler, task), ...await this.operationGenerator.compile(compiler, task));
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$9.has(compiler)) MetadataStorage$9.set(compiler, {
-			applied: false,
-			hooks: {
-				afterEntrypointArtifactGenerated: new tapable.AsyncSeriesWaterfallHook(["artifact", "task"]),
-				afterSchemaDeclarationArtifactGenerated: new tapable.AsyncSeriesWaterfallHook([
-					"artifact",
-					"schemaDefinition",
-					"task"
-				]),
-				afterResponseDeclarationArtifactGenerated: new tapable.AsyncSeriesWaterfallHook([
-					"artifact",
-					"responseDefinition",
-					"task"
-				]),
-				afterOperationDeclarationArtifactGenerated: new tapable.AsyncSeriesWaterfallHook([
-					"artifact",
-					"operationDefinition",
-					"task"
-				])
-			}
-		});
-		return MetadataStorage$9.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/generate-micro-function/generators/request/request.generator.ts
-const MICRO_FUNCTION_REQUEST_GENERATOR = "microFunctionRequestGenerator";
-var RequestGenerator = class RequestGenerator {
-	generateRequestArtifact(moduleName, fileNamingStyle) {
-		const content = [
-			"/* @anchor:file:start */",
-			"",
-			"import { KeqRequest } from \"keq\"",
-			"",
-			"/* @anchor:request-declaration */",
-			"export const request = new KeqRequest()",
-			"",
-			"/* @anchor:file:end */"
-		].join("\n");
-		return new Artifact({
-			id: RequestGenerator.getRequestArtifactId(moduleName),
-			filepath: RequestGenerator.getRequestArtifactFilepath(moduleName, fileNamingStyle),
-			content
-		});
-	}
-	async compile(compiler, task) {
-		const context = compiler.context;
-		const rc = context.rc;
-		const documents = context.documents;
-		return [...new Set(documents.flatMap((doc) => doc.operations.map((op) => op.module.name)))].map((moduleName) => this.generateRequestArtifact(moduleName, rc.rendering.fileNamingStyle));
-	}
-	static getRequestArtifactFilepath(moduleName, fileNamingStyle) {
-		return `./${change_case[fileNamingStyle](moduleName)}/request.ts`;
-	}
-	static getRequestArtifactId(moduleName) {
-		return `request?module=${moduleName}&generator=${MICRO_FUNCTION_REQUEST_GENERATOR}`;
-	}
-};
-//#endregion
-//#region src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
-const MICRO_FUNCTION_GENERATOR = "microFunctionGenerator";
-var MicroFunctionGenerator = class MicroFunctionGenerator {
-	async compile(compiler, task) {
-		const metadata = MetadataStorage$10.get(compiler);
-		const context = compiler.context;
-		const rc = context.rc;
-		const operationDefinitions = context.documents.flatMap((document) => document.operations);
-		const artifactMap = new Map(await Promise.all(operationDefinitions.map(async (operationDefinition) => [operationDefinition, await metadata.hooks.afterMicroFunctionArtifactGenerated.promise(this.generateOperationDefinitionArtifact(operationDefinition, rc), operationDefinition, task)])));
-		if (!rc.rendering.entrypoint) return [...artifactMap.values()];
-		return [...await Promise.all(ramda.collectBy((operationDefinition) => operationDefinition.module.name, operationDefinitions).map((operationDefinitions) => [operationDefinitions[0].module, operationDefinitions.map((operationDefinition) => artifactMap.get(operationDefinition)).filter((artifact) => Boolean(artifact))]).map(async ([moduleDefinition, artifacts]) => await metadata.hooks.afterEntrypointArtifactGenerated.promise(this.generateEntrypointArtifact(moduleDefinition, artifacts, rc), task))), ...artifactMap.values()];
-	}
-	generateOperationDefinitionArtifact(operationDefinition, rc) {
-		const filepath = MicroFunctionGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: MicroFunctionGenerator.getOperationDefinitionArtifactId(operationDefinition),
-			filepath,
-			content: OperationDefinitionTransformer.toMicroFunction(operationDefinition, {
-				esm: rc.rendering.esm,
-				getOperationDefinitionDeclarationFilepath(operationDefinition) {
-					const relativePath = path.relative(dirpath, OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				},
-				getRequestFilepath() {
-					const relativePath = path.relative(dirpath, RequestGenerator.getRequestArtifactFilepath(operationDefinition.module.name, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				}
-			}),
-			extensionName: ".type.ts"
-		});
-	}
-	generateEntrypointArtifact(moduleDefinition, exports, rc) {
-		const filepath = MicroFunctionGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.rendering.fileNamingStyle);
-		const dirpath = filepath.substring(0, filepath.lastIndexOf("/"));
-		return new Artifact({
-			id: MicroFunctionGenerator.getEntrypointArtifactId(moduleDefinition),
-			filepath,
-			content: EntrypointTransformer.toTypescript(exports, { dirpath })
-		});
-	}
-	static getOperationDefinitionArtifactFilepath(operationDefinition, fileNamingStyle) {
-		const filename = `${change_case[fileNamingStyle](operationDefinition.operationId)}.fn.ts`;
-		return [
-			".",
-			change_case[fileNamingStyle](operationDefinition.module.name),
-			"operations",
-			filename
-		].join("/");
-	}
-	static getOperationDefinitionArtifactId(operationDefinition) {
-		return `${operationDefinition.id}?generator=${MICRO_FUNCTION_GENERATOR}`;
-	}
-	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
-		return [
-			".",
-			change_case[fileNamingStyle](moduleDefinition.name),
-			"operations",
-			"index.ts"
-		].join("/");
-	}
-	static getEntrypointArtifactId(moduleDefinition) {
-		return `${moduleDefinition.address}/paths/entrypoint?generator=${MICRO_FUNCTION_GENERATOR}`;
-	}
-};
-//#endregion
-//#region src/plugins/generate-micro-function/generate-micro-function.plugin.ts
-var GenerateMicroFunctionPlugin = class GenerateMicroFunctionPlugin {
-	microFunctionGenerator = new MicroFunctionGenerator();
-	requestGenerator = new RequestGenerator();
-	apply(compiler) {
-		const metadata = GenerateMicroFunctionPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.compile.tapPromise(GenerateMicroFunctionPlugin.name, async (task) => {
-			const artifacts = [...await this.requestGenerator.compile(compiler, task), ...await this.microFunctionGenerator.compile(compiler, task)];
-			compiler.context.artifacts.push(...artifacts);
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$10.has(compiler)) MetadataStorage$10.set(compiler, {
-			applied: false,
-			hooks: {
-				afterEntrypointArtifactGenerated: new tapable.AsyncSeriesWaterfallHook(["artifact", "task"]),
-				afterMicroFunctionArtifactGenerated: new tapable.AsyncSeriesWaterfallHook([
-					"artifact",
-					"operationDefinition",
-					"task"
-				])
-			}
-		});
-		return MetadataStorage$10.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/body-fallback/constants/metadata-storage.ts
-const MetadataStorage$8 = new PluginMetadataStorage("@keq-request/cli:BodyFallbackPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/body-fallback/index.ts
-var BodyFallbackPlugin = class BodyFallbackPlugin {
-	apply(compiler) {
-		const metadata = BodyFallbackPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.setup.tap(BodyFallbackPlugin.name, () => {
-			const generateMicroFunctionPluginMetadata = GenerateMicroFunctionPlugin.of(compiler);
-			if (!generateMicroFunctionPluginMetadata) throw new Error("BodyFallbackPlugin requires GenerateMicroFunctionPlugin to be applied first.");
-			generateMicroFunctionPluginMetadata.hooks.afterMicroFunctionArtifactGenerated.tap(BodyFallbackPlugin.name, (artifact, operationDefinition) => {
-				const keys = (operationDefinition.operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p)) || []).map((p) => p.name).filter(ramda.isNotNil);
-				const $acc = !keys.length ? "        acc[key] = args[key]" : [
-					`        if (![${keys.map((k) => JSON.stringify(k)).join(", ")}].includes(key)) {`,
-					"          acc[key] = args[key]",
-					"        }"
-				].join("\n");
-				artifact.anchor.block.replace("body", [
-					"  if (typeof args === \"object\" && args !== null && !Array.isArray(args)) {",
-					"    const requestBody = Object.keys(args)",
-					"      .reduce((acc, key) => {",
-					$acc,
-					"        return acc",
-					"      }, {} as Record<string, unknown>)",
-					"",
-					"    if (Object.keys(requestBody).length > 0) {",
-					"      req.send(requestBody)",
-					"    }",
-					"  }"
-				].filter(ramda.isNotNil).join("\n"));
-				return artifact;
-			});
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$8.has(compiler)) MetadataStorage$8.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$8.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/use-valibot/constants/metadata-storage.ts
-const MetadataStorage$7 = new PluginMetadataStorage("@keq-request/cli:UseValibotPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/use-valibot/use-valibot.plugin.ts
-const USE_VALIBOT = "useValibot";
-var UseValibotPlugin = class UseValibotPlugin {
-	name = USE_VALIBOT;
-	constructor() {}
-	apply(compiler) {
-		const metadata = UseValibotPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		const declarationMetadata = GenerateDeclarationPlugin.of(compiler);
-		if (!declarationMetadata) throw new Error("UseValibotPlugin requires GenerateDeclarationPlugin to be registered first");
-		declarationMetadata.hooks.afterSchemaDeclarationArtifactGenerated.tap(UseValibotPlugin.name, (artifact, schemaDefinition) => {
-			const rc = compiler.context.rc;
-			const filepath = artifact.filepath;
-			const dirpath = path.dirname(filepath);
-			const valibotContent = SchemaDefinitionTransformer.toValibot(schemaDefinition, {
-				esm: rc.rendering.esm,
-				additionalPropertiesType: rc.rendering.additionalPropertiesType,
-				getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-					const relativePath = path.relative(dirpath, SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				}
-			});
-			return new Artifact({
-				...artifact,
-				content: valibotContent
-			});
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$7.has(compiler)) MetadataStorage$7.set(compiler, { applied: false });
-		return MetadataStorage$7.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/generate-nestjs-module/constants/metadata-storage.ts
-const MetadataStorage$6 = new PluginMetadataStorage("@keq-request/cli:GenerateNestjsModulePlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/generate-nestjs-module/generators/nestjs-module.generator.ts
-const NESTJS_MODULE_GENERATOR = "nestjs-module-generator";
-var NestjsModuleGenerator = class NestjsModuleGenerator {
-	generateNestjsModuleArtifact(document, rc) {
-		const filepath = NestjsModuleGenerator.getNestjsModuleArtifactFilepath(document, rc.rendering.fileNamingStyle);
-		const dirname = path.dirname(filepath);
-		return new Artifact({
-			id: NestjsModuleGenerator.getNestjsModuleArtifactId(document),
-			filepath,
-			content: ApiDocumentTransformer.toNestjsModule(document, {
-				esm: rc.rendering.esm,
-				getNestjsClientFilepath(document) {
-					const relativePath = path.relative(dirname, NestjsModuleGenerator.getNestjsClientArtifactFilepath(document, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				}
-			})
-		});
-	}
-	generateNestjsClientArtifact(document, rc) {
-		const filepath = NestjsModuleGenerator.getNestjsClientArtifactFilepath(document, rc.rendering.fileNamingStyle);
-		const dirpath = path.dirname(filepath);
-		return new Artifact({
-			id: NestjsModuleGenerator.getNestjsClientArtifactId(document),
-			filepath,
-			content: ApiDocumentTransformer.toNestjsClient(document, {
-				esm: rc.rendering.esm,
-				getOperationDefinitionDeclarationFilepath(operationDefinition) {
-					const relativePath = path.relative(dirpath, OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.rendering.fileNamingStyle));
-					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-				}
-			})
-		});
-	}
-	async compile(compiler, task) {
-		const metadata = MetadataStorage$6.get(compiler);
-		const rc = compiler.context.rc;
-		const documents = compiler.context.documents;
-		const nestjsModuleArtifacts = await Promise.all(documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(this.generateNestjsModuleArtifact(document, rc), document, task)));
-		const nestjsClientArtifacts = await Promise.all(documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(this.generateNestjsClientArtifact(document, rc), document, task)));
-		return [...nestjsModuleArtifacts, ...nestjsClientArtifacts];
-	}
-	static getNestjsModuleArtifactFilepath(document, fileNamingStyle) {
-		const filename = `${change_case[fileNamingStyle](document.module.name)}.module.ts`;
-		return [
-			".",
-			change_case[fileNamingStyle](document.module.name),
-			filename
-		].join("/");
-	}
-	static getNestjsModuleArtifactId(document) {
-		return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}`;
-	}
-	static getNestjsClientArtifactFilepath(document, fileNamingStyle) {
-		const filename = `${change_case[fileNamingStyle](document.module.name)}.client.ts`;
-		return [
-			".",
-			change_case[fileNamingStyle](document.module.name),
-			filename
-		].join("/");
-	}
-	static getNestjsClientArtifactId(document) {
-		return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}-client`;
-	}
-};
-//#endregion
-//#region src/plugins/generate-nestjs-module/generate-nestjs-module.ts
-var GenerateNestjsModulePlugin = class GenerateNestjsModulePlugin {
-	nestjsModuleGenerator = new NestjsModuleGenerator();
-	apply(compiler) {
-		const metadata = GenerateNestjsModulePlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.compile.tapPromise(GenerateNestjsModulePlugin.name, async (task) => {
-			const artifacts = await this.nestjsModuleGenerator.compile(compiler, task);
-			compiler.context.artifacts.push(...artifacts);
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$6.has(compiler)) MetadataStorage$6.set(compiler, {
-			applied: false,
-			hooks: { afterNestjsModuleArtifactGenerated: new tapable.AsyncSeriesWaterfallHook([
-				"artifact",
-				"document",
-				"task"
-			]) }
-		});
-		return MetadataStorage$6.get(compiler);
-	}
-	static of(compiler) {
-		return MetadataStorage$6.get(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/chinese-to-pinyin/constants/metadata-storage.ts
-const MetadataStorage$5 = new PluginMetadataStorage("@keq-request/cli:ChineseToPinyinPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
-var ChineseToPinyinPlugin = class ChineseToPinyinPlugin {
-	apply(compiler) {
-		const metadata = ChineseToPinyinPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.afterDownload.tap(ChineseToPinyinPlugin.name, (task) => {
-			const documents = compiler.context.documents;
-			compiler.context.documents = documents.map((doc) => {
-				return new ApiDocumentV3_1((0, swagger_fix.fixSwagger)(doc.specification), doc.module);
-			});
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$5.has(compiler)) MetadataStorage$5.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$5.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/download-http-file/constants/metadata-storage.ts
-const MetadataStorage$4 = new PluginMetadataStorage("@keq-request/cli:DownloadHttpFilePlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/download-http-file/download-http-file.plugin.ts
-var DownloadHttpFilePlugin = class DownloadHttpFilePlugin {
-	apply(compiler) {
-		const metadata = DownloadHttpFilePlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.download.tapPromise(DownloadHttpFilePlugin.name, async (address, task) => {
-			const { url } = address;
-			if (!url.startsWith("http://") && !url.startsWith("https://")) return void 0;
-			const content = await this.download(address);
-			const spec = this.deserialize(content);
-			return JSON.stringify(spec);
-		});
-	}
-	async download(address) {
-		const { url, headers } = address;
-		try {
-			const res = await fetch(url, { headers });
-			if (res.status >= 400) {
-				const body = await res.text().catch(() => "");
-				const detail = body ? `\n  Response Body: ${body}` : "";
-				throw new Error(`failed with status code ${res.status}${detail}`);
-			}
-			return await res.text();
-		} catch (e) {
-			if (e instanceof Error) e.message = `Unable get the openapi/swagger file from ${url}: ${e.message}`;
-			throw e;
-		}
-	}
-	deserialize(content) {
-		const json = JSON.parse(content);
-		return OpenapiUtils.to3_1(json);
-	}
-	static register(compiler) {
-		if (!MetadataStorage$4.has(compiler)) MetadataStorage$4.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$4.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/download-local-file/constants/metadata-storage.ts
-const MetadataStorage$3 = new PluginMetadataStorage("@keq-request/cli:DownloadLocalFilePlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/download-local-file/download-local-file.plugin.ts
-var DownloadLocalFilePlugin = class DownloadLocalFilePlugin {
-	apply(compiler) {
-		const metadata = DownloadLocalFilePlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.download.tapPromise(DownloadLocalFilePlugin.name, async (address, task) => {
-			const { url: url$1, encoding } = address;
-			if (!url$1.startsWith("file://")) return void 0;
-			const filepath = (0, url.fileURLToPath)(url$1);
-			const fileExt = path.extname(filepath);
-			const content = await fs_promises.readFile(filepath, encoding);
-			const str = typeof content === "string" ? content : content.toString(encoding);
-			if ([".yml", ".yaml"].includes(fileExt)) {
-				const value = js_yaml.load(str);
-				return JSON.stringify(OpenapiUtils.to3_1(value));
-			} else if (fileExt === ".json") return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(str)));
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$3.has(compiler)) MetadataStorage$3.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$3.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/shaking/constants/metadata-storage.ts
-const MetadataStorage$2 = new PluginMetadataStorage("@keq-request/cli:ShakingPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/shaking/shaking.plugin.ts
-var ShakingPlugin = class ShakingPlugin {
-	apply(compiler) {
-		const metadata = ShakingPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.beforeCompile.tap(ShakingPlugin.name, (task) => {
-			const matcher = compiler.context.matcher;
-			const documents = compiler.context.documents;
-			compiler.context.documents = documents.map((document) => this.shaking(compiler, document)).filter((document) => !document.isEmpty()).filter((document) => !matcher.isModuleDenied(document.module));
-		});
-	}
-	shaking(compiler, document) {
-		const rc = compiler.context.rc;
-		const matcher = compiler.context.matcher;
-		const isAccepted = (pathname, method, operation) => {
-			if (!SupportedMethods.includes(method)) return false;
-			return !matcher.isOperationDenied(new OperationDefinition({
-				method,
-				pathname,
-				operation,
-				module: document.module,
-				document
-			}));
-		};
-		return new ApiDocumentV3_1((0, _opendoc_openapi_shaking.openapiShakingSync)(document.specification, isAccepted, { tolerant: rc.tolerant }), new ModuleDefinition(document.module.name, {
-			url: `memory://${document.module.name}.v3_1.sharked.json`,
-			headers: {},
-			encoding: "utf8"
-		}));
-	}
-	static register(compiler) {
-		if (!MetadataStorage$2.has(compiler)) MetadataStorage$2.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$2.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/terminal-select/utils/select-operation-definitions.ts
-async function selectOperationDefinitions(task, operationDefinitions) {
-	return await task.prompt(_listr2_prompt_adapter_inquirer.ListrInquirerPromptAdapter).run(inquirer_select_pro.select, {
-		message: "Select Pathname",
-		defaultValue: [],
-		options: (input) => {
-			const items = operationDefinitions.map((op) => ({
-				name: `${op.module.name} ${op.method.toUpperCase()} ${op.pathname}`,
-				value: op
-			}));
-			if (!input) return items;
-			const keys = input.trim().toLowerCase().split(/\s+/);
-			return items.filter((i) => {
-				const name = i.name.toLowerCase();
-				return keys.every((q) => name.includes(q));
-			});
-		}
-	});
-}
-//#endregion
-//#region src/plugins/terminal-select/constants/metadata-storage.ts
-const MetadataStorage$1 = new PluginMetadataStorage("@keq-request/cli:TerminalSelectPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/terminal-select/terminal-select.plugin.ts
-var TerminalSelectPlugin = class TerminalSelectPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-	apply(compiler) {
-		const metadata = TerminalSelectPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		compiler.hooks.afterDownload.tapPromise(TerminalSelectPlugin.name, async (task) => {
-			const context = compiler.context;
-			const matcher = context.matcher;
-			const selectedOperationDefinitions = await selectOperationDefinitions(task, context.documents.flatMap((document) => document.operations));
-			for (const op of selectedOperationDefinitions) matcher.append({
-				persist: !!this.options.persist,
-				deny: this.options.mode === "deny",
-				moduleName: op.module.name,
-				operationMethod: op.method,
-				operationPathname: op.pathname
-			});
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage$1.has(compiler)) MetadataStorage$1.set(compiler, {
-			applied: false,
-			hooks: {}
-		});
-		return MetadataStorage$1.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/clean/clean.plugin.ts
-var CleanPlugin = class CleanPlugin {
-	apply(compiler) {
-		compiler.hooks.beforePersist.tapPromise(CleanPlugin.name, async () => {
-			const rc = compiler.context.rc;
-			if (!rc) throw new Error("Please run setup task first.");
-			const outdir = rc.outdir;
-			await fs_extra.default.emptyDir(outdir);
-		});
-	}
-};
-//#endregion
-//#region src/plugins/initialize/initialize.plugin.ts
-var InitializePlugin = class InitializePlugin {
-	constructor(options) {
-		this.options = options;
-	}
-	apply(compiler) {
-		compiler.hooks.setup.tap(InitializePlugin.name, (task) => {
-			const plugins = [new DownloadHttpFilePlugin(), new DownloadLocalFilePlugin()];
-			if (this.options.build) plugins.push(new ShakingPlugin());
-			if (this.options.interactive) plugins.push(new TerminalSelectPlugin(typeof this.options.interactive === "object" ? this.options.interactive : { mode: "allow" }));
-			const rc = compiler.context.rc;
-			plugins.push(...ramda.unnest((rc.translators || []).map((translator) => {
-				return translator.apply();
-			})));
-			if (this.options.fresh) plugins.push(new CleanPlugin());
-			if (rc.plugins && rc.plugins.length) plugins.push(...rc.plugins);
-			for (const plugin of plugins) plugin.apply(compiler);
-		});
-	}
-};
-//#endregion
-//#region src/plugins/overwrite-operation-id/overwrite-operation-id.plugin.ts
-var OverwriteOperationIdPlugin = class OverwriteOperationIdPlugin {
-	constructor(factory) {
-		this.factory = factory;
-	}
-	apply(compiler) {
-		compiler.hooks.afterDownload.tap(OverwriteOperationIdPlugin.name, () => {
-			const documents = compiler.context.documents;
-			const factory = this.factory;
-			compiler.context.documents = documents.map((document) => {
-				return new ApiDocumentV3_1(OpenapiUtils.mapOperation(document.specification, (method, pathname, operation) => {
-					const operationId = factory({
-						method,
-						pathname,
-						operation,
-						module: document.module
-					});
-					if (typeof operationId === "string") {
-						if (operationId.length === 0) throw new Exception(document.module, `The generated operationId for [${method.toUpperCase()} ${pathname}] is an empty string.`);
-						operation.operationId = operationId;
-						return operation;
-					}
-					return operation;
-				}), document.module);
-			});
-		});
-	}
-};
-//#endregion
-//#region src/plugins/overwrite-schema-name/overwrite-schema-name.plugin.ts
-var OverwriteSchemaNamePlugin = class OverwriteSchemaNamePlugin {
-	constructor(factory) {
-		this.factory = factory;
-	}
-	apply(compiler) {
-		compiler.hooks.beforeValidate.tap(OverwriteSchemaNamePlugin.name, (spec, moduleDefinition) => {
-			const schemas = spec.components?.schemas;
-			if (!schemas) return;
-			const renameMap = /* @__PURE__ */ new Map();
-			for (const name of Object.keys(schemas)) {
-				const newName = this.factory({
-					name,
-					module: moduleDefinition
-				});
-				if (typeof newName === "string" && newName !== name) renameMap.set(name, newName);
-			}
-			if (renameMap.size === 0) return;
-			for (const [oldName, newName] of renameMap) {
-				schemas[newName] = schemas[oldName];
-				delete schemas[oldName];
-			}
-			const refMap = /* @__PURE__ */ new Map();
-			for (const [oldName, newName] of renameMap) refMap.set(`#/components/schemas/${oldName}`, `#/components/schemas/${newName}`);
-			const matches = (0, jsonpath_plus.JSONPath)({
-				path: "$..*['$ref']^",
-				json: spec,
-				resultType: "all"
-			});
-			for (const match of matches) {
-				const ref = match.value.$ref;
-				if (typeof ref === "string" && refMap.has(ref)) match.value.$ref = refMap.get(ref);
-			}
-		});
-	}
-};
-//#endregion
-//#region src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
-const QsArrayFormatUnion = Object.values(QsArrayFormat);
-var OverwriteQueryOptionsPlugin = class OverwriteQueryOptionsPlugin {
-	constructor(factory) {
-		this.factory = factory;
-	}
-	apply(compiler) {
-		compiler.hooks.afterDownload.tap(OverwriteQueryOptionsPlugin.name, (task) => {
-			const documents = compiler.context.documents;
-			const factory = this.factory;
-			compiler.context.documents = documents.map((document) => {
-				return new ApiDocumentV3_1(OpenapiUtils.mapParameter(document.specification, (method, pathname, operation, parameter) => {
-					const qsOptions = typeof factory === "function" ? factory({
-						parameter,
-						operation,
-						pathname,
-						method,
-						module: document.module
-					}) : factory;
-					if (!qsOptions) return parameter;
-					if (qsOptions.arrayFormat) {
-						if (!QsArrayFormatUnion.includes(qsOptions.arrayFormat)) throw new Exception(document.module, `The 'arrayFormat' value '${qsOptions.arrayFormat}' for the query parameter '${parameter.name}' in [${method.toUpperCase()} ${pathname}] is invalid.`);
-						parameter["x-qs-array-format"] = qsOptions.arrayFormat;
-					}
-					if (qsOptions.allowDots !== void 0) {
-						if (typeof qsOptions.allowDots !== "boolean") throw new Exception(document.module, `The 'allowDots' value for the query parameter '${parameter.name}' in [${method.toUpperCase()} ${pathname}] must be a boolean.`);
-						parameter["x-qs-allow-dots"] = Boolean(qsOptions.allowDots);
-					}
-					if (qsOptions.indices !== void 0) {
-						if (typeof qsOptions.indices !== "boolean") throw new Exception(document.module, `The 'indices' value for the query parameter '${parameter.name}' in [${method.toUpperCase()} ${pathname}] must be a boolean.`);
-						parameter["x-qs-indices"] = Boolean(qsOptions.indices);
-					}
-					return parameter;
-				}), document.module);
-			});
-		});
-	}
-};
-//#endregion
-//#region src/plugins/overwrite-additional-properties/constants/metadata-storage.ts
-const MetadataStorage = new PluginMetadataStorage("@keq-request/cli:OverwriteAdditionalPropertiesPlugin:MetadataStorage");
-//#endregion
-//#region src/plugins/overwrite-additional-properties/overwrite-additional-properties.plugin.ts
-var OverwriteAdditionalPropertiesPlugin = class OverwriteAdditionalPropertiesPlugin {
-	constructor(options = {}) {
-		this.options = options;
-	}
-	apply(compiler) {
-		const metadata = OverwriteAdditionalPropertiesPlugin.register(compiler);
-		if (metadata.applied) return;
-		metadata.applied = true;
-		const { disallowIfNotPresent = false } = this.options;
-		if (!disallowIfNotPresent) return;
-		compiler.hooks.afterDownload.tap(OverwriteAdditionalPropertiesPlugin.name, () => {
-			const documents = compiler.context.documents;
-			compiler.context.documents = documents.map((document) => {
-				return new ApiDocumentV3_1(OpenapiUtils.mapSchema(document.specification, (schema) => {
-					if (schema.type !== "object" && !schema.properties) return schema;
-					if (schema.additionalProperties === void 0) return Object.assign({}, schema, { additionalProperties: false });
-					return schema;
-				}), document.module);
-			});
-		});
-	}
-	static register(compiler) {
-		if (!MetadataStorage.has(compiler)) MetadataStorage.set(compiler, { applied: false });
-		return MetadataStorage.get(compiler);
-	}
-	static of(compiler) {
-		return this.register(compiler);
-	}
-};
-//#endregion
-//#region src/plugins/lint-schema/lint-schema.plugin.ts
-var LintSchemaPlugin = class LintSchemaPlugin {
-	constructor(options = {}) {
-		this.options = options;
-	}
-	apply(compiler) {
-		compiler.hooks.beforeCompile.tap(LintSchemaPlugin.name, () => {
-			const documents = compiler.context.documents;
-			const validate = new ajv_dist_2020_js.default({
-				allErrors: true,
-				strict: false
-			}).getSchema("https://json-schema.org/draft/2020-12/schema");
-			if (!validate) {
-				require_logger.logger.warn("Failed to load JSON Schema Draft 2020-12 meta-schema for validation");
-				return;
-			}
-			let hasErrors = false;
-			for (const document of documents) {
-				const spec = document.specification;
-				const moduleName = document.module.name;
-				if (spec.components?.schemas) for (const [name, schema] of Object.entries(spec.components.schemas)) {
-					if (typeof schema === "boolean" || "$ref" in schema) continue;
-					if (!validate(schema) && validate.errors) {
-						hasErrors = true;
-						for (const error of validate.errors) require_logger.logger.warn(`[${moduleName}] components.schemas.${name}${error.instancePath}: ${error.message}`);
-					}
-				}
-				for (const [path, pathItem] of Object.entries(spec.paths || {})) {
-					if (!pathItem) continue;
-					for (const method of SupportedMethods) {
-						const operation = pathItem[method];
-						if (!operation) continue;
-						const operationId = operation.operationId || `${method.toUpperCase()} ${path}`;
-						if (operation.parameters) for (const param of operation.parameters) {
-							if ("$ref" in param || !param.schema) continue;
-							if (typeof param.schema === "boolean" || "$ref" in param.schema) continue;
-							if (!validate(param.schema) && validate.errors) {
-								hasErrors = true;
-								for (const error of validate.errors) require_logger.logger.warn(`[${moduleName}] ${operationId} parameter "${param.name}" schema${error.instancePath}: ${error.message}`);
-							}
-						}
-						if (operation.requestBody && !("$ref" in operation.requestBody)) {
-							const content = operation.requestBody.content || {};
-							for (const [mediaType, mediaTypeObj] of Object.entries(content)) {
-								if (!mediaTypeObj.schema || typeof mediaTypeObj.schema === "boolean" || "$ref" in mediaTypeObj.schema) continue;
-								if (!validate(mediaTypeObj.schema) && validate.errors) {
-									hasErrors = true;
-									for (const error of validate.errors) require_logger.logger.warn(`[${moduleName}] ${operationId} requestBody ${mediaType} schema${error.instancePath}: ${error.message}`);
-								}
-							}
-						}
-						if (operation.responses) for (const [statusCode, response] of Object.entries(operation.responses)) {
-							if ("$ref" in response) continue;
-							const content = response.content || {};
-							for (const [mediaType, mediaTypeObj] of Object.entries(content)) {
-								if (!mediaTypeObj.schema || typeof mediaTypeObj.schema === "boolean" || "$ref" in mediaTypeObj.schema) continue;
-								if (!validate(mediaTypeObj.schema) && validate.errors) {
-									hasErrors = true;
-									for (const error of validate.errors) require_logger.logger.warn(`[${moduleName}] ${operationId} response ${statusCode} ${mediaType} schema${error.instancePath}: ${error.message}`);
-								}
-							}
-						}
-					}
-				}
-			}
-			if (this.options.strict && hasErrors) throw new Error("Schema validation failed. Fix the errors above or set LintSchemaPlugin strict option to false.");
-			this.lintDuplicateOperationId(compiler, documents);
-		});
-	}
-	/**
-	* Detect duplicate operationId across all operations within each API document.
-	*
-	* In tolerant mode, duplicates are auto-resolved by appending `__{method}_{pathname}` suffix
-	* and the patched document replaces the original in the compiler context.
-	* In strict mode (tolerant=false), an Exception is thrown immediately.
-	*/
-	lintDuplicateOperationId(compiler, documents) {
-		for (let i = 0; i < documents.length; i++) {
-			const document = documents[i];
-			const spec = document.specification;
-			const moduleName = document.module.name;
-			const operationIdMap = /* @__PURE__ */ new Map();
-			for (const [pathname, pathItem] of Object.entries(spec.paths || {})) {
-				if (!pathItem) continue;
-				for (const method of SupportedMethods) {
-					const operation = pathItem[method];
-					if (!operation?.operationId) continue;
-					const list = operationIdMap.get(operation.operationId) || [];
-					list.push({
-						method,
-						pathname
-					});
-					operationIdMap.set(operation.operationId, list);
-				}
-			}
-			const duplicates = [...operationIdMap.entries()].filter(([, ops]) => ops.length > 1);
-			if (duplicates.length === 0) continue;
-			if (!compiler.options.tolerant) {
-				const messages = duplicates.map(([id, ops]) => `  - operationId "${id}" is used by: ${ops.map((o) => `[${o.method.toUpperCase()} ${o.pathname}]`).join(", ")}`);
-				throw new Exception(document.module, `Duplicate operationId found:\n${messages.join("\n")}`);
-			}
-			const duplicateIds = new Set(duplicates.map(([id]) => id));
-			for (const [id, ops] of duplicates) require_logger.logger.warn(`[${moduleName}] Duplicate operationId "${id}" found in: ${ops.map((o) => `[${o.method.toUpperCase()} ${o.pathname}]`).join(", ")}`);
-			const newSpec = OpenapiUtils.mapOperation(spec, (method, pathname, operation) => {
-				if (operation.operationId && duplicateIds.has(operation.operationId)) {
-					const sanitized = pathname.replace(/\//g, "_").replace(/-/g, "_").replace(/:/g, "$$").replace(/{(.+)}/, "$$$1");
-					const newId = `${operation.operationId}__${method}${sanitized}`;
-					require_logger.logger.warn(`[${moduleName}] Renamed: "${operation.operationId}" -> "${newId}" for [${method.toUpperCase()} ${pathname}]`);
-					operation.operationId = newId;
-				}
-				return operation;
-			});
-			compiler.context.documents[i] = new ApiDocumentV3_1(newSpec, document.module);
-		}
-	}
-};
-//#endregion
-//#region src/plugins/springdoc-compat/springdoc-compat.plugin.ts
-function flattenExtensions(obj) {
-	if (typeof obj !== "object" || obj === null) return;
-	if (Array.isArray(obj)) {
-		for (const item of obj) flattenExtensions(item);
-		return;
-	}
-	const record = obj;
-	if ("extensions" in record && typeof record.extensions === "object" && record.extensions !== null) {
-		const extensions = record.extensions;
-		for (const [key, value] of Object.entries(extensions)) if (!(key in record)) record[key] = value;
-		delete record.extensions;
-	}
-	for (const value of Object.values(record)) flattenExtensions(value);
-}
-/**
-* Springdoc (Java/Spring Boot) 生成的 OpenAPI 文档兼容插件。
-*
-* Springdoc 输出的文档存在若干不符合 OpenAPI 规范的结构，此插件在验证前进行修正。
-* 当前处理：
-* - 将嵌套的 `extensions` 对象展平为同级 x-* 属性
-*/
-var SpringdocCompatPlugin = class SpringdocCompatPlugin {
-	apply(compiler) {
-		compiler.hooks.beforeValidate.tap(SpringdocCompatPlugin.name, (spec) => {
-			flattenExtensions(spec);
-		});
-	}
-};
-//#endregion
-//#region src/plugins/mock/mock.plugin.ts
-function resolveRef(root, ref) {
-	if (!ref.startsWith("#/")) return void 0;
-	const parts = ref.slice(2).split("/");
-	let current = root;
-	for (const part of parts) {
-		if (typeof current !== "object" || current === null) return void 0;
-		current = current[part];
-	}
-	return typeof current === "object" && current !== null ? current : void 0;
-}
-function resolveSchemaNode(root, node) {
-	if ("$ref" in node && typeof node["$ref"] === "string") return resolveRef(root, node["$ref"]);
-	return node;
-}
-function hasExplicitValue(node) {
-	return "example" in node || "examples" in node || "enum" in node || "const" in node || "x-faker" in node;
-}
-function matchesCondition(node, when) {
-	if (when.type) {
-		if (!(Array.isArray(when.type) ? when.type : [when.type]).includes(node.type)) return false;
-	}
-	if (when.format && node.format !== when.format) return false;
-	return true;
-}
-function applyAction(node, then) {
-	if ("example" in then) node.example = then.example;
-	else if ("faker" in then) node["x-faker"] = then.args ? { [then.faker]: then.args } : then.faker;
-	else if ("default" in then) node.default = then.default;
-}
-function extractPropertyTarget(given) {
-	const match = given.match(/\.properties\.([^.[]+)$/);
-	return match ? match[1] : void 0;
-}
-function extractSchemaEntryPath(given) {
-	const idx = given.lastIndexOf(".properties.");
-	if (idx === -1) return void 0;
-	return given.slice(0, idx);
-}
-function walkSchemaProperties(schema, root, visitor, visited = /* @__PURE__ */ new Set()) {
-	const resolved = resolveSchemaNode(root, schema);
-	if (!resolved) return;
-	if (visited.has(resolved)) return;
-	visited.add(resolved);
-	if (resolved.properties && typeof resolved.properties === "object") for (const [name, propValue] of Object.entries(resolved.properties)) {
-		if (typeof propValue !== "object" || propValue === null) continue;
-		const propSchema = propValue;
-		visitor(name, propSchema);
-		walkSchemaProperties(propSchema, root, visitor, visited);
-	}
-	if (resolved.items && typeof resolved.items === "object") walkSchemaProperties(resolved.items, root, visitor, visited);
-	for (const key of [
-		"allOf",
-		"oneOf",
-		"anyOf"
-	]) {
-		const arr = resolved[key];
-		if (Array.isArray(arr)) {
-			for (const sub of arr) if (typeof sub === "object" && sub !== null) walkSchemaProperties(sub, root, visitor, visited);
-		}
-	}
-}
-var MockPlugin = class MockPlugin {
-	rules;
-	constructor(options) {
-		this.rules = options.rules;
-	}
-	apply(compiler) {
-		compiler.hooks.beforeValidate.tap(MockPlugin.name, (spec) => {
-			for (const rule of this.rules) this.applyRule(spec, rule);
-		});
-	}
-	applyRule(spec, rule) {
-		const propertyTarget = extractPropertyTarget(rule.given);
-		if (!propertyTarget) {
-			const matches = (0, jsonpath_plus.JSONPath)({
-				path: rule.given,
-				json: spec,
-				resultType: "all"
-			});
-			for (const match of matches) {
-				const node = match.value;
-				if (typeof node !== "object" || node === null) continue;
-				const schema = node;
-				if (hasExplicitValue(schema)) continue;
-				if (rule.when && !matchesCondition(schema, rule.when)) continue;
-				applyAction(schema, rule.then);
-			}
-			return;
-		}
-		const schemaEntryPath = extractSchemaEntryPath(rule.given);
-		if (!schemaEntryPath) return;
-		const entries = (0, jsonpath_plus.JSONPath)({
-			path: schemaEntryPath,
-			json: spec,
-			resultType: "all"
-		});
-		for (const entry of entries) {
-			if (typeof entry.value !== "object" || entry.value === null) continue;
-			const schemaEntry = entry.value;
-			walkSchemaProperties(schemaEntry, spec, (propName, propSchema) => {
-				if (propName !== propertyTarget) return;
-				if (hasExplicitValue(propSchema)) return;
-				if (rule.when && !matchesCondition(propSchema, rule.when)) return;
-				applyAction(propSchema, rule.then);
-			});
-		}
-	}
-};
-//#endregion
-Object.defineProperty(exports, "ApiDocumentV3_1", {
-	enumerable: true,
-	get: function() {
-		return ApiDocumentV3_1;
-	}
-});
-Object.defineProperty(exports, "Artifact", {
-	enumerable: true,
-	get: function() {
-		return Artifact;
-	}
-});
-Object.defineProperty(exports, "Asset", {
-	enumerable: true,
-	get: function() {
-		return Asset;
-	}
-});
-Object.defineProperty(exports, "BodyFallbackPlugin", {
-	enumerable: true,
-	get: function() {
-		return BodyFallbackPlugin;
-	}
-});
-Object.defineProperty(exports, "ChineseToPinyinPlugin", {
-	enumerable: true,
-	get: function() {
-		return ChineseToPinyinPlugin;
-	}
-});
-Object.defineProperty(exports, "CleanPlugin", {
-	enumerable: true,
-	get: function() {
-		return CleanPlugin;
-	}
-});
-Object.defineProperty(exports, "DECLARATION_GENERATOR", {
-	enumerable: true,
-	get: function() {
-		return DECLARATION_GENERATOR;
-	}
-});
-Object.defineProperty(exports, "DownloadHttpFilePlugin", {
-	enumerable: true,
-	get: function() {
-		return DownloadHttpFilePlugin;
-	}
-});
-Object.defineProperty(exports, "DownloadLocalFilePlugin", {
-	enumerable: true,
-	get: function() {
-		return DownloadLocalFilePlugin;
-	}
-});
-Object.defineProperty(exports, "EslintPlugin", {
-	enumerable: true,
-	get: function() {
-		return EslintPlugin;
-	}
-});
-Object.defineProperty(exports, "Exception", {
-	enumerable: true,
-	get: function() {
-		return Exception;
-	}
-});
-Object.defineProperty(exports, "FileTracker", {
-	enumerable: true,
-	get: function() {
-		return FileTracker;
-	}
-});
-Object.defineProperty(exports, "GenerateDeclarationPlugin", {
-	enumerable: true,
-	get: function() {
-		return GenerateDeclarationPlugin;
-	}
-});
-Object.defineProperty(exports, "GenerateMicroFunctionPlugin", {
-	enumerable: true,
-	get: function() {
-		return GenerateMicroFunctionPlugin;
-	}
-});
-Object.defineProperty(exports, "GenerateNestjsModulePlugin", {
-	enumerable: true,
-	get: function() {
-		return GenerateNestjsModulePlugin;
-	}
-});
-Object.defineProperty(exports, "InitializePlugin", {
-	enumerable: true,
-	get: function() {
-		return InitializePlugin;
-	}
-});
-Object.defineProperty(exports, "LintSchemaPlugin", {
-	enumerable: true,
-	get: function() {
-		return LintSchemaPlugin;
-	}
-});
-Object.defineProperty(exports, "MICRO_FUNCTION_GENERATOR", {
-	enumerable: true,
-	get: function() {
-		return MICRO_FUNCTION_GENERATOR;
-	}
-});
-Object.defineProperty(exports, "MICRO_FUNCTION_REQUEST_GENERATOR", {
-	enumerable: true,
-	get: function() {
-		return MICRO_FUNCTION_REQUEST_GENERATOR;
-	}
-});
-Object.defineProperty(exports, "MicroFunctionGenerator", {
-	enumerable: true,
-	get: function() {
-		return MicroFunctionGenerator;
-	}
-});
-Object.defineProperty(exports, "MockPlugin", {
-	enumerable: true,
-	get: function() {
-		return MockPlugin;
-	}
-});
-Object.defineProperty(exports, "ModuleDefinition", {
-	enumerable: true,
-	get: function() {
-		return ModuleDefinition;
-	}
-});
-Object.defineProperty(exports, "NestjsModuleGenerator", {
-	enumerable: true,
-	get: function() {
-		return NestjsModuleGenerator;
-	}
-});
-Object.defineProperty(exports, "OPERATION_GENERATOR", {
-	enumerable: true,
-	get: function() {
-		return OPERATION_GENERATOR;
-	}
-});
-Object.defineProperty(exports, "OpenapiUtils", {
-	enumerable: true,
-	get: function() {
-		return OpenapiUtils;
-	}
-});
-Object.defineProperty(exports, "OperationDeclarationGenerator", {
-	enumerable: true,
-	get: function() {
-		return OperationDeclarationGenerator;
-	}
-});
-Object.defineProperty(exports, "OperationDefinition", {
-	enumerable: true,
-	get: function() {
-		return OperationDefinition;
-	}
-});
-Object.defineProperty(exports, "OverwriteAdditionalPropertiesPlugin", {
-	enumerable: true,
-	get: function() {
-		return OverwriteAdditionalPropertiesPlugin;
-	}
-});
-Object.defineProperty(exports, "OverwriteOperationIdPlugin", {
-	enumerable: true,
-	get: function() {
-		return OverwriteOperationIdPlugin;
-	}
-});
-Object.defineProperty(exports, "OverwriteQueryOptionsPlugin", {
-	enumerable: true,
-	get: function() {
-		return OverwriteQueryOptionsPlugin;
-	}
-});
-Object.defineProperty(exports, "OverwriteSchemaNamePlugin", {
-	enumerable: true,
-	get: function() {
-		return OverwriteSchemaNamePlugin;
-	}
-});
-Object.defineProperty(exports, "PrettierPlugin", {
-	enumerable: true,
-	get: function() {
-		return PrettierPlugin;
-	}
-});
-Object.defineProperty(exports, "QsArrayFormat", {
-	enumerable: true,
-	get: function() {
-		return QsArrayFormat;
-	}
-});
-Object.defineProperty(exports, "RESPONSE_GENERATOR", {
-	enumerable: true,
-	get: function() {
-		return RESPONSE_GENERATOR;
-	}
-});
-Object.defineProperty(exports, "RequestGenerator", {
-	enumerable: true,
-	get: function() {
-		return RequestGenerator;
-	}
-});
-Object.defineProperty(exports, "ResponseDeclarationGenerator", {
-	enumerable: true,
-	get: function() {
-		return ResponseDeclarationGenerator;
-	}
-});
-Object.defineProperty(exports, "SCHEMA_GENERATOR", {
-	enumerable: true,
-	get: function() {
-		return SCHEMA_GENERATOR;
-	}
-});
-Object.defineProperty(exports, "SchemaDeclarationGenerator", {
-	enumerable: true,
-	get: function() {
-		return SchemaDeclarationGenerator;
-	}
-});
-Object.defineProperty(exports, "SchemaDefinition", {
-	enumerable: true,
-	get: function() {
-		return SchemaDefinition;
-	}
-});
-Object.defineProperty(exports, "ShakingPlugin", {
-	enumerable: true,
-	get: function() {
-		return ShakingPlugin;
-	}
-});
-Object.defineProperty(exports, "SpringdocCompatPlugin", {
-	enumerable: true,
-	get: function() {
-		return SpringdocCompatPlugin;
-	}
-});
-Object.defineProperty(exports, "SupportedMethods", {
-	enumerable: true,
-	get: function() {
-		return SupportedMethods;
-	}
-});
-Object.defineProperty(exports, "TerminalSelectPlugin", {
-	enumerable: true,
-	get: function() {
-		return TerminalSelectPlugin;
-	}
-});
-Object.defineProperty(exports, "USE_VALIBOT", {
-	enumerable: true,
-	get: function() {
-		return USE_VALIBOT;
-	}
-});
-Object.defineProperty(exports, "UseValibotPlugin", {
-	enumerable: true,
-	get: function() {
-		return UseValibotPlugin;
-	}
-});
-
-//# sourceMappingURL=plugins-CgMhaNZq.cjs.map