@keq-request/cli 5.0.0-alpha.29 → 5.0.0-alpha.31

package/dist/chunk-7HHTHYRA.cjs

@@ -0,0 +1,2895 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7;// src/plugins/eslint/eslint.plugin.ts
+var _eslint = require('eslint');
+
+// src/plugins/eslint/constants/metadata-storage.ts
+var MetadataStorage = /* @__PURE__ */ new WeakMap();
+
+// 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 eslint = new (0, _eslint.ESLint)({ fix: true });
+      const results = await eslint.lintFiles(files.map((file) => file.path));
+      await _eslint.ESLint.outputFixes(results);
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage.has(compiler)) {
+      MetadataStorage.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/prettier/prettier.plugin.ts
+var _child_process = require('child_process');
+var _util = require('util');
+
+// src/plugins/prettier/constants/metadata-storage.ts
+var MetadataStorage2 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/prettier/prettier.plugin.ts
+var execAsync = _util.promisify.call(void 0, _child_process.exec);
+var PrettierPlugin = class _PrettierPlugin {
+  apply(compiler) {
+    if (!compiler.options.build) return;
+    const metadata = _PrettierPlugin.register(compiler);
+    if (metadata.applied) return;
+    metadata.applied = true;
+    compiler.hooks.afterPersist.tapPromise(_PrettierPlugin.name, async () => {
+      const files = compiler.context.assets || [];
+      if (files.length === 0) return;
+      const filePaths = files.map((file) => file.path).join(" ");
+      await execAsync(`prettier --write ${filePaths}`);
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage2.has(compiler)) {
+      MetadataStorage2.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage2.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/body-fallback/index.ts
+var _ramda = require('ramda'); var R20 = _interopRequireWildcard(_ramda); var R19 = _interopRequireWildcard(_ramda); var R3 = _interopRequireWildcard(_ramda); var R2 = _interopRequireWildcard(_ramda); var R = _interopRequireWildcard(_ramda); var R5 = _interopRequireWildcard(_ramda); var R4 = _interopRequireWildcard(_ramda); var R6 = _interopRequireWildcard(_ramda); var R7 = _interopRequireWildcard(_ramda); var R8 = _interopRequireWildcard(_ramda); var R13 = _interopRequireWildcard(_ramda); var R11 = _interopRequireWildcard(_ramda); var R10 = _interopRequireWildcard(_ramda); var R9 = _interopRequireWildcard(_ramda); var R12 = _interopRequireWildcard(_ramda); var R15 = _interopRequireWildcard(_ramda); var R14 = _interopRequireWildcard(_ramda); var R16 = _interopRequireWildcard(_ramda); var R17 = _interopRequireWildcard(_ramda); var R18 = _interopRequireWildcard(_ramda); var R21 = _interopRequireWildcard(_ramda);
+
+// src/utils/json-schema-utils/is-array.ts
+function isArray(schema) {
+  return schema.type === "array";
+}
+
+// src/utils/json-schema-utils/is-mixed.ts
+function isMixed(schema) {
+  return Array.isArray(schema.type);
+}
+
+// src/utils/json-schema-utils/is-non-array.ts
+function isNonArray(schema) {
+  return typeof schema.type === "string" && schema.type !== "array";
+}
+
+// src/utils/json-schema-utils/is-ref.ts
+function isRef(schema) {
+  return "$ref" in schema;
+}
+
+// src/utils/json-schema-utils/index.ts
+var JsonSchemaUtils = (_class = class {
+  static __initStatic() {this.isRef = isRef}
+  static __initStatic2() {this.isArray = isArray}
+  static __initStatic3() {this.isNonArray = isNonArray}
+  static __initStatic4() {this.isMixed = isMixed}
+}, _class.__initStatic(), _class.__initStatic2(), _class.__initStatic3(), _class.__initStatic4(), _class);
+
+// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
+var _tapable = require('tapable');
+
+// src/plugins/generate-micro-function/constants/metadata-storage.ts
+var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
+
+var _path = require('path'); var path7 = _interopRequireWildcard(_path); var path = _interopRequireWildcard(_path); var path6 = _interopRequireWildcard(_path); var path4 = _interopRequireWildcard(_path); var path5 = _interopRequireWildcard(_path); var path8 = _interopRequireWildcard(_path); var path9 = _interopRequireWildcard(_path); var path10 = _interopRequireWildcard(_path);
+var _changecase = require('change-case'); var changeCase6 = _interopRequireWildcard(_changecase); var changeCase5 = _interopRequireWildcard(_changecase); var changeCase = _interopRequireWildcard(_changecase); var changeCase2 = _interopRequireWildcard(_changecase); var changeCase3 = _interopRequireWildcard(_changecase); var changeCase4 = _interopRequireWildcard(_changecase); var changeCase7 = _interopRequireWildcard(_changecase);
+
+// src/models/artifact.ts
+
+
+// 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 {
+  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");
+  }
+};
+
+// src/models/artifact.ts
+var HeaderComment = [
+  "// Code generated by keq-cli. DO NOT EDIT.",
+  "// Code generated by keq-cli. DO NOT EDIT.",
+  "// Code generated by keq-cli. DO NOT EDIT.",
+  "",
+  ""
+].join("\n");
+var Artifact = (_class2 = class {
+  
+  
+  
+  
+  __init() {this.anchor = new Anchor(this)}
+  constructor(options) {;_class2.prototype.__init.call(this);
+    this.id = options.id;
+    this.filepath = options.filepath;
+    this.extensionName = options.extensionName || path.extname(options.filepath);
+    this.content = options.content;
+  }
+  get dirname() {
+    return path.dirname(this.filepath);
+  }
+  renderer() {
+    return `${HeaderComment}${this.content}`;
+  }
+}, _class2);
+
+// src/models/api-document_v3_1.ts
+
+
+// src/models/module-definition.ts
+var ModuleDefinition = class _ModuleDefinition {
+  
+  
+  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" });
+  }
+};
+
+// src/constants/supported-methods.ts
+var SupportedMethods = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+];
+
+// src/models/operation-definition.ts
+
+
+// src/utils/is-keywords.ts
+var 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);
+}
+
+// src/utils/is-reserved-word.ts
+var 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);
+}
+
+// src/models/operation-definition.ts
+var _jsonpathplus = require('jsonpath-plus');
+
+// src/models/schema-definition.ts
+
+
+var SchemaDefinition = class _SchemaDefinition {
+  
+  
+  
+  
+  get id() {
+    return `${this.module.address}#/components/schemas/${this.name}`;
+  }
+  constructor(args) {
+    this.module = args.module;
+    this.name = args.name;
+    this.schema = args.schema;
+    this.document = args.document;
+  }
+  getDependencies() {
+    const refs = R.uniq(_jsonpathplus.JSONPath.call(void 0, {
+      path: "$..*['$ref']",
+      json: this.schema
+    }));
+    return refs.filter((ref) => typeof ref === "string" && !!ref.trim()).map((ref) => {
+      const definition = this.document.dereference(ref);
+      if (definition) return definition;
+      return _SchemaDefinition.unknown();
+    });
+  }
+  static unknown() {
+    return new _SchemaDefinition({
+      name: "",
+      schema: {},
+      module: ModuleDefinition.unknown(),
+      document: ApiDocumentV3_1.unknown()
+    });
+  }
+  static isUnknown(definition) {
+    return definition.name === "";
+  }
+};
+
+// src/models/operation-definition.ts
+var OperationDefinition = class {
+  
+  
+  
+  
+  
+  
+  get id() {
+    return `${this.module.address}#/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() {
+    const refs = R2.uniq([
+      ..._jsonpathplus.JSONPath.call(void 0, {
+        path: "$.requestBody.content..schema..$ref",
+        json: this.operation
+      }),
+      ..._jsonpathplus.JSONPath.call(void 0, {
+        path: "$.responses..content..schema..$ref",
+        json: this.operation
+      }),
+      ..._jsonpathplus.JSONPath.call(void 0, {
+        path: "$.parameters..schema..$ref",
+        json: this.operation
+      })
+    ]);
+    const dependencies = refs.filter((ref) => typeof ref === "string" && ref).map((ref) => {
+      const schemaDefinition = this.document.dereference(ref);
+      if (schemaDefinition) return schemaDefinition;
+      return SchemaDefinition.unknown();
+    });
+    return dependencies;
+  }
+};
+
+// src/utils/logger.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var logger = {
+  log: (str) => console.log(_chalk2.default.green(str)),
+  warn: (str) => console.warn(_chalk2.default.yellow(str)),
+  error: (str) => console.error(_chalk2.default.red(str))
+};
+
+// src/models/api-document_v3_1.ts
+var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
+  
+  
+  constructor(specification, module) {
+    this.module = module;
+    this.specification = specification;
+  }
+  get schemas() {
+    const module = this.module;
+    return Object.entries(_optionalChain([this, 'access', _ => _.specification, 'access', _2 => _2.components, 'optionalAccess', _3 => _3.schemas]) || {}).map(([name, schema]) => new SchemaDefinition({
+      name,
+      schema,
+      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 R3.isEmpty(this.specification.paths);
+  }
+  dereference($ref) {
+    if ($ref.startsWith("#/")) {
+      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 path11 = $ref.replace("#/", "").split("/");
+      return R3.path(path11, this.specification) !== void 0;
+    }
+    return false;
+  }
+  static unknown() {
+    return new _ApiDocumentV3_1({}, ModuleDefinition.unknown());
+  }
+};
+
+// src/models/asset.ts
+var Asset = class {
+  
+  constructor(path11) {
+    this.path = path11;
+  }
+};
+
+// src/plugins/generate-declaration/generate-declaration.plugin.ts
+
+
+// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
+
+
+
+// src/transformers/json-schema/comment.renderer.ts
+var CommentRenderer = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  render() {
+    const schema = this.schema;
+    const lines = ["/**"];
+    if (schema.description) {
+      const description = schema.description.replace("*/", "*\\/");
+      lines.push(...description.split("\n").map((line) => ` * ${line}`));
+    }
+    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");
+  }
+};
+
+// src/transformers/json-schema/declaration.renderer.ts
+
+
+// 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");
+}
+
+// src/transformers/json-schema/reference.transformer.ts
+
+var ReferenceTransformer = class {
+  static toDeclaration(schema, alias2 = R4.identity) {
+    if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
+    const parts = schema.$ref.split("/");
+    return alias2(parts[parts.length - 1]) || "unknown";
+  }
+};
+
+// src/transformers/json-schema/declaration.renderer.ts
+var DeclarationRenderer = 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)) {
+      schema.type.map((type) => ({ ...schema, type })).map((schema2) => this.renderSchema(schema2)).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)) {
+      const items = schema.items.map((s) => this.renderSchema(s)).join(", ");
+      return `[${items}]`;
+    }
+    if (schema.items && typeof schema.items === "object") {
+      return `${this.renderSchema(schema.items)}[]`;
+    }
+    return "any[]";
+  }
+  renderObject(schema) {
+    if ((!schema.properties || R5.isEmpty(schema.properties)) && (!schema.additionalProperties || R5.isEmpty(schema.additionalProperties))) {
+      return "object";
+    }
+    const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
+      let $comment = new CommentRenderer(propertySchema).render();
+      if ($comment) $comment += "\n";
+      const $key = `"${propertyName}"${_optionalChain([schema, 'access', _4 => _4.required, 'optionalAccess', _5 => _5.includes, 'call', _6 => _6(propertyName)]) ? "" : "?"}`;
+      const $value = this.renderSchema(propertySchema);
+      return indent(2, `${$comment}${$key}: ${$value}`);
+    });
+    if (schema.additionalProperties) {
+      const $value = schema.additionalProperties === true ? "any" : this.renderSchema(schema.additionalProperties);
+      $properties.push(indent(2, `[key: string]: ${$value}`));
+    }
+    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";
+  }
+};
+
+// 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)) {
+      const schemas = schema.type.map((type) => ({ ...schema, type })).map((schema2) => this.renderSchema(schema2));
+      return `v.union([${schemas.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)) {
+      const items = schema.items.map((s) => this.renderSchema(s)).join(", ");
+      result = `v.tuple([${items}])`;
+    } 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) {
+    if ((!schema.properties || R6.isEmpty(schema.properties)) && (!schema.additionalProperties || R6.isEmpty(schema.additionalProperties))) {
+      return "v.object({})";
+    }
+    const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
+      let $comment = new CommentRenderer(propertySchema).render();
+      if ($comment) $comment += "\n";
+      const $key = `"${propertyName}"`;
+      let $value = this.renderSchema(propertySchema);
+      if (!_optionalChain([schema, 'access', _7 => _7.required, 'optionalAccess', _8 => _8.includes, 'call', _9 => _9(propertyName)])) {
+        $value = `v.optional(${$value})`;
+      }
+      return indent(2, `${$comment}${$key}: ${$value},`);
+    });
+    let result = [
+      "v.object({",
+      ...$properties,
+      "})"
+    ].join("\n");
+    if (schema.additionalProperties) {
+      if (schema.additionalProperties === true) {
+        result = result.replace("v.object({", "v.looseObject({");
+      } else {
+        const $value = this.renderSchema(schema.additionalProperties);
+        result = `v.intersect([${result}, v.record(v.string(), ${$value})])`;
+      }
+    }
+    return result;
+  }
+  renderOneOf(schema) {
+    if (!schema.oneOf) return "v.unknown()";
+    const schemas = schema.oneOf.map((s) => this.renderSchema(s));
+    return `v.union([${schemas.join(", ")}])`;
+  }
+  renderAnyOf(schema) {
+    if (!schema.anyOf) return "v.unknown()";
+    const schemas = schema.anyOf.map((s) => this.renderSchema(s));
+    return `v.union([${schemas.join(", ")}])`;
+  }
+  renderAllOf(schema) {
+    if (!schema.allOf || schema.allOf.length === 0) return "v.unknown()";
+    const schemas = schema.allOf.map((s) => this.renderSchema(s));
+    return `v.intersect([${schemas.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])})`;
+    }
+    const allStrings = schema.enum.every((v) => typeof v === "string");
+    if (allStrings) {
+      const values = schema.enum.map((v) => JSON.stringify(v)).join(", ");
+      return `v.picklist([${values}])`;
+    }
+    const literals = schema.enum.map((v) => `v.literal(${JSON.stringify(v)})`);
+    return `v.union([${literals.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;
+  }
+};
+
+// src/transformers/json-schema/json-schema.transformer.ts
+var JsonSchemaTransformer = class {
+  static toComment(schema) {
+    return new CommentRenderer(schema).render();
+  }
+  static toDeclaration(schema, options) {
+    return new DeclarationRenderer(schema, options).render();
+  }
+  static toValibot(schema, options) {
+    return new ValibotRenderer(schema, options).render();
+  }
+};
+
+// src/transformers/schema-definition/schema-definition.transformer.ts
+
+var SchemaDefinitionTransformer = class {
+  static toDeclaration(schemaDefinition, options) {
+    const dependencies = schemaDefinition.getDependencies();
+    let $dependencies = dependencies.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(R7.isNotNil).join("\n");
+    }
+    if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
+      const $schema = JsonSchemaTransformer.toDeclaration(schemaDefinition.schema);
+      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(R7.isNotNil).join("\n");
+    }
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $dependencies,
+      $comment || void 0,
+      `export type ${schemaDefinition.name} = ${JsonSchemaTransformer.toDeclaration(schemaDefinition.schema)}`,
+      "",
+      "/* @anchor:file:end */"
+    ].filter(R7.isNotNil).join("\n");
+  }
+  static toValibot(schemaDefinition, options) {
+    const dependencies = schemaDefinition.getDependencies();
+    let $dependencies = dependencies.filter((dep) => !SchemaDefinition.isUnknown(dep)).map((dep) => {
+      const filepath = options.getDependentSchemaDefinitionFilepath(dep);
+      return `import { ${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(R7.isNotNil).join("\n");
+    }
+    const $schema = JsonSchemaTransformer.toValibot(schemaDefinition.schema);
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $valibotImport,
+      $dependencies,
+      $comment || void 0,
+      `export const ${schemaDefinition.name}Schema = ${$schema}`,
+      `export type ${schemaDefinition.name} = v.InferOutput<typeof ${schemaDefinition.name}Schema>`,
+      "",
+      "/* @anchor:file:end */"
+    ].filter(R7.isNotNil).join("\n");
+  }
+};
+
+// src/transformers/operation-definition/comment.renderer.ts
+
+var CommentRenderer2 = 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") {
+      lines.push(` * ${R8.trim(operation.summary)}`);
+      lines.push(" *");
+    }
+    if (operation.description && typeof operation.description === "string") {
+      lines.push(` * @description ${R8.trim(operation.description)}`);
+    }
+    lines.push(" */");
+    return lines.join("\n");
+  }
+};
+
+// src/transformers/operation-definition/declaration.renderer.ts
+
+
+// src/transformers/operation-definition/utils/type-name-factory.ts
+
+function typeNameFactory(operationDefinition) {
+  const pascalCaseOperationId = changeCase.pascalCase(operationDefinition.operationId);
+  return (name) => `${pascalCaseOperationId}${name}`;
+}
+
+// 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;
+}
+
+// src/utils/openapi-utils/dereference-operation.ts
+
+var _jsonpointer = require('jsonpointer'); var _jsonpointer2 = _interopRequireDefault(_jsonpointer);
+
+
+// src/utils/openapi-utils/remove-undefined-ref.ts
+
+
+
+
+// src/utils/openapi-utils/is-ref-defined.ts
+
+function isRefDefined($ref, swagger) {
+  if ($ref.startsWith("#/")) {
+    const path11 = $ref.replace("#/", "").split("/");
+    return R9.path(path11, swagger) !== void 0;
+  }
+  return false;
+}
+
+// src/utils/openapi-utils/remove-undefined-ref.ts
+function removeUndefinedRef(swagger) {
+  const shadow = R10.clone(swagger);
+  const matches = _jsonpathplus.JSONPath.call(void 0, {
+    path: "$..*['$ref']^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) {
+      _jsonpointer2.default.set(shadow, match.pointer, R10.omit(["$ref"], match.value));
+    }
+  }
+  return shadow;
+}
+
+// src/utils/openapi-utils/dereference-operation.ts
+function dereferencePathObject(swagger) {
+  const matches = _jsonpathplus.JSONPath.call(void 0, {
+    path: "$.paths.*.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    _jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceRequestBody(swagger) {
+  const matches = _jsonpathplus.JSONPath.call(void 0, {
+    path: "$.paths.*.*.requestBody.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    _jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceResponses(swagger) {
+  const matches = [
+    ..._jsonpathplus.JSONPath.call(void 0, {
+      path: "$.paths.*.*.responses.*.$ref^",
+      json: swagger,
+      resultType: "all"
+    }),
+    ..._jsonpathplus.JSONPath.call(void 0, {
+      path: "$.paths.*.*.responses.*.headers.*.$ref^",
+      json: swagger,
+      resultType: "all"
+    })
+  ];
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    _jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceParameters(swagger) {
+  const matches = _jsonpathplus.JSONPath.call(void 0, {
+    path: "$.paths.*.*.parameters.*.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    _jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceOperation(swagger) {
+  const shadow = R11.clone(swagger);
+  dereferencePathObject(shadow);
+  dereferenceRequestBody(shadow);
+  dereferenceResponses(shadow);
+  dereferenceParameters(shadow);
+  return removeUndefinedRef(shadow);
+}
+
+// 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;
+}
+
+// src/utils/openapi-utils/to-3_1.ts
+var _openapiparser = require('@scalar/openapi-parser');
+function To3_1(openapi) {
+  const { specification } = _openapiparser.upgrade.call(void 0, openapi);
+  return specification;
+}
+
+// src/utils/openapi-utils/map-operation.ts
+
+function mapOperation(specification, mapper) {
+  const shadow = R12.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;
+}
+
+// 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;
+  });
+}
+
+// src/utils/openapi-utils/index.ts
+var OpenapiUtils = (_class3 = class {
+  static __initStatic5() {this.isRefDefined = isRefDefined}
+  static __initStatic6() {this.dereference = dereference}
+  static __initStatic7() {this.dereferenceDeep = dereferenceDeep}
+  static __initStatic8() {this.removeUndefinedRef = removeUndefinedRef}
+  static __initStatic9() {this.dereferenceOperation = dereferenceOperation}
+  static __initStatic10() {this.mapOperation = mapOperation}
+  static __initStatic11() {this.mapParameter = mapParameter}
+  // static updateOperationId = updateOperationId
+  static __initStatic12() {this.to3_1 = To3_1}
+}, _class3.__initStatic5(), _class3.__initStatic6(), _class3.__initStatic7(), _class3.__initStatic8(), _class3.__initStatic9(), _class3.__initStatic10(), _class3.__initStatic11(), _class3.__initStatic12(), _class3);
+
+// src/transformers/operation-definition/declaration.renderer.ts
+var alias = (name) => `${name}Schema`;
+var DeclarationRenderer2 = class {
+  constructor(operationDefinition, options) {
+    this.operationDefinition = operationDefinition;
+    this.options = options;
+    this.typeName = typeNameFactory(operationDefinition);
+  }
+  
+  renderResponseBodies(operation, options) {
+    if (!operation.responses || R13.isEmpty(operation.responses)) {
+      return `export interface ${this.typeName("ResponseBodies")} {}`;
+    }
+    const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
+      if (!JsonSchemaUtils.isRef(response)) {
+        const $value = 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(" | ");
+        return indent(2, `${statusCode}: ${$value || "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 $value = JsonSchemaTransformer.toDeclaration(parameter.schema || { type: "any" }, options);
+      return indent(2, `${$key}: ${$value}`);
+    }).join("\n");
+    return [
+      `export type ${name} = {`,
+      $parameters,
+      "}"
+    ].filter(Boolean).join("\n");
+  }
+  renderDependencies() {
+    const schemaDefinitions = this.operationDefinition.getDependencies().filter((schemaDefinition) => !SchemaDefinition.isUnknown(schemaDefinition));
+    const $schemaDefinitions = schemaDefinitions.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"'));
+    return [
+      'import type { KeqOperation, KeqPathParameterInit, KeqQueryInit, ServerSentEvent } from "keq"',
+      ...$schemaDefinitions
+    ].join("\n");
+  }
+  render() {
+    const { operation } = this.operationDefinition;
+    if (!operation.responses) return "";
+    const jsonSchemaDeclarationRendererOptions = {
+      referenceTransformer: (schema) => {
+        return ReferenceTransformer.toDeclaration(schema, alias);
+      }
+    };
+    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);
+    const $requestQuery = this.rendererParameters(
+      `${this.typeName("RequestQuery")}`,
+      _optionalChain([operation, 'access', _10 => _10.parameters, 'optionalAccess', _11 => _11.filter, 'call', _12 => _12((p) => !JsonSchemaUtils.isRef(p) && p.in === "query")]) || [],
+      jsonSchemaDeclarationRendererOptions
+    );
+    const $routeParameters = this.rendererParameters(
+      `${this.typeName("RouteParameters")}`,
+      _optionalChain([operation, 'access', _13 => _13.parameters, 'optionalAccess', _14 => _14.filter, 'call', _15 => _15((p) => !JsonSchemaUtils.isRef(p) && p.in === "path")]) || [],
+      jsonSchemaDeclarationRendererOptions
+    );
+    const $requestHeaders = this.rendererParameters(
+      `${this.typeName("RequestHeaders")}`,
+      _optionalChain([operation, 'access', _16 => _16.parameters, 'optionalAccess', _17 => _17.filter, 'call', _18 => _18((p) => !JsonSchemaUtils.isRef(p) && p.in === "header")]) || [],
+      jsonSchemaDeclarationRendererOptions
+    );
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $dependencies,
+      "",
+      $responseBodies,
+      "",
+      $requestBodies,
+      "",
+      $requestQuery,
+      "",
+      $routeParameters,
+      "",
+      $requestHeaders,
+      "",
+      $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(R13.isNotNil).join("\n");
+  }
+};
+
+// src/transformers/operation-definition/micro-function.renderer.ts
+
+
+// src/exception.ts
+var _tscustomerror = require('ts-custom-error');
+var _wordwrap = require('word-wrap'); var _wordwrap2 = _interopRequireDefault(_wordwrap);
+var Exception = class extends _tscustomerror.CustomError {
+  constructor(module, message) {
+    const moduleName = typeof module === "string" ? module : module.name;
+    const msg = _wordwrap2.default.call(void 0, message, { width: 60, indent: "    " });
+    super(`${moduleName} module failed to compile:
+${msg}`);
+    Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
+  }
+};
+
+// src/transformers/operation-definition/typescript-snippet.ts
+
+
+// src/constants/file-naming-style.ts
+var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
+  FileNamingStyle2["camelCase"] = "camelCase";
+  FileNamingStyle2["capitalCase"] = "capitalCase";
+  FileNamingStyle2["constantCase"] = "constantCase";
+  FileNamingStyle2["dotCase"] = "dotCase";
+  FileNamingStyle2["headerCase"] = "headerCase";
+  FileNamingStyle2["noCase"] = "noCase";
+  FileNamingStyle2["paramCase"] = "paramCase";
+  FileNamingStyle2["pascalCase"] = "pascalCase";
+  FileNamingStyle2["pathCase"] = "pathCase";
+  FileNamingStyle2["sentenceCase"] = "sentenceCase";
+  FileNamingStyle2["snakeCase"] = "snakeCase";
+  return FileNamingStyle2;
+})(FileNamingStyle || {});
+
+// src/constants/qs-array-format.ts
+var QsArrayFormat = /* @__PURE__ */ ((QsArrayFormat2) => {
+  QsArrayFormat2["brackets"] = "brackets";
+  QsArrayFormat2["indices"] = "indices";
+  QsArrayFormat2["repeat"] = "repeat";
+  QsArrayFormat2["comma"] = "comma";
+  QsArrayFormat2["space"] = "space";
+  QsArrayFormat2["pipe"] = "pipe";
+  return QsArrayFormat2;
+})(QsArrayFormat || {});
+
+// src/transformers/operation-definition/typescript-snippet.ts
+var OperationDefinitionSnippet = class {
+  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 = _nullishCoalesce(parameter.explode, () => ( true));
+    if ("x-qs-array-format" in parameter) {
+      arrayFormat = parameter["x-qs-array-format"];
+    } else {
+      if (style === "deepObject") {
+        arrayFormat = "brackets" /* brackets */;
+      } else if (explode) {
+        arrayFormat = "repeat" /* repeat */;
+      } else {
+        if (style === "form") {
+          arrayFormat = "comma" /* comma */;
+        } else if (style === "spaceDelimited") {
+          arrayFormat = "space" /* space */;
+        } else if (style === "pipeDelimited") {
+          arrayFormat = "pipe" /* 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 } : {}
+      };
+    }
+    return void 0;
+  }
+  // render: "if (args && 'Authorization' in args) req.header('Authorization', args['Authorization'])"
+  renderRequestHeaders() {
+    const { operation } = this.operationDefinition;
+    const $headers = (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");
+    return $headers;
+  }
+  // render: "if (args && 'id' in args) req.query('id', args['id'], options)"
+  renderRequestQuery() {
+    const { operation } = this.operationDefinition;
+    const $query = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
+      const option = this.getQsParameters(p);
+      const $option = !option || R14.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");
+    return $query;
+  }
+  // render: "if (args && 'id' in args) req.params('id', args['id'])"
+  renderRequestPathParameters() {
+    const { operation } = this.operationDefinition;
+    const $pathParameters = (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");
+    return $pathParameters;
+  }
+  getRequestMediaTypes() {
+    const { operation } = this.operationDefinition;
+    const requestBodyContent = _optionalChain([operation, 'access', _19 => _19.requestBody, 'optionalAccess', _20 => _20.content]) || {};
+    return Object.keys(requestBodyContent);
+  }
+  // render "req.type("application/json")"
+  renderMediaType() {
+    const mediaTypes = this.getRequestMediaTypes();
+    if (mediaTypes.length === 1 && !mediaTypes[0].endsWith("/*")) {
+      return `req.type("${mediaTypes[0]}")
+`;
+    } 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 "";
+  }
+  // render body
+  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 = _optionalChain([operation, 'access', _21 => _21.requestBody, 'optionalAccess', _22 => _22.content]) || {};
+    const $requestBody = 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(R14.isNotNil).join("\n");
+    return $requestBody;
+  }
+  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");
+  }
+};
+
+// src/transformers/operation-definition/micro-function.renderer.ts
+var OperationDefinitionMicroFunctionRenderer = class {
+  constructor(operationDefinition, options) {
+    this.operationDefinition = operationDefinition;
+    this.options = options;
+    this.typeName = typeNameFactory(operationDefinition);
+    this.helper = new OperationDefinitionSnippet(operationDefinition, options);
+  }
+  
+  
+  render() {
+    const { operation, operationId, method, pathname } = this.operationDefinition;
+    if (!operation.responses) return "";
+    const $dependencies = this.renderDependencies();
+    const $comment = new CommentRenderer2(this.operationDefinition).render();
+    const moduleName = this.operationDefinition.module.name;
+    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 moduleName = "${moduleName}"`,
+      `const method = "${method}"`,
+      `const pathname = "${pathname}"`,
+      "",
+      $comment || void 0,
+      `export ${$operationDeclaration} {`,
+      `  const req = request.${$method}<${this.typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
+      "    .option('module', { name: moduleName, pathname, method })",
+      "",
+      $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(R15.isNotNil).join("\n");
+  }
+  renderDependencies() {
+    const declarationFilepath = this.options.getOperationDefinitionDeclarationFilepath(this.operationDefinition);
+    const requestFilepath = this.options.getRequestFilepath();
+    return [
+      'import { Keq } from "keq"',
+      `import { request } from "${requestFilepath}"`,
+      `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.operationDefinition;
+    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");
+  }
+};
+
+// src/transformers/operation-definition/nestjs-method.renderer.ts
+
+var OperationDefinitionNestjsMethodRenderer = class {
+  constructor(operationDefinition, options) {
+    this.operationDefinition = operationDefinition;
+    this.options = options;
+    this.typeName = typeNameFactory(operationDefinition);
+    this.helper = new OperationDefinitionSnippet(operationDefinition, options);
+  }
+  
+  
+  render() {
+    const pathname = this.operationDefinition.pathname;
+    const $comment = new CommentRenderer2(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)})`,
+      "    .option(",
+      '      "module",',
+      "      {",
+      `        name: ${JSON.stringify(this.operationDefinition.module.name)},`,
+      `        pathname: ${JSON.stringify(pathname)},`,
+      `        method: ${JSON.stringify($method)},`,
+      "      },",
+      "    )",
+      "",
+      $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(R16.isNotNil).join("\n");
+  }
+  renderOperationDeclaration(operationDefinition) {
+    const { operationId } = operationDefinition;
+    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");
+  }
+};
+
+// src/transformers/operation-definition/operation-definition.transformer.ts
+var OperationDefinitionTransformer = class {
+  static toDeclaration(operationDefinition, options) {
+    return new DeclarationRenderer2(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 CommentRenderer2(operationDefinition).render();
+  }
+};
+
+// src/transformers/entrypoint/entrypoint.transformer.ts
+
+var EntrypointTransformer = class {
+  static toTypescript(exports, options) {
+    const $exports = exports.map((exportArtifact) => {
+      const relativePath = path4.relative(
+        options.dirpath,
+        exportArtifact.filepath
+      ).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, options.esm ? ".js" : "");
+      return relativePath.startsWith(".") ? `export * from '${relativePath}'` : `export * from './${relativePath}'`;
+    });
+    return [
+      "/* @anchor:file:start */",
+      "",
+      ...$exports,
+      "",
+      "/* @anchor:file:end */"
+    ].join("\n");
+  }
+};
+
+// src/transformers/api-document/nestjs-client.renderer.ts
+
+
+var NestjsClientRenderer = class {
+  constructor(document, options) {
+    this.document = document;
+    this.options = options;
+  }
+  renderDependencies() {
+    const $operations = 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"'));
+    return [
+      'import { Injectable, Logger } from "@nestjs/common"',
+      'import { Keq, KeqRequest } from "keq"',
+      ...$operations
+    ].join("\n");
+  }
+  render() {
+    const moduleName = changeCase2.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(R17.isNotNil).join("\n");
+  }
+};
+
+// src/transformers/api-document/nestjs-module.renderer.ts
+
+var NestjsModuleRenderer = class {
+  constructor(document, options) {
+    this.document = document;
+    this.options = options;
+  }
+  render() {
+    const moduleName = changeCase3.pascalCase(this.document.module.name);
+    const clientFilepath = this.options.getNestjsClientFilepath(this.document).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, this.options.esm ? ".js" : "");
+    return [
+      "/* @anchor:file:start */",
+      'import { Module, Inject, ConfigurableModuleBuilder, Global } from "@nestjs/common"',
+      'import { KeqRequest } from "keq"',
+      'import { KeqModuleOptions } from "@keq-request/nestjs"',
+      `import { ${moduleName}Client } from "${clientFilepath}"`,
+      "",
+      "",
+      "const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder<KeqModuleOptions>().build()",
+      "",
+      "@Global()",
+      "@Module({",
+      "  imports: [],",
+      "  controllers: [],",
+      `  providers: [${moduleName}Client],`,
+      `  exports: [${moduleName}Client],`,
+      "})",
+      `export class ${moduleName}Module extends ConfigurableModuleClass {`,
+      "",
+      "  constructor(",
+      "    @Inject(MODULE_OPTIONS_TOKEN) private readonly options: KeqModuleOptions,",
+      "    private readonly request: KeqRequest,",
+      "  ) {",
+      "    super()",
+      "  }",
+      "",
+      "  onModuleInit() {",
+      "    if (this.options.middlewares) {",
+      "      for (const middleware of this.options.middlewares) {",
+      "        this.request.use(middleware)",
+      "      }",
+      "    }",
+      "  }",
+      "}",
+      "",
+      "/* @anchor:file:end */"
+    ].join("\n");
+  }
+};
+
+// 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();
+  }
+};
+
+// src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
+
+
+
+
+// src/plugins/generate-declaration/constants/metadata-storage.ts
+var MetadataStorage4 = /* @__PURE__ */ new Map();
+
+// src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
+var SCHEMA_GENERATOR = "schemaGenerator";
+var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
+  async compile(compiler, task) {
+    const context = compiler.context;
+    const metadata = MetadataStorage4.get(compiler);
+    const rc = context.rc;
+    const documents = context.documents;
+    const schemaDefinitions = 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
+          )
+        ])
+      )
+    );
+    const entrypoints = R18.collectBy(
+      (schemaDefinition) => schemaDefinition.module.name,
+      schemaDefinitions
+    ).map((schemaDefinitions2) => [
+      schemaDefinitions2[0].module,
+      schemaDefinitions2.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.fileNamingStyle);
+    const dirpath = path5.dirname(filepath);
+    const artifact = new Artifact({
+      id: _SchemaDeclarationGenerator.getSchemaDefinitionArtifactId(schemaDefinition),
+      filepath,
+      content: SchemaDefinitionTransformer.toDeclaration(
+        schemaDefinition,
+        {
+          esm: rc.esm,
+          getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
+            const relativePath = path5.relative(
+              dirpath,
+              _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
+            );
+            return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+          }
+        }
+      ),
+      extensionName: ".schema.ts"
+    });
+    return artifact;
+  }
+  generateEntrypointArtifact(moduleDefinition, exports, rc) {
+    const filepath = _SchemaDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
+    const dirpath = path5.dirname(filepath);
+    const artifact = new Artifact({
+      id: _SchemaDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
+      filepath,
+      content: EntrypointTransformer.toTypescript(exports, { dirpath })
+    });
+    return artifact;
+  }
+  static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+    return [
+      ".",
+      changeCase4[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 = `${changeCase4[fileNamingStyle](schemaDefinition.name)}.schema.ts`;
+    return [
+      ".",
+      changeCase4[fileNamingStyle](schemaDefinition.module.name),
+      "types",
+      "components",
+      "schemas",
+      filename
+    ].join("/");
+  }
+  static getSchemaDefinitionArtifactId(schemaDefinition) {
+    return `${schemaDefinition.id}?generator=${SCHEMA_GENERATOR}`;
+  }
+};
+
+// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
+var OPERATION_GENERATOR = "operationDeclarationGenerator";
+var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
+  async compile(compiler, task) {
+    const context = compiler.context;
+    const metadata = MetadataStorage4.get(compiler);
+    const rc = context.rc;
+    const documents = context.documents;
+    const operationDefinitions = 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.fileNamingStyle);
+    const dirpath = path6.dirname(filepath);
+    const artifact = new Artifact({
+      id: _OperationDeclarationGenerator.getOperationDefinitionArtifactId(operationDefinition),
+      filepath,
+      content: OperationDefinitionTransformer.toDeclaration(
+        operationDefinition,
+        {
+          esm: rc.esm,
+          getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
+            const relativePath = path6.relative(
+              dirpath,
+              SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
+            );
+            return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+          }
+        }
+      ),
+      extensionName: ".type.ts"
+    });
+    return artifact;
+  }
+  generateEntrypointArtifact(moduleDefinition, exports, rc) {
+    const filepath = _OperationDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
+    const dirpath = path6.dirname(filepath);
+    const artifact = new Artifact({
+      id: _OperationDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
+      filepath,
+      content: EntrypointTransformer.toTypescript(exports, { dirpath })
+    });
+    return artifact;
+  }
+  static getOperationDefinitionArtifactFilepath(operationDefinition, fileNamingStyle) {
+    const filename = `${changeCase5[fileNamingStyle](operationDefinition.operationId)}.type.ts`;
+    const filepath = [
+      ".",
+      changeCase5[fileNamingStyle](operationDefinition.module.name),
+      "types",
+      "operations",
+      filename
+    ].join("/");
+    return filepath;
+  }
+  static getOperationDefinitionArtifactId(operationDefinition) {
+    return `${operationDefinition.id}?generator=${OPERATION_GENERATOR}`;
+  }
+  static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+    return [
+      ".",
+      changeCase5[fileNamingStyle](moduleDefinition.name),
+      "types",
+      "operations",
+      "index.ts"
+    ].join("/");
+  }
+  static getEntrypointArtifactId(moduleDefinition) {
+    return `${moduleDefinition.address.url}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
+  }
+};
+
+// src/plugins/generate-declaration/generate-declaration.plugin.ts
+var DECLARATION_GENERATOR = "declarationGenerator";
+var GenerateDeclarationPlugin = (_class4 = class _GenerateDeclarationPlugin {
+  __init2() {this.name = DECLARATION_GENERATOR}
+  __init3() {this.operationGenerator = new OperationDeclarationGenerator()}
+  __init4() {this.schemaGenerator = new SchemaDeclarationGenerator()}
+  constructor() {;_class4.prototype.__init2.call(this);_class4.prototype.__init3.call(this);_class4.prototype.__init4.call(this);
+  }
+  apply(compiler) {
+    const metadata = _GenerateDeclarationPlugin.register(compiler);
+    if (metadata.applied) return;
+    metadata.applied = true;
+    compiler.hooks.compile.tapPromise(_GenerateDeclarationPlugin.name, async (task) => {
+      await _asyncOptionalChain([compiler, 'access', async _23 => _23.context, 'access', async _24 => _24.artifacts, 'optionalAccess', async _25 => _25.push, 'call', async _26 => _26(
+        ...await this.schemaGenerator.compile(compiler, task),
+        ...await this.operationGenerator.compile(compiler, task)
+      )]);
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage4.has(compiler)) {
+      MetadataStorage4.set(compiler, {
+        applied: false,
+        hooks: {
+          afterEntrypointArtifactGenerated: new (0, _tapable.AsyncSeriesWaterfallHook)(["artifact", "task"]),
+          afterSchemaDeclarationArtifactGenerated: new (0, _tapable.AsyncSeriesWaterfallHook)(["artifact", "schemaDefinition", "task"]),
+          afterOperationDeclarationArtifactGenerated: new (0, _tapable.AsyncSeriesWaterfallHook)(["artifact", "operationDefinition", "task"])
+        }
+      });
+    }
+    return MetadataStorage4.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+}, _class4);
+
+// src/plugins/generate-micro-function/generators/request/request.generator.ts
+var MICRO_FUNCTION_REQUEST_GENERATOR = "microFunctionRequestGenerator";
+var RequestGenerator = class _RequestGenerator {
+  generateRequestArtifact() {
+    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(),
+      filepath: _RequestGenerator.getRequestArtifactFilepath(),
+      content
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async compile(compiler, task) {
+    return [
+      this.generateRequestArtifact()
+    ];
+  }
+  static getRequestArtifactFilepath() {
+    return "./request.ts";
+  }
+  static getRequestArtifactId() {
+    return `request?generator=${MICRO_FUNCTION_REQUEST_GENERATOR}`;
+  }
+};
+
+// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
+var MICRO_FUNCTION_GENERATOR = "microFunctionGenerator";
+var MicroFunctionGenerator = class _MicroFunctionGenerator {
+  async compile(compiler, task) {
+    const metadata = MetadataStorage3.get(compiler);
+    const context = compiler.context;
+    const rc = context.rc;
+    const documents = context.documents;
+    const operationDefinitions = 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
+          )
+        ])
+      )
+    );
+    const entrypoints = await Promise.all(
+      R19.collectBy(
+        (operationDefinition) => operationDefinition.module.name,
+        operationDefinitions
+      ).map((operationDefinitions2) => [
+        operationDefinitions2[0].module,
+        operationDefinitions2.map((operationDefinition) => artifactMap.get(operationDefinition)).filter((artifact) => Boolean(artifact))
+      ]).map(async ([moduleDefinition, artifacts]) => await metadata.hooks.afterEntrypointArtifactGenerated.promise(
+        this.generateEntrypointArtifact(
+          moduleDefinition,
+          artifacts,
+          rc
+        ),
+        task
+      ))
+    );
+    return [...entrypoints, ...artifactMap.values()];
+  }
+  generateOperationDefinitionArtifact(operationDefinition, rc) {
+    const filepath = _MicroFunctionGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
+    const dirpath = path7.dirname(filepath);
+    const artifact = new Artifact({
+      id: _MicroFunctionGenerator.getOperationDefinitionArtifactId(operationDefinition),
+      filepath,
+      content: OperationDefinitionTransformer.toMicroFunction(operationDefinition, {
+        esm: rc.esm,
+        getOperationDefinitionDeclarationFilepath(operationDefinition2) {
+          const relativePath = path7.relative(
+            dirpath,
+            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition2, rc.fileNamingStyle)
+          );
+          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        },
+        getRequestFilepath() {
+          const relativePath = path7.relative(
+            dirpath,
+            RequestGenerator.getRequestArtifactFilepath()
+          );
+          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        }
+      }),
+      extensionName: ".type.ts"
+    });
+    return artifact;
+  }
+  generateEntrypointArtifact(moduleDefinition, exports, rc) {
+    const filepath = _MicroFunctionGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
+    const dirpath = filepath.substring(0, filepath.lastIndexOf("/"));
+    const artifact = new Artifact({
+      id: _MicroFunctionGenerator.getEntrypointArtifactId(moduleDefinition),
+      filepath,
+      content: EntrypointTransformer.toTypescript(exports, { dirpath })
+    });
+    return artifact;
+  }
+  static getOperationDefinitionArtifactFilepath(operationDefinition, fileNamingStyle) {
+    const filename = `${changeCase6[fileNamingStyle](operationDefinition.operationId)}.fn.ts`;
+    const filepath = [
+      ".",
+      changeCase6[fileNamingStyle](operationDefinition.module.name),
+      "operations",
+      filename
+    ].join("/");
+    return filepath;
+  }
+  static getOperationDefinitionArtifactId(operationDefinition) {
+    return `${operationDefinition.id}?generator=${MICRO_FUNCTION_GENERATOR}`;
+  }
+  static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+    return [
+      ".",
+      changeCase6[fileNamingStyle](moduleDefinition.name),
+      "operations",
+      "index.ts"
+    ].join("/");
+  }
+  static getEntrypointArtifactId(moduleDefinition) {
+    return `${moduleDefinition.address}/paths/entrypoint?generator=${MICRO_FUNCTION_GENERATOR}`;
+  }
+};
+
+// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
+var GenerateMicroFunctionPlugin = (_class5 = class _GenerateMicroFunctionPlugin {constructor() { _class5.prototype.__init5.call(this);_class5.prototype.__init6.call(this); }
+  __init5() {this.microFunctionGenerator = new MicroFunctionGenerator()}
+  __init6() {this.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 (!MetadataStorage3.has(compiler)) {
+      MetadataStorage3.set(compiler, {
+        applied: false,
+        hooks: {
+          afterEntrypointArtifactGenerated: new (0, _tapable.AsyncSeriesWaterfallHook)(["artifact", "task"]),
+          afterMicroFunctionArtifactGenerated: new (0, _tapable.AsyncSeriesWaterfallHook)(["artifact", "operationDefinition", "task"])
+        }
+      });
+    }
+    return MetadataStorage3.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+}, _class5);
+
+// src/plugins/body-fallback/constants/metadata-storage.ts
+var MetadataStorage5 = /* @__PURE__ */ new WeakMap();
+
+// 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 operation = operationDefinition.operation;
+        const parameters = _optionalChain([operation, 'access', _27 => _27.parameters, 'optionalAccess', _28 => _28.filter, 'call', _29 => _29((p) => !JsonSchemaUtils.isRef(p))]) || [];
+        const keys2 = parameters.map((p) => p.name).filter(R20.isNotNil);
+        const $acc = !keys2.length ? "        acc[key] = args[key]" : [
+          `        if (![${keys2.map((k) => JSON.stringify(k)).join(", ")}].includes(key)) {`,
+          "          acc[key] = args[key]",
+          "        }"
+        ].join("\n");
+        artifact.anchor.block.replace("body", [
+          // $mediaType ? `${$mediaType}\n` : undefined,
+          '  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(R20.isNotNil).join("\n"));
+        return artifact;
+      });
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage5.has(compiler)) {
+      MetadataStorage5.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage5.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/use-valibot/constants/metadata-storage.ts
+var MetadataStorage6 = /* @__PURE__ */ new Map();
+
+// src/plugins/use-valibot/use-valibot.plugin.ts
+
+var USE_VALIBOT = "useValibot";
+var UseValibotPlugin = (_class6 = class _UseValibotPlugin {
+  __init7() {this.name = USE_VALIBOT}
+  constructor() {;_class6.prototype.__init7.call(this);
+  }
+  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 = path8.dirname(filepath);
+        const valibotContent = SchemaDefinitionTransformer.toValibot(
+          schemaDefinition,
+          {
+            esm: rc.esm,
+            getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
+              const relativePath = path8.relative(
+                dirpath,
+                SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
+              );
+              return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+            }
+          }
+        );
+        return new Artifact({
+          ...artifact,
+          content: valibotContent
+        });
+      }
+    );
+  }
+  static register(compiler) {
+    if (!MetadataStorage6.has(compiler)) {
+      MetadataStorage6.set(compiler, {
+        applied: false
+      });
+    }
+    return MetadataStorage6.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+}, _class6);
+
+// src/plugins/generate-nestjs-module/generate-nestjs-module.ts
+
+
+// src/plugins/generate-nestjs-module/constants/metadata-storage.ts
+var MetadataStorage7 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/generate-nestjs-module/generators/nestjs-module.generator.ts
+
+
+var NESTJS_MODULE_GENERATOR = "nestjs-module-generator";
+var NestjsModuleGenerator = class _NestjsModuleGenerator {
+  generateNestjsModuleArtifact(document, rc) {
+    const filepath = _NestjsModuleGenerator.getNestjsModuleArtifactFilepath(document, rc.fileNamingStyle);
+    const dirname7 = path9.dirname(filepath);
+    const artifact = new Artifact({
+      id: _NestjsModuleGenerator.getNestjsModuleArtifactId(document),
+      filepath,
+      content: ApiDocumentTransformer.toNestjsModule(document, {
+        esm: rc.esm,
+        getNestjsClientFilepath(document2) {
+          const relativePath = path9.relative(
+            dirname7,
+            _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document2, rc.fileNamingStyle)
+          );
+          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        }
+      })
+    });
+    return artifact;
+  }
+  generateNestjsClientArtifact(document, rc) {
+    const filepath = _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document, rc.fileNamingStyle);
+    const dirpath = path9.dirname(filepath);
+    const artifact = new Artifact({
+      id: _NestjsModuleGenerator.getNestjsClientArtifactId(document),
+      filepath,
+      content: ApiDocumentTransformer.toNestjsClient(document, {
+        esm: rc.esm,
+        getOperationDefinitionDeclarationFilepath(operationDefinition) {
+          const relativePath = path9.relative(
+            dirpath,
+            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle)
+          );
+          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        }
+      })
+    });
+    return artifact;
+  }
+  async compile(compiler, task) {
+    const metadata = MetadataStorage7.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 = `${changeCase7[fileNamingStyle](document.module.name)}.module.ts`;
+    const filepath = [
+      ".",
+      changeCase7[fileNamingStyle](document.module.name),
+      filename
+    ];
+    return filepath.join("/");
+  }
+  static getNestjsModuleArtifactId(document) {
+    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}`;
+  }
+  static getNestjsClientArtifactFilepath(document, fileNamingStyle) {
+    const filename = `${changeCase7[fileNamingStyle](document.module.name)}.client.ts`;
+    const filepath = [
+      ".",
+      changeCase7[fileNamingStyle](document.module.name),
+      filename
+    ];
+    return filepath.join("/");
+  }
+  static getNestjsClientArtifactId(document) {
+    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}-client`;
+  }
+};
+
+// src/plugins/generate-nestjs-module/generate-nestjs-module.ts
+var GenerateNestjsModulePlugin = (_class7 = class _GenerateNestjsModulePlugin {constructor() { _class7.prototype.__init8.call(this); }
+  __init8() {this.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 (!MetadataStorage7.has(compiler)) {
+      MetadataStorage7.set(compiler, {
+        applied: false,
+        hooks: {
+          afterNestjsModuleArtifactGenerated: new (0, _tapable.AsyncSeriesWaterfallHook)(["artifact", "document", "task"])
+        }
+      });
+    }
+    return MetadataStorage7.get(compiler);
+  }
+  static of(compiler) {
+    return MetadataStorage7.get(compiler);
+  }
+}, _class7);
+
+// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
+var _swaggerfix = require('swagger-fix');
+
+// src/plugins/chinese-to-pinyin/constants/metadata-storage.ts
+var MetadataStorage8 = /* @__PURE__ */ new WeakMap();
+
+// 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(
+          _swaggerfix.fixSwagger.call(void 0, doc.specification),
+          doc.module
+        );
+      });
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage8.has(compiler)) {
+      MetadataStorage8.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage8.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/download-http-file/constants/metadata-storage.ts
+var MetadataStorage9 = /* @__PURE__ */ new WeakMap();
+
+// 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) throw new Error(`failed with status code ${res.status}`);
+      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);
+    const spec = OpenapiUtils.to3_1(json);
+    return spec;
+  }
+  static register(compiler) {
+    if (!MetadataStorage9.has(compiler)) {
+      MetadataStorage9.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage9.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/download-local-file/download-local-file.plugin.ts
+
+var _promises = require('fs/promises'); var fs = _interopRequireWildcard(_promises);
+var _jsyaml = require('js-yaml'); var yaml = _interopRequireWildcard(_jsyaml);
+var _url = require('url');
+
+// src/plugins/download-local-file/constants/metadata-storage.ts
+var MetadataStorage10 = /* @__PURE__ */ new WeakMap();
+
+// 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 = _url.fileURLToPath.call(void 0, url);
+      const fileExt = path10.extname(filepath);
+      const content = await fs.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 (!MetadataStorage10.has(compiler)) {
+      MetadataStorage10.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage10.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/shaking/shaking.plugin.ts
+var _openapishaking = require('@opendoc/openapi-shaking');
+
+// src/plugins/shaking/constants/metadata-storage.ts
+var MetadataStorage11 = /* @__PURE__ */ new WeakMap();
+
+// 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.isModuleIgnored(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.isOperationIgnored(new OperationDefinition({
+        method,
+        pathname,
+        operation,
+        module: document.module,
+        document
+      }));
+    };
+    const sharkedSwagger = _openapishaking.openapiShakingSync.call(void 0, 
+      document.specification,
+      isAccepted,
+      { tolerant: rc.tolerant }
+    );
+    return new ApiDocumentV3_1(
+      sharkedSwagger,
+      new ModuleDefinition(
+        document.module.name,
+        {
+          url: `memory://${document.module.name}.v3_1.sharked.json`,
+          headers: {},
+          encoding: "utf8"
+        }
+      )
+    );
+  }
+  static register(compiler) {
+    if (!MetadataStorage11.has(compiler)) {
+      MetadataStorage11.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage11.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/terminal-select/utils/select-operation-definitions.ts
+var _inquirerselectpro = require('inquirer-select-pro');
+var _promptadapterinquirer = require('@listr2/prompt-adapter-inquirer');
+async function selectOperationDefinitions(task, operationDefinitions) {
+  const selectedOperationDefinitions = await task.prompt(_promptadapterinquirer.ListrInquirerPromptAdapter).run(
+    _inquirerselectpro.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 keys2 = input.trim().toLowerCase().split(/\s+/);
+        return items.filter((i) => {
+          const name = i.name.toLowerCase();
+          return keys2.every((q) => name.includes(q));
+        });
+      }
+    }
+  );
+  return selectedOperationDefinitions;
+}
+
+// src/plugins/terminal-select/constants/metadata-storage.ts
+var MetadataStorage12 = /* @__PURE__ */ new WeakMap();
+
+// 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 documents = context.documents;
+      const operationDefinitions = documents.flatMap((document) => document.operations);
+      const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
+      if (this.options.clear) {
+        matcher.append({
+          persist: false,
+          ignore: true,
+          moduleName: "*",
+          operationMethod: "*",
+          operationPathname: "*"
+        });
+      }
+      for (const op of selectedOperationDefinitions) {
+        matcher.append({
+          persist: !!this.options.persist,
+          ignore: this.options.mode === "add",
+          moduleName: op.module.name,
+          operationMethod: op.method,
+          operationPathname: op.pathname
+        });
+      }
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage12.has(compiler)) {
+      MetadataStorage12.set(compiler, {
+        applied: false,
+        hooks: {}
+      });
+    }
+    return MetadataStorage12.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// 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: "except" }
+          )
+        );
+      }
+      const rc = compiler.context.rc;
+      plugins.push(
+        ...R21.unnest(
+          (rc.translators || []).map((translator) => {
+            const plugins2 = translator.apply();
+            return plugins2;
+          })
+        )
+      );
+      if (rc.plugins && rc.plugins.length) {
+        plugins.push(...rc.plugins);
+      }
+      for (const plugin of plugins) {
+        plugin.apply(compiler);
+      }
+    });
+    if (this.options.includes && this.options.includes.length) {
+      const modulesIncludes = this.options.includes;
+      compiler.hooks.afterSetup.tap(_InitializePlugin.name, (task) => {
+        const rc = compiler.context.rc;
+        const matcher = compiler.context.matcher;
+        const notExistModules = modulesIncludes.filter((moduleName) => !(moduleName in rc.modules));
+        if (notExistModules.length) {
+          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
+        }
+        const ignoredModules = R21.difference(R21.keys(rc.modules), modulesIncludes);
+        for (const moduleName of ignoredModules) {
+          matcher.append({
+            persist: false,
+            ignore: true,
+            moduleName,
+            operationMethod: "*",
+            operationPathname: "*"
+          });
+        }
+      });
+    }
+  }
+};
+
+// 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) => {
+        const spec = 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;
+          }
+        );
+        return new ApiDocumentV3_1(spec, document.module);
+      });
+    });
+  }
+};
+
+// src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
+var 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) => {
+        const specification = 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;
+          }
+        );
+        return new ApiDocumentV3_1(
+          specification,
+          document.module
+        );
+      });
+    });
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FileNamingStyle = FileNamingStyle; exports.QsArrayFormat = QsArrayFormat; exports.SupportedMethods = SupportedMethods; exports.EslintPlugin = EslintPlugin; exports.PrettierPlugin = PrettierPlugin; exports.Artifact = Artifact; exports.ModuleDefinition = ModuleDefinition; exports.SchemaDefinition = SchemaDefinition; exports.OperationDefinition = OperationDefinition; exports.logger = logger; exports.ApiDocumentV3_1 = ApiDocumentV3_1; exports.Asset = Asset; exports.OpenapiUtils = OpenapiUtils; exports.Exception = Exception; exports.SCHEMA_GENERATOR = SCHEMA_GENERATOR; exports.SchemaDeclarationGenerator = SchemaDeclarationGenerator; exports.OPERATION_GENERATOR = OPERATION_GENERATOR; exports.OperationDeclarationGenerator = OperationDeclarationGenerator; exports.DECLARATION_GENERATOR = DECLARATION_GENERATOR; exports.GenerateDeclarationPlugin = GenerateDeclarationPlugin; exports.MICRO_FUNCTION_REQUEST_GENERATOR = MICRO_FUNCTION_REQUEST_GENERATOR; exports.RequestGenerator = RequestGenerator; exports.MICRO_FUNCTION_GENERATOR = MICRO_FUNCTION_GENERATOR; exports.MicroFunctionGenerator = MicroFunctionGenerator; exports.GenerateMicroFunctionPlugin = GenerateMicroFunctionPlugin; exports.BodyFallbackPlugin = BodyFallbackPlugin; exports.USE_VALIBOT = USE_VALIBOT; exports.UseValibotPlugin = UseValibotPlugin; exports.NestjsModuleGenerator = NestjsModuleGenerator; exports.GenerateNestjsModulePlugin = GenerateNestjsModulePlugin; exports.ChineseToPinyinPlugin = ChineseToPinyinPlugin; exports.DownloadHttpFilePlugin = DownloadHttpFilePlugin; exports.DownloadLocalFilePlugin = DownloadLocalFilePlugin; exports.ShakingPlugin = ShakingPlugin; exports.TerminalSelectPlugin = TerminalSelectPlugin; exports.InitializePlugin = InitializePlugin; exports.OverwriteOperationIdPlugin = OverwriteOperationIdPlugin; exports.OverwriteQueryOptionsPlugin = OverwriteQueryOptionsPlugin;
+//# sourceMappingURL=chunk-7HHTHYRA.cjs.map