keq 2.8.13 → 2.9.0

package/packages/cli/dist/plugins-DCvJ8iHR.mjs

@@ -0,0 +1,3280 @@
+import { t as logger } from "./logger-QLBHySQ3.mjs";
+import { AsyncSeriesWaterfallHook } from "tapable";
+import fs from "fs-extra";
+import * as path$1 from "path";
+import * as R from "ramda";
+import { ESLint } from "eslint";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as changeCase from "change-case";
+import { JSONPath } from "jsonpath-plus";
+import jsonpointer from "jsonpointer";
+import { upgrade } from "@scalar/openapi-parser";
+import { CustomError } from "ts-custom-error";
+import wrap from "word-wrap";
+import { fixSwagger } from "swagger-fix";
+import * as fs$1 from "fs/promises";
+import * as yaml from "js-yaml";
+import { fileURLToPath } from "url";
+import { openapiShakingSync } from "@opendoc/openapi-shaking";
+import { select } from "inquirer-select-pro";
+import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
+import Ajv2020 from "ajv/dist/2020.js";
+//#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({ fix: true }).lintFiles(files.map((file) => file.path));
+			await 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 = promisify(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$1.extname(options.filepath);
+		this.content = options.content;
+	}
+	get dirname() {
+		return path$1.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 R.uniq(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 R.uniq(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 R.uniq([
+			...JSONPath({
+				path: "$.requestBody.content..schema..$ref",
+				json: this.operation
+			}),
+			...JSONPath({
+				path: "$.responses..content..schema..$ref",
+				json: this.operation
+			}),
+			...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 R.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 R.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));
+		}
+		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 R.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.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.stat(file.filepath)).mtimeMs;
+		} catch {
+			file.mtimeMs = 0;
+		}
+	}
+	async isChanged() {
+		for (const file of this.files) try {
+			if ((await fs.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 = R.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 && !R.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 && !R.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(R.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(R.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(R.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(R.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(R.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(R.isNotNil).join("\n");
+	}
+	static renderContentType(response, options) {
+		const content = response.content;
+		if (!content || R.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 = R.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 = R.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 = changeCase.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 R.path(path, swagger) !== void 0;
+	}
+	return false;
+}
+//#endregion
+//#region src/utils/openapi-utils/remove-undefined-ref.ts
+function removeUndefinedRef(swagger) {
+	const shadow = R.clone(swagger);
+	const matches = JSONPath({
+		path: "$..*['$ref']^",
+		json: swagger,
+		resultType: "all"
+	});
+	for (const match of matches) if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) jsonpointer.set(shadow, match.pointer, R.omit(["$ref"], match.value));
+	return shadow;
+}
+//#endregion
+//#region src/utils/openapi-utils/dereference-operation.ts
+function dereferencePathObject(swagger) {
+	const matches = JSONPath({
+		path: "$.paths.*.$ref^",
+		json: swagger,
+		resultType: "all"
+	});
+	for (const match of matches) {
+		const value = dereference(match.value.$ref, swagger);
+		jsonpointer.set(swagger, match.pointer, value);
+	}
+}
+function dereferenceRequestBody(swagger) {
+	const matches = JSONPath({
+		path: "$.paths.*.*.requestBody.$ref^",
+		json: swagger,
+		resultType: "all"
+	});
+	for (const match of matches) {
+		const value = dereference(match.value.$ref, swagger);
+		jsonpointer.set(swagger, match.pointer, value);
+	}
+}
+function dereferenceResponses(swagger) {
+	const responseMatches = 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.set(swagger, match.pointer, value);
+	}
+	const headerMatches = JSONPath({
+		path: "$.paths.*.*.responses.*.headers.*.$ref^",
+		json: swagger,
+		resultType: "all"
+	});
+	for (const match of headerMatches) {
+		const value = dereference(match.value.$ref, swagger);
+		jsonpointer.set(swagger, match.pointer, value);
+	}
+}
+function dereferenceParameters(swagger) {
+	const matches = JSONPath({
+		path: "$.paths.*.*.parameters.*.$ref^",
+		json: swagger,
+		resultType: "all"
+	});
+	for (const match of matches) {
+		const value = dereference(match.value.$ref, swagger);
+		jsonpointer.set(swagger, match.pointer, value);
+	}
+}
+function dereferenceOperation(swagger) {
+	const shadow = R.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 } = upgrade(openapi);
+	return specification;
+}
+//#endregion
+//#region src/utils/openapi-utils/map-operation.ts
+function mapOperation(specification, mapper) {
+	const shadow = R.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 = R.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 || R.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(R.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 = changeCase.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 CustomError {
+	constructor(module, message) {
+		const moduleName = typeof module === "string" ? module : module.name;
+		const msg = wrap(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 || R.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(R.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(R.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(R.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$1.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 = changeCase.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(R.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 = changeCase.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 = R.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$1.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$1.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$1.dirname(filepath);
+		return new Artifact({
+			id: SchemaDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
+			filepath,
+			content: EntrypointTransformer.toTypescript(exports, { dirpath })
+		});
+	}
+	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+		return [
+			".",
+			changeCase[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 = `${changeCase[fileNamingStyle](schemaDefinition.name)}.schema.ts`;
+		return [
+			".",
+			changeCase[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 = R.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$1.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$1.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$1.dirname(filepath);
+		return new Artifact({
+			id: ResponseDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
+			filepath,
+			content: EntrypointTransformer.toTypescript(exports, { dirpath })
+		});
+	}
+	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+		return [
+			".",
+			changeCase[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 = `${changeCase[fileNamingStyle](responseDefinition.name)}.response.ts`;
+		return [
+			".",
+			changeCase[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$1.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$1.relative(dirpath, SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.rendering.fileNamingStyle));
+					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+				},
+				getDependentResponseDefinitionFilepath(dependentResponseDefinition) {
+					const relativePath = path$1.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$1.dirname(filepath);
+		return new Artifact({
+			id: OperationDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
+			filepath,
+			content: EntrypointTransformer.toTypescript(exports, { dirpath })
+		});
+	}
+	static getOperationDefinitionArtifactFilepath(operationDefinition, fileNamingStyle) {
+		const filename = `${changeCase[fileNamingStyle](operationDefinition.operationId)}.type.ts`;
+		return [
+			".",
+			changeCase[fileNamingStyle](operationDefinition.module.name),
+			"types",
+			"operations",
+			filename
+		].join("/");
+	}
+	static getOperationDefinitionArtifactId(operationDefinition) {
+		return `${operationDefinition.id}?generator=${OPERATION_GENERATOR}`;
+	}
+	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+		return [
+			".",
+			changeCase[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 AsyncSeriesWaterfallHook(["artifact", "task"]),
+				afterSchemaDeclarationArtifactGenerated: new AsyncSeriesWaterfallHook([
+					"artifact",
+					"schemaDefinition",
+					"task"
+				]),
+				afterResponseDeclarationArtifactGenerated: new AsyncSeriesWaterfallHook([
+					"artifact",
+					"responseDefinition",
+					"task"
+				]),
+				afterOperationDeclarationArtifactGenerated: new 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 `./${changeCase[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(R.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$1.dirname(filepath);
+		return new Artifact({
+			id: MicroFunctionGenerator.getOperationDefinitionArtifactId(operationDefinition),
+			filepath,
+			content: OperationDefinitionTransformer.toMicroFunction(operationDefinition, {
+				esm: rc.rendering.esm,
+				getOperationDefinitionDeclarationFilepath(operationDefinition) {
+					const relativePath = path$1.relative(dirpath, OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.rendering.fileNamingStyle));
+					return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+				},
+				getRequestFilepath() {
+					const relativePath = path$1.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 = `${changeCase[fileNamingStyle](operationDefinition.operationId)}.fn.ts`;
+		return [
+			".",
+			changeCase[fileNamingStyle](operationDefinition.module.name),
+			"operations",
+			filename
+		].join("/");
+	}
+	static getOperationDefinitionArtifactId(operationDefinition) {
+		return `${operationDefinition.id}?generator=${MICRO_FUNCTION_GENERATOR}`;
+	}
+	static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+		return [
+			".",
+			changeCase[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 AsyncSeriesWaterfallHook(["artifact", "task"]),
+				afterMicroFunctionArtifactGenerated: new 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(R.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(R.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$1.dirname(filepath);
+			const valibotContent = SchemaDefinitionTransformer.toValibot(schemaDefinition, {
+				esm: rc.rendering.esm,
+				additionalPropertiesType: rc.rendering.additionalPropertiesType,
+				getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
+					const relativePath = path$1.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$1.dirname(filepath);
+		return new Artifact({
+			id: NestjsModuleGenerator.getNestjsModuleArtifactId(document),
+			filepath,
+			content: ApiDocumentTransformer.toNestjsModule(document, {
+				esm: rc.rendering.esm,
+				getNestjsClientFilepath(document) {
+					const relativePath = path$1.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$1.dirname(filepath);
+		return new Artifact({
+			id: NestjsModuleGenerator.getNestjsClientArtifactId(document),
+			filepath,
+			content: ApiDocumentTransformer.toNestjsClient(document, {
+				esm: rc.rendering.esm,
+				getOperationDefinitionDeclarationFilepath(operationDefinition) {
+					const relativePath = path$1.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 = `${changeCase[fileNamingStyle](document.module.name)}.module.ts`;
+		return [
+			".",
+			changeCase[fileNamingStyle](document.module.name),
+			filename
+		].join("/");
+	}
+	static getNestjsModuleArtifactId(document) {
+		return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}`;
+	}
+	static getNestjsClientArtifactFilepath(document, fileNamingStyle) {
+		const filename = `${changeCase[fileNamingStyle](document.module.name)}.client.ts`;
+		return [
+			".",
+			changeCase[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 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(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, encoding } = address;
+			if (!url.startsWith("file://")) return void 0;
+			const filepath = fileURLToPath(url);
+			const fileExt = path$1.extname(filepath);
+			const content = await fs$1.readFile(filepath, encoding);
+			const str = typeof content === "string" ? content : content.toString(encoding);
+			if ([".yml", ".yaml"].includes(fileExt)) {
+				const value = 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(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(ListrInquirerPromptAdapter).run(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.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(...R.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 = 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 Ajv2020({
+				allErrors: true,
+				strict: false
+			}).getSchema("https://json-schema.org/draft/2020-12/schema");
+			if (!validate) {
+				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) 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) 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) 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) 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) 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}`;
+					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 = 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 = 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
+export { ResponseDeclarationGenerator as A, ModuleDefinition as B, MICRO_FUNCTION_REQUEST_GENERATOR as C, OPERATION_GENERATOR as D, GenerateDeclarationPlugin as E, FileTracker as F, QsArrayFormat as G, PrettierPlugin as H, Asset as I, ApiDocumentV3_1 as L, SchemaDeclarationGenerator as M, Exception as N, OperationDeclarationGenerator as O, OpenapiUtils as P, OperationDefinition as R, MicroFunctionGenerator as S, DECLARATION_GENERATOR as T, EslintPlugin as U, Artifact as V, SupportedMethods as W, USE_VALIBOT as _, OverwriteQueryOptionsPlugin as a, GenerateMicroFunctionPlugin as b, InitializePlugin as c, ShakingPlugin as d, DownloadLocalFilePlugin as f, NestjsModuleGenerator as g, GenerateNestjsModulePlugin as h, OverwriteAdditionalPropertiesPlugin as i, SCHEMA_GENERATOR as j, RESPONSE_GENERATOR as k, CleanPlugin as l, ChineseToPinyinPlugin as m, SpringdocCompatPlugin as n, OverwriteSchemaNamePlugin as o, DownloadHttpFilePlugin as p, LintSchemaPlugin as r, OverwriteOperationIdPlugin as s, MockPlugin as t, TerminalSelectPlugin as u, UseValibotPlugin as v, RequestGenerator as w, MICRO_FUNCTION_GENERATOR as x, BodyFallbackPlugin as y, SchemaDefinition as z };
+
+//# sourceMappingURL=plugins-DCvJ8iHR.mjs.map