keq 2.8.14 → 2.9.0

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

@@ -0,0 +1,3558 @@
+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