@keq-request/cli 5.0.0-alpha.22 → 5.0.0-alpha.24

package/dist/index.js

@@ -4,7 +4,7 @@ function defineKeqConfig(config) {
 }
 
 // src/types/runtime-config.ts
-import { Type as Type2 } from "@sinclair/typebox";
+import { Type } from "@sinclair/typebox";
 
 // src/constants/file-naming-style.ts
 var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
@@ -22,64 +22,66 @@ var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
   return FileNamingStyle2;
 })(FileNamingStyle || {});
 
-// src/types/qs.ts
-import { Type } from "@sinclair/typebox";
-
-// 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/types/qs.ts
-var Qs = Type.Object({
-  indices: Type.Optional(Type.Boolean()),
-  arrayFormat: Type.Optional(Type.Enum(QsArrayFormat)),
-  allowDots: Type.Optional(Type.Boolean())
-});
-
 // src/types/runtime-config.ts
-var RuntimeConfig = Type2.Object({
+var RuntimeConfig = Type.Object({
+  mode: Type.Optional(
+    Type.Union([
+      Type.Literal("micro-function"),
+      Type.Literal("nestjs-module"),
+      Type.Literal("none")
+    ], { default: "micro-function" })
+  ),
   /**
    * Whether to generate ES Module code
    *
    * If not specified, the module system will be inferred from the nearest package.json "type" field
    * or defaults to "cjs" if no package.json is found.
    */
-  esm: Type2.Optional(Type2.Boolean({ default: false })),
+  esm: Type.Optional(Type.Boolean({ default: false })),
   /**
    * Output directory for generated files
    */
-  outdir: Type2.String({ default: `${process.cwd()}/api` }),
+  outdir: Type.String({ default: `${process.cwd()}/api` }),
   /**
    * File naming style for generated files
    */
-  fileNamingStyle: Type2.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
-  modules: Type2.Record(Type2.String(), Type2.String()),
-  operationIdFactory: Type2.Optional(Type2.Function([Type2.Any()], Type2.String())),
-  qs: Type2.Optional(Type2.Union([
-    Qs,
-    Type2.Function([Type2.Any()], Qs)
-  ])),
-  debug: Type2.Optional(Type2.Boolean({ default: false })),
+  fileNamingStyle: Type.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
+  modules: Type.Record(Type.String(), Type.String()),
+  debug: Type.Optional(Type.Boolean({ default: false })),
   /**
    * Whether to tolerate wrong openapi/swagger structure
    */
-  tolerant: Type2.Optional(Type2.Boolean({ default: false })),
-  plugins: Type2.Optional(Type2.Array(Type2.Any(), { default: [] }))
+  tolerant: Type.Optional(Type.Boolean({ default: false })),
+  plugins: Type.Optional(Type.Array(Type.Any(), { default: [] }))
 });
 
+// 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/constants/supported-methods.ts
+var SupportedMethods = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+];
+
 // src/compiler/compiler.ts
-import { AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook } from "tapable";
 import { Listr } from "listr2";
+import { AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } from "tapable";
 
-// src/tasks/setup/index.ts
-import * as R3 from "ramda";
+// src/compiler/tasks/setup/index.ts
 import fs3 from "fs-extra";
 import path2 from "path";
 import { Value } from "@sinclair/typebox/value";
@@ -176,7 +178,7 @@ var IgnoreMatcher = class _IgnoreMatcher {
   }
 };
 
-// src/tasks/setup/utils/validate-modules.ts
+// src/compiler/tasks/setup/utils/validate-modules.ts
 import * as R2 from "ramda";
 import validator from "validator";
 function validateModules(modules) {
@@ -205,7 +207,7 @@ function validateModules(modules) {
   }
 }
 
-// src/tasks/setup/utils/find-nearest-package-json.ts
+// src/compiler/tasks/setup/utils/find-nearest-package-json.ts
 import fs2 from "fs";
 import path from "path";
 function findNearestPackageJson(startDir = process.cwd()) {
@@ -223,7 +225,7 @@ function findNearestPackageJson(startDir = process.cwd()) {
   return null;
 }
 
-// src/tasks/setup/utils/get-project-module-system.ts
+// src/compiler/tasks/setup/utils/get-project-module-system.ts
 function getProjectModuleSystem(pkgInfo) {
   if (!pkgInfo?.json) return "cjs";
   const { json } = pkgInfo;
@@ -231,7 +233,7 @@ function getProjectModuleSystem(pkgInfo) {
   return "cjs";
 }
 
-// src/tasks/setup/index.ts
+// src/compiler/tasks/setup/index.ts
 var explore = cosmiconfig("keq");
 function main(compiler, options) {
   return {
@@ -242,7 +244,7 @@ function main(compiler, options) {
       }
       if (!Value.Check(RuntimeConfig, result.config)) {
         const errors = [...Value.Errors(RuntimeConfig, result.config)];
-        const message = errors.map(({ path: path9, message: message2 }) => `${path9}: ${message2}`).join("\n");
+        const message = errors.map(({ path: path13, message: message2 }) => `${path13}: ${message2}`).join("\n");
         throw new Error(`Invalid Config: ${message}`);
       }
       const rc = Value.Default(RuntimeConfig, result.config);
@@ -251,14 +253,13 @@ function main(compiler, options) {
         await fs3.ensureDir(".keq");
         rc.debug = true;
       }
-      if (options?.tolerant) {
-        rc.tolerant = true;
-      }
+      rc.tolerant = Boolean(rc.tolerant);
       const packageJsonInfo = findNearestPackageJson();
       if (packageJsonInfo) {
         const moduleSystem = getProjectModuleSystem(packageJsonInfo);
         rc.esm = moduleSystem === "esm";
       }
+      context.rc = rc;
       let matcher = new IgnoreMatcher([]);
       if (result.filepath) {
         const ignoreFilepath = path2.resolve(path2.dirname(result.filepath), ".keqignore");
@@ -276,28 +277,8 @@ function main(compiler, options) {
           operationPathname: rule.operationPathname
         });
       }
-      if (options?.modules && options.modules.length) {
-        const notExistModules = options.modules.filter((moduleName) => !(moduleName in rc.modules));
-        if (notExistModules.length) {
-          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
-        }
-        const ignoredModules = R3.difference(R3.keys(rc.modules), options.modules);
-        for (const moduleName of ignoredModules) {
-          matcher.append({
-            persist: false,
-            ignore: true,
-            moduleName,
-            operationMethod: "*",
-            operationPathname: "*"
-          });
-        }
-      }
-      context.setup = { rc, matcher };
-      if (rc.plugins && rc.plugins.length) {
-        for (const plugin of rc.plugins) {
-          plugin.apply(compiler);
-        }
-      }
+      context.matcher = matcher;
+      await compiler.hooks.setup.promise(task);
     }
   };
 }
@@ -320,43 +301,126 @@ function createSetupTask(compiler, options) {
   };
 }
 
-// src/tasks/download/index.ts
+// src/compiler/tasks/download/index.ts
 import { PRESET_TIMER } from "listr2";
+import { validate } from "@scalar/openapi-parser";
+
+// src/models/artifact.ts
+import * as path3 from "path";
+
+// 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);
+  }
+  block;
+  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 = class {
+  id;
+  filepath;
+  content;
+  extensionName;
+  anchor = new Anchor(this);
+  constructor(options) {
+    this.id = options.id;
+    this.filepath = options.filepath;
+    this.extensionName = options.extensionName || path3.extname(options.filepath);
+    this.content = options.content;
+  }
+  get dirname() {
+    return path3.dirname(this.filepath);
+  }
+  renderer() {
+    return `${HeaderComment}${this.content}`;
+  }
+};
 
-// src/tasks/utils/module-definition.ts
-var ModuleDefinition = class {
+// src/models/api-document_v3_1.ts
+import * as R5 from "ramda";
+
+// src/models/module-definition.ts
+var ModuleDefinition = class _ModuleDefinition {
   name;
   address;
   constructor(name, address) {
     this.name = name;
     this.address = address;
   }
+  static unknown() {
+    return new _ModuleDefinition("", "");
+  }
 };
 
-// src/tasks/utils/api-document.ts
-import fs5 from "fs-extra";
-import * as path5 from "path";
-import * as yaml from "js-yaml";
-import * as validUrl from "valid-url";
-import { request } from "keq";
-import { upgrade, validate } from "@scalar/openapi-parser";
-
-// src/tasks/utils/api-document_v3_1.ts
-import * as R6 from "ramda";
-
-// src/constants/supported-methods.ts
-var SupportedMethods = [
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "head",
-  "options"
-];
-
-// src/tasks/utils/operation-definition.ts
-import * as R5 from "ramda";
+// src/models/operation-definition.ts
+import * as R4 from "ramda";
 
 // src/utils/is-keywords.ts
 var keywords = [
@@ -428,45 +492,51 @@ function isReservedWord(str) {
   return reservedWords.includes(str);
 }
 
-// src/tasks/utils/operation-definition.ts
+// src/models/operation-definition.ts
 import { JSONPath as JSONPath2 } from "jsonpath-plus";
 
-// src/tasks/utils/schema-definition.ts
-import * as R4 from "ramda";
+// src/models/schema-definition.ts
+import * as R3 from "ramda";
 import { JSONPath } from "jsonpath-plus";
 var SchemaDefinition = class _SchemaDefinition {
-  id;
   name;
   schema;
   module;
   document;
+  get id() {
+    return `${this.module.address}#/components/schemas/${this.name}`;
+  }
   constructor(args) {
     this.module = args.module;
     this.name = args.name;
-    this.id = args.id;
     this.schema = args.schema;
     this.document = args.document;
   }
   getDependencies() {
-    const refs = R4.uniq(JSONPath({
+    const refs = R3.uniq(JSONPath({
       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 new _SchemaDefinition({
-        id: ref,
-        name: "unknown",
-        schema: {},
-        module: this.module,
-        document: this.document
-      });
+      return _SchemaDefinition.unknown();
+    });
+  }
+  static unknown() {
+    return new _SchemaDefinition({
+      name: "",
+      schema: {},
+      module: ModuleDefinition.unknown(),
+      document: ApiDocumentV3_1.unknown()
     });
   }
+  static isUnknown(definition) {
+    return definition.name === "";
+  }
 };
 
-// src/tasks/utils/operation-definition.ts
+// src/models/operation-definition.ts
 var OperationDefinition = class {
   module;
   operationId;
@@ -474,6 +544,9 @@ var OperationDefinition = class {
   pathname;
   operation;
   document;
+  get id() {
+    return `${this.module.address}#/paths/${this.pathname}/${this.method}`;
+  }
   constructor(args) {
     this.module = args.module;
     this.method = args.method.toLowerCase();
@@ -493,7 +566,7 @@ var OperationDefinition = class {
     return `${method}_${pathname}`.replace(/\//g, "_").replace(/-/g, "_").replace(/:/g, "$$").replace(/{(.+)}/, "$$$1");
   }
   getDependencies() {
-    const refs = R5.uniq([
+    const refs = R4.uniq([
       ...JSONPath2({
         path: "$.requestBody.content..schema..$ref",
         json: this.operation
@@ -510,13 +583,7 @@ var OperationDefinition = class {
     const dependencies = refs.filter((ref) => typeof ref === "string" && ref).map((ref) => {
       const schemaDefinition = this.document.dereference(ref);
       if (schemaDefinition) return schemaDefinition;
-      return new SchemaDefinition({
-        id: ref,
-        name: "unknown",
-        schema: {},
-        module: this.module,
-        document: this.document
-      });
+      return SchemaDefinition.unknown();
     });
     return dependencies;
   }
@@ -530,8 +597,7 @@ var logger = {
   error: (str) => console.error(chalk.red(str))
 };
 
-// src/tasks/utils/api-document_v3_1.ts
-import { openapiShakingSync } from "@opendoc/openapi-shaking";
+// src/models/api-document_v3_1.ts
 var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
   module;
   specification;
@@ -542,7 +608,6 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
   get schemas() {
     const module = this.module;
     return Object.entries(this.specification.components?.schemas || {}).map(([name, schema]) => new SchemaDefinition({
-      id: `#/components/schemas/${name}`,
       name,
       schema,
       module,
@@ -560,61 +625,44 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
     })));
   }
   isEmpty() {
-    return R6.isEmpty(this.specification.paths);
+    return R5.isEmpty(this.specification.paths);
   }
   dereference($ref) {
     if ($ref.startsWith("#/")) {
-      return this.schemas.find((schema) => schema.id === $ref);
+      return this.schemas.find((schema) => schema.id.endsWith($ref));
     }
     logger.warn(`The $ref(${$ref}) is not defined in ${this.module.name} openapi/swagger.`);
   }
   isRefDefined($ref) {
     if ($ref.startsWith("#/")) {
-      const path9 = $ref.replace("#/", "").split("/");
-      return R6.path(path9, this.specification) !== void 0;
+      const path13 = $ref.replace("#/", "").split("/");
+      return R5.path(path13, this.specification) !== void 0;
     }
     return false;
   }
-  sharking(filter2) {
-    const isAccepted = (pathname, method, operation) => {
-      if (!SupportedMethods.includes(method)) return false;
-      const operationDefinition = new OperationDefinition({
-        method,
-        pathname,
-        operation,
-        module: this.module,
-        document: this
-      });
-      return filter2(operationDefinition);
-    };
-    const sharkedSwagger = openapiShakingSync(
-      this.specification,
-      isAccepted,
-      { tolerant: true }
-    );
-    return new _ApiDocumentV3_1(
-      sharkedSwagger,
-      new ModuleDefinition(
-        this.module.name,
-        `file://${this.module.name}.v3_1.sharked.json`
-      )
-    );
+  static unknown() {
+    return new _ApiDocumentV3_1({}, ModuleDefinition.unknown());
   }
 };
 
-// src/tasks/utils/api-document.ts
-import { fixSwagger } from "swagger-fix";
-
-// src/utils/debugger.ts
-import fs4 from "fs-extra";
-var Debugger = class {
-  constructor(rc) {
-    this.rc = rc;
+// src/models/asset.ts
+var Asset = class {
+  path;
+  constructor(path13) {
+    this.path = path13;
   }
-  writeOpenapi(fullpath, openapi) {
-    if (this.rc?.debug) {
-      void fs4.writeJSON(fullpath, openapi, { spaces: 2 });
-    }
+};
+
+// src/exception.ts
+import { CustomError } from "ts-custom-error";
+import wrap from "word-wrap";
+var Exception = class extends CustomError {
+  constructor(module, message) {
+    const moduleName = typeof module === "string" ? module : module.name;
+    const msg = wrap(message, { width: 60, indent: "    " });
+    super(`${moduleName} module failed to compile:
+${msg}`);
+    Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
   }
 };
 
@@ -633,28 +681,28 @@ function dereference($ref, swagger) {
 }
 
 // src/utils/openapi-utils/dereference-operation.ts
-import * as R9 from "ramda";
+import * as R8 from "ramda";
 import jsonpointer2 from "jsonpointer";
 import { JSONPath as JSONPath4 } from "jsonpath-plus";
 
 // src/utils/openapi-utils/remove-undefined-ref.ts
-import * as R8 from "ramda";
+import * as R7 from "ramda";
 import jsonpointer from "jsonpointer";
 import { JSONPath as JSONPath3 } from "jsonpath-plus";
 
 // src/utils/openapi-utils/is-ref-defined.ts
-import * as R7 from "ramda";
+import * as R6 from "ramda";
 function isRefDefined($ref, swagger) {
   if ($ref.startsWith("#/")) {
-    const path9 = $ref.replace("#/", "").split("/");
-    return R7.path(path9, swagger) !== void 0;
+    const path13 = $ref.replace("#/", "").split("/");
+    return R6.path(path13, swagger) !== void 0;
   }
   return false;
 }
 
 // src/utils/openapi-utils/remove-undefined-ref.ts
 function removeUndefinedRef(swagger) {
-  const shadow = R8.clone(swagger);
+  const shadow = R7.clone(swagger);
   const matches = JSONPath3({
     path: "$..*['$ref']^",
     json: swagger,
@@ -662,7 +710,7 @@ function removeUndefinedRef(swagger) {
   });
   for (const match of matches) {
     if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) {
-      jsonpointer.set(shadow, match.pointer, R8.omit(["$ref"], match.value));
+      jsonpointer.set(shadow, match.pointer, R7.omit(["$ref"], match.value));
     }
   }
   return shadow;
@@ -676,7 +724,7 @@ function dereferencePathObject(swagger) {
     resultType: "all"
   });
   for (const match of matches) {
-    const value = OpenapiUtils.dereference(match.value.$ref, swagger);
+    const value = dereference(match.value.$ref, swagger);
     jsonpointer2.set(swagger, match.pointer, value);
   }
 }
@@ -687,7 +735,7 @@ function dereferenceRequestBody(swagger) {
     resultType: "all"
   });
   for (const match of matches) {
-    const value = OpenapiUtils.dereference(match.value.$ref, swagger);
+    const value = dereference(match.value.$ref, swagger);
     jsonpointer2.set(swagger, match.pointer, value);
   }
 }
@@ -705,7 +753,7 @@ function dereferenceResponses(swagger) {
     })
   ];
   for (const match of matches) {
-    const value = OpenapiUtils.dereference(match.value.$ref, swagger);
+    const value = dereference(match.value.$ref, swagger);
     jsonpointer2.set(swagger, match.pointer, value);
   }
 }
@@ -716,12 +764,12 @@ function dereferenceParameters(swagger) {
     resultType: "all"
   });
   for (const match of matches) {
-    const value = OpenapiUtils.dereference(match.value.$ref, swagger);
+    const value = dereference(match.value.$ref, swagger);
     jsonpointer2.set(swagger, match.pointer, value);
   }
 }
 function dereferenceOperation(swagger) {
-  const shadow = R9.clone(swagger);
+  const shadow = R8.clone(swagger);
   dereferencePathObject(shadow);
   dereferenceRequestBody(shadow);
   dereferenceResponses(shadow);
@@ -729,25 +777,6 @@ function dereferenceOperation(swagger) {
   return removeUndefinedRef(shadow);
 }
 
-// src/utils/openapi-utils/update-operation-id.ts
-import * as R10 from "ramda";
-function updateOperationId(swagger, fn) {
-  const shadow = R10.clone(swagger);
-  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];
-      const operationId = fn(method, pathname, operation);
-      if (typeof operationId === "string" && operationId.length > 0) {
-        operation.operationId = operationId;
-      }
-    }
-  }
-  return shadow;
-}
-
 // src/utils/json-schema-utils/is-array.ts
 function isArray(schema) {
   return schema.type === "array";
@@ -796,6 +825,38 @@ function dereferenceDeep($ref, swagger) {
   return value;
 }
 
+// src/utils/openapi-utils/to-3_1.ts
+import { upgrade } from "@scalar/openapi-parser";
+function To3_1(openapi) {
+  const { specification } = upgrade(openapi);
+  return specification;
+}
+
+// src/utils/openapi-utils/map-operation.ts
+import * as R9 from "ramda";
+function mapOperation(specification, mapper) {
+  const shadow = R9.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 = class {
   static isRefDefined = isRefDefined;
@@ -803,107 +864,22 @@ var OpenapiUtils = class {
   static dereferenceDeep = dereferenceDeep;
   static removeUndefinedRef = removeUndefinedRef;
   static dereferenceOperation = dereferenceOperation;
-  static updateOperationId = updateOperationId;
+  static mapOperation = mapOperation;
+  static mapParameter = mapParameter;
+  // static updateOperationId = updateOperationId
+  static to3_1 = To3_1;
 };
 
-// src/tasks/utils/api-document.ts
-var ApiDocument = class _ApiDocument {
-  module;
-  specification;
-  constructor(specification, module) {
-    this.module = module;
-    this.specification = specification;
-  }
-  static cache = /* @__PURE__ */ new Map();
-  static async download(url) {
-    let content;
-    try {
-      const res = await request.get(url).resolveWith("response");
-      if (res.status >= 400) throw new Error(`Request failed with status code ${res.status}`);
-      content = await res.text();
-    } catch (e) {
-      if (e instanceof Error) {
-        e.message = `Unable get the openapi/swagger file from ${url}: ${e.message}`;
+// src/compiler/tasks/download/index.ts
+function main2(compiler, options) {
+  return {
+    task: (context, task) => {
+      if (!context.rc || !context.matcher) {
+        throw new Error("Please run setup task first.");
       }
-      throw e;
-    }
-    try {
-      return JSON.parse(content);
-    } catch (e) {
-      throw new Error(`The openapi/swagger file get from url isn't json: ${url}`);
-    }
-  }
-  static async read(filePath) {
-    const fileExt = path5.extname(filePath);
-    const content = await fs5.readFile(filePath, "utf8");
-    if ([".yml", ".yaml"].includes(fileExt)) {
-      return yaml.load(content);
-    } else if (fileExt === ".json") {
-      return JSON.parse(content);
-    }
-    throw new Error(`File ${fileExt} not support.`);
-  }
-  static async create(moduleDefinition) {
-    const { address } = moduleDefinition;
-    if (this.cache.has(moduleDefinition.address)) {
-      return this.cache.get(moduleDefinition.address);
-    }
-    const openapi = validUrl.isUri(address) ? await this.download(address) : await this.read(address);
-    return new _ApiDocument(openapi, moduleDefinition);
-  }
-  async validate() {
-    return await validate(this.specification);
-  }
-  // remove chinese and special symbols
-  fix() {
-    const openapi = fixSwagger(this.specification);
-    return new _ApiDocument(
-      openapi,
-      new ModuleDefinition(
-        this.module.name,
-        `file://${this.module.name}.fixed.json`
-      )
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async toV3_1(rc) {
-    const debug = new Debugger(rc);
-    let spec = this.specification;
-    const { specification } = upgrade(spec);
-    spec = specification;
-    debug.writeOpenapi(`.keq/${this.module.name}.3_1.json`, spec);
-    spec = OpenapiUtils.dereferenceOperation(spec);
-    debug.writeOpenapi(`.keq/${this.module.name}.3_1.sharked.json`, spec);
-    if (rc?.operationIdFactory) {
-      const operationIdFactory = rc.operationIdFactory;
-      spec = OpenapiUtils.updateOperationId(
-        spec,
-        (method, pathname, operation) => operationIdFactory({ method, pathname, operation, module: this.module })
-      );
-      debug.writeOpenapi(`.keq/${this.module.name}.3_1.formatted.json`, spec);
-    }
-    return new ApiDocumentV3_1(
-      spec,
-      new ModuleDefinition(
-        this.module.name,
-        `file://${this.module.name}.v3_1.json`
-      )
-    );
-  }
-};
-
-// src/tasks/download/index.ts
-function main2(compiler, options) {
-  return {
-    task: (context, task) => {
-      if (!context.setup) {
-        throw new Error("Please run setup task first.");
-      }
-      const rc = context.setup.rc;
-      const matcher = context.setup.matcher;
-      context.downloaded = {
-        documents: []
-      };
+      const rc = context.rc;
+      const matcher = context.matcher;
+      context.documents = [];
       return task.newListr(
         Object.entries(rc.modules).map(([moduleName, address]) => new ModuleDefinition(moduleName, address)).map((moduleDefinition) => ({
           title: moduleDefinition.name,
@@ -913,8 +889,23 @@ function main2(compiler, options) {
               return;
             }
             task2.output = `Downloaded from ${moduleDefinition.address}`;
-            const document = await ApiDocument.create(moduleDefinition);
-            ctx.downloaded.documents.push(document);
+            const content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task2);
+            if (!content) {
+              throw new Exception(moduleDefinition, `Cannot download document from ${moduleDefinition.address}`);
+            }
+            const spec = JSON.parse(content);
+            const { valid, errors } = await validate(spec);
+            if (!valid) {
+              const message = `${moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: 
+${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
+              task2.output = message;
+            }
+            OpenapiUtils.dereferenceOperation(spec);
+            const document = new ApiDocumentV3_1(
+              spec,
+              moduleDefinition
+            );
+            ctx.documents?.push(document);
           }
         })),
         {
@@ -951,151 +942,31 @@ function createDownloadTask(compiler, options) {
   };
 }
 
-// src/tasks/validate/index.ts
-function main3() {
-  return {
-    task: (context, task) => {
-      if (!context.setup) throw new Error("Please run setup task first.");
-      if (!context.downloaded) throw new Error("Please run download task first.");
-      const rc = context.setup.rc;
-      const downloadedDocuments = context.downloaded.documents;
-      const debug = new Debugger(rc);
-      context.validated = {
-        documents: []
-      };
-      return task.newListr(
-        downloadedDocuments.map((document) => ({
-          title: document.module.name,
-          task: async (ctx, task2) => {
-            const { valid, errors } = await document.validate();
-            if (!valid) {
-              const message = `${document.module.name} module openapi/swagger file does not conform to the openapi@3.1 standard specifications or have grammatical errors, which may cause unexpected errors: 
-${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
-              task2.output = message;
-            }
-            const fixedDocument = document.fix();
-            debug.writeOpenapi(`.keq/${document.module.name}.fixed.json`, fixedDocument.specification);
-            const v3_1Document = await fixedDocument.toV3_1(rc);
-            ctx.validated.documents.push(v3_1Document);
-          }
-        })),
-        {
-          concurrent: true,
-          rendererOptions: {
-            collapseSubtasks: false,
-            persistentOutput: true
-          }
-        }
-      );
-    }
-  };
-}
-function createValidateTask(compiler, options) {
-  return {
-    title: "Validate",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main3(),
-        {
-          task: (context2, task2) => compiler.hooks.afterValidate.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/tasks/shaking/index.ts
-function main4(compiler, options) {
-  return {
-    task: (context, task) => {
-      if (!context.setup) throw new Error("Please run setup task first.");
-      if (!context.validated) throw new Error("Please run validate task first.");
-      const matcher = context.setup.matcher;
-      const documents = context.validated.documents;
-      context.shaken = {
-        documents: []
-      };
-      return task.newListr(
-        documents.map((document) => ({
-          title: document.module.name,
-          task: (ctx, task2) => {
-            if (options?.skipIgnoredModules && matcher.isModuleIgnored(document.module)) {
-              task2.skip(`${document.module.name} module is ignored`);
-              return;
-            }
-            const shakenDocument = document.sharking(
-              (operationDefinition) => !matcher.isOperationIgnored(operationDefinition)
-            );
-            if (options?.skipEmptyDocuments && shakenDocument.isEmpty()) {
-              task2.skip(`${document.module.name} module is empty`);
-              return;
-            }
-            ctx.shaken.documents.push(shakenDocument);
-          }
-        })),
-        {
-          concurrent: true,
-          rendererOptions: {
-            collapseSubtasks: false,
-            suffixSkips: true
-          }
-        }
-      );
-    }
-  };
-}
-function createShakingTask(compiler, options) {
-  return {
-    title: "Shaking",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main4(compiler, options),
-        {
-          task: (context2, task2) => compiler.hooks.afterShaking.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/tasks/persist/index.ts
+// src/compiler/tasks/persist/index.ts
 import * as path6 from "path";
-import fs6 from "fs-extra";
+import fs4 from "fs-extra";
 function createPersistArtifactTask() {
   return {
     title: "Write files",
     task: async (context, task) => {
-      if (!context.setup) throw new Error("Please run setup task first.");
-      if (!context.compiled) {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.artifacts || context.artifacts.length === 0) {
         task.skip("No compiled artifacts to persist.");
         return;
       }
-      const rc = context.setup.rc;
-      const artifacts = context.compiled.artifacts;
-      for (const artifact of artifacts) {
-        artifact.changeFileNameCase(rc.fileNamingStyle);
-      }
+      const rc = context.rc;
+      const artifacts = context.artifacts;
       const total = artifacts.length;
       let completed = 0;
       const files = await Promise.all(artifacts.map(async (artifact) => {
         const realpath = `./${path6.join(rc.outdir, artifact.filepath)}`;
-        await fs6.ensureFile(realpath);
-        await fs6.writeFile(realpath, artifact.toCode({ esm: !!rc.esm }));
+        await fs4.ensureFile(realpath);
+        await fs4.writeFile(realpath, artifact.renderer());
         completed += 1;
         task.output = `Persisted ${completed}/${total} files`;
-        return { path: path6.resolve(realpath) };
+        return new Asset(path6.resolve(realpath));
       }));
-      context.persisted = { files };
+      context.assets = files;
     }
   };
 }
@@ -1103,13 +974,13 @@ function createPersistIgnoreTask() {
   return {
     title: "Update .keqignore",
     task: async (context, task) => {
-      if (!context.setup) throw new Error("Please run setup task first.");
-      const matcher = context.setup.matcher;
+      if (!context.matcher) throw new Error("Please run setup task first.");
+      const matcher = context.matcher;
       await matcher.write(".keqignore");
     }
   };
 }
-function main5() {
+function main3() {
   return {
     task: (context, task) => task.newListr(
       [
@@ -1132,7 +1003,7 @@ function createPersistTask(compiler, options) {
     skip: options?.skip,
     task: (context, task) => task.newListr(
       [
-        main5(),
+        main3(),
         {
           task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
         }
@@ -1144,965 +1015,1616 @@ function createPersistTask(compiler, options) {
   };
 }
 
-// src/tasks/compile/utils/compile-schema-definition.ts
-import * as R14 from "ramda";
-
-// src/renderer/json-schema/index.ts
-import * as R12 from "ramda";
-
-// src/renderer/utils/generate-schema.ts
-import * as R11 from "ramda";
-function generateComment(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/compiler/tasks/compile/index.ts
+function main4(compiler) {
+  return {
+    task: async (context, task) => {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.documents) throw new Error("Please run shaking task first.");
+      context.artifacts = [];
+      await compiler.hooks.compile.promise(task);
+    }
+  };
+}
+function createCompileTask(compiler, options) {
+  return {
+    title: "Compile",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        {
+          task: (context2, task2) => compiler.hooks.beforeCompile.promise(task2)
+        },
+        main4(compiler),
+        {
+          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
 }
-function generateSchema(schema, alias = R11.identity) {
-  if (typeof schema === "boolean") return "unknown";
-  if (JsonSchemaUtils.isRef(schema)) return generateReference(schema, alias);
-  if (JsonSchemaUtils.isMixed(schema)) return generateMixed(schema, alias);
-  if (JsonSchemaUtils.isArray(schema)) return generateArray(schema, alias);
-  if (schema.type === "object") return generateObject(schema, alias);
-  if (schema.enum) return generateEnum(schema, alias);
-  if (schema.oneOf) return generateOneOf(schema, alias);
-  if (schema.anyOf) return generateAnyOf(schema, alias);
-  if (schema.allOf) return generateAllOf(schema, alias);
-  if (schema.type === "string") return generateString(schema, alias);
-  if (schema.type === "number") return generateNumber(schema, alias);
-  if (schema.type === "boolean") return generateBoolean(schema, alias);
-  if (schema.type === "null") return generateNull(schema, alias);
-  if (schema.type === "integer") return generateInteger(schema, alias);
-  return "unknown";
+
+// src/compiler/intercepter/print-information.ts
+function proxyTaskWrapper(pluginName, task) {
+  return new Proxy(task, {
+    set(target, prop2, value) {
+      if (prop2 !== "output") {
+        return Reflect.set(target, prop2, value);
+      }
+      target.output = `[Plugin: ${pluginName}] ${value}`;
+      return true;
+    }
+  });
 }
-function generateMixed(schema, alias) {
-  if (Array.isArray(schema.type)) {
-    schema.type.map((type) => ({ ...schema, type })).map((schema2) => generateSchema(schema2, alias)).join(" | ");
-  }
-  return "unknown";
+function printInformation(taskIndex) {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      if (tap.type === "promise") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      return tap;
+    }
+  };
 }
-function generateReference(schema, alias) {
-  if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
-  const parts = schema.$ref.split("/");
-  return alias(parts[parts.length - 1]) || "unknown";
+
+// src/compiler/intercepter/perfect-error-message.ts
+import * as R10 from "ramda";
+function perfectErrorMessage() {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      function prefix(err) {
+        if (err instanceof Error) {
+          err.message = `[Plugin: ${tap.name}] ${err.message}`;
+        }
+      }
+      if (tap.type === "promise") {
+        tap.fn = async (...args) => {
+          try {
+            return await fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
+      }
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          try {
+            return fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
+      }
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const callback = R10.last(args);
+          return fn(...R10.init(args), (err, result) => {
+            prefix(err);
+            return callback(err, result);
+          });
+        };
+      }
+      return tap;
+    }
+  };
 }
-function generateArray(schema, alias) {
-  if (schema.items && Array.isArray(schema.items)) {
-    const items = schema.items.map((s) => generateSchema(s, alias)).join(", ");
-    return `[${items}]`;
+
+// src/plugins/eslint/index.ts
+import { ESLint } from "eslint";
+
+// src/plugins/prettier/prettier.plugin.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+
+// src/plugins/body-fallback/index.ts
+import * as R22 from "ramda";
+
+// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
+import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook2 } from "tapable";
+
+// src/plugins/generate-micro-function/constants/metadata-storage.ts
+var MetadataStorage = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
+import * as R21 from "ramda";
+import * as path10 from "path";
+import * as changeCase6 from "change-case";
+
+// src/plugins/generate-declaration/generate-declaration.plugin.ts
+import { AsyncSeriesWaterfallHook } from "tapable";
+
+// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
+import * as path9 from "path";
+import * as changeCase5 from "change-case";
+
+// src/transformers/json-schema/comment.renderer.ts
+var CommentRenderer = class {
+  constructor(schema) {
+    this.schema = schema;
   }
-  if (schema.items && typeof schema.items === "object") {
-    return `${generateSchema(schema.items, alias)}[]`;
+  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");
   }
-  return "any[]";
-}
+};
+
+// src/transformers/json-schema/declaration.renderer.ts
+import * as R12 from "ramda";
+
+// src/utils/indent.ts
 function indent(space, text) {
   if (text === "") return "";
   const indentation = " ".repeat(space);
-  return text.split("\n").map((line) => `${indentation}${line}`).join("\n");
+  return text.split("\n").map((line) => line ? `${indentation}${line}` : line).join("\n");
 }
-function generateObject(schema, alias) {
-  if ((!schema.properties || R11.isEmpty(schema.properties)) && (!schema.additionalProperties || R11.isEmpty(schema.additionalProperties))) {
-    return "object";
+
+// src/transformers/json-schema/reference.transformer.ts
+import * as R11 from "ramda";
+var ReferenceTransformer = class {
+  static toDeclaration(schema, alias2 = R11.identity) {
+    if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
+    const parts = schema.$ref.split("/");
+    return alias2(parts[parts.length - 1]) || "unknown";
   }
-  const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
-    let $comment = generateComment(propertySchema);
-    if ($comment) $comment += "\n";
-    const $key = `"${propertyName}"${schema.required?.includes(propertyName) ? "" : "?"}`;
-    const $value = generateSchema(propertySchema, alias);
-    return indent(2, `${$comment}${$key}: ${$value}`);
-  });
-  if (schema.additionalProperties) {
-    const $value = schema.additionalProperties === true ? "any" : generateSchema(schema.additionalProperties, alias);
-    $properties.push(indent(2, `[key: string]: ${$value}`));
-  }
-  return [
-    "{",
-    ...$properties,
-    "}"
-  ].join("\n");
-}
-function generateOneOf(schema, alias) {
-  if (!schema.oneOf) return "unknown";
-  return schema.oneOf.map((s) => generateSchema(s, alias)).join(" | ");
-}
-function generateAnyOf(schema, alias) {
-  if (!schema.anyOf) return "unknown";
-  return schema.anyOf.map((s) => generateSchema(s, alias)).join(" | ");
-}
-function generateAllOf(schema, alias) {
-  if (!schema.allOf) return "unknown";
-  return schema.allOf.map((s) => generateSchema(s, alias)).join(" & ");
-}
-function generateEnum(schema, alias) {
-  if (!schema.enum) return "unknown";
-  return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
-}
-function generateString(schema, alias) {
-  if (schema.contentMediaType === "application/octet-stream") return "Blob | Buffer";
-  if (schema.format === "binary") return "Blob | Buffer";
-  return "string";
-}
-function generateNumber(schema, alias) {
-  return "number";
-}
-function generateBoolean(schema, alias) {
-  return "boolean";
-}
-function generateNull(schema, alias) {
-  return "null";
-}
-function generateInteger(schema, alias) {
-  return "number";
-}
+};
+
+// 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 || R12.isEmpty(schema.properties)) && (!schema.additionalProperties || R12.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}"${schema.required?.includes(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/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();
+  }
+};
 
-// src/renderer/json-schema/index.ts
-async function jsonSchemaRenderer(schemaDefinition) {
-  let $comment = generateComment(schemaDefinition.schema);
-  if ($comment) $comment += "\n";
-  if (typeof schemaDefinition.schema === "boolean") {
+// src/transformers/schema-definition/schema-definition.transformer.ts
+import * as R13 from "ramda";
+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(R13.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(R13.isNotNil).join("\n");
+    }
     return [
       "/* @anchor:file:start */",
       "",
+      $dependencies,
       $comment || void 0,
-      `type ${schemaDefinition.name} = unknown`,
+      `export type ${schemaDefinition.name} = ${JsonSchemaTransformer.toDeclaration(schemaDefinition.schema)}`,
       "",
       "/* @anchor:file:end */"
-    ].filter(R12.isNotNil).join("\n");
+    ].filter(R13.isNotNil).join("\n");
   }
-  if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
-    const $schema = generateSchema(schemaDefinition.schema);
-    const $declaration = $schema.startsWith("{") ? `export interface ${schemaDefinition.name} ${$schema}` : `export type ${schemaDefinition.name} = ${$schema}`;
+};
+
+// src/transformers/operation-definition/comment.renderer.ts
+import * as R14 from "ramda";
+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(` * ${R14.trim(operation.summary)}`);
+      lines.push(" *");
+    }
+    if (operation.description && typeof operation.description === "string") {
+      lines.push(` * @description ${R14.trim(operation.description)}`);
+    }
+    lines.push(" */");
+    return lines.join("\n");
+  }
+};
+
+// src/transformers/operation-definition/declaration.renderer.ts
+import * as R15 from "ramda";
+
+// src/transformers/operation-definition/utils/type-name-factory.ts
+import * as changeCase from "change-case";
+function typeNameFactory(operationDefinition) {
+  const pascalCaseOperationId = changeCase.pascalCase(operationDefinition.operationId);
+  return (name) => `${pascalCaseOperationId}${name}`;
+}
+
+// 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);
+  }
+  typeName;
+  renderResponseBodies(operation, options) {
+    if (!operation.responses || R15.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")}`,
+      operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "query") || [],
+      jsonSchemaDeclarationRendererOptions
+    );
+    const $routeParameters = this.rendererParameters(
+      `${this.typeName("RouteParameters")}`,
+      operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "path") || [],
+      jsonSchemaDeclarationRendererOptions
+    );
+    const $requestHeaders = this.rendererParameters(
+      `${this.typeName("RequestHeaders")}`,
+      operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "header") || [],
+      jsonSchemaDeclarationRendererOptions
+    );
     return [
       "/* @anchor:file:start */",
       "",
-      $comment || void 0,
-      $declaration,
+      $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(R12.isNotNil).join("\n");
-  }
-  return [
-    "/* @anchor:file:start */",
-    "",
-    $comment || void 0,
-    `export type ${schemaDefinition.name} = ${generateSchema(schemaDefinition.schema)}`,
-    "",
-    "/* @anchor:file:end */"
-  ].filter(R12.isNotNil).join("\n");
-}
+    ].filter(R15.isNotNil).join("\n");
+  }
+};
 
-// src/tasks/utils/anchor.ts
-var AnchorBlock = class {
-  constructor(artifact) {
-    this.artifact = artifact;
+// src/transformers/operation-definition/micro-function.renderer.ts
+import * as R17 from "ramda";
+
+// src/transformers/operation-definition/typescript-snippet.ts
+import * as R16 from "ramda";
+var OperationDefinitionSnippet = class {
+  constructor(operationDefinition, options) {
+    this.operationDefinition = operationDefinition;
+    this.options = options;
+    this.typeName = typeNameFactory(operationDefinition);
   }
-  /**
-   * 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}".`);
+  typeName;
+  getQsParameters(parameter) {
+    let arrayFormat;
+    let allowDots;
+    let indices;
+    const style = parameter.style || "form";
+    const explode = parameter.explode ?? true;
+    if ("x-qs-array-format" in parameter) {
+      arrayFormat = parameter["x-qs-array-format"];
+    } else {
+      if (style === "deepObject") {
+        arrayFormat = "brackets" /* 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 */;
+        }
+      }
     }
-    lines.splice(anchorIndex, 0, content);
-    this.artifact.content = lines.join("\n");
+    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 || R16.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 = operation.requestBody?.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 "";
   }
-  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}".`);
+  // 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);
     }
-    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}".`);
+  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}`);
     }
-    lines.splice(startIndex + 1, endIndex - startIndex - 1, content);
-    this.artifact.content = lines.join("\n");
+  }
+  renderRequestBody() {
+    const { operation } = this.operationDefinition;
+    const requestBodyContent = operation.requestBody?.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(R16.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");
   }
 };
-var Anchor = class {
-  constructor(artifact) {
-    this.artifact = artifact;
-    this.block = new AnchorBlock(artifact);
+
+// 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);
+  }
+  helper;
+  typeName;
+  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 || 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(R17.isNotNil).join("\n");
   }
-  block;
-  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}".`);
+  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>>`;
     }
-    lines.splice(anchorIndex + 1, 0, content);
-    this.artifact.content = lines.join("\n");
+    throw new Exception(this.operationDefinition.module, "[operationDeclarationRenderer] Unreachable");
   }
-  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}".`);
+};
+
+// src/transformers/operation-definition/nestjs-method.renderer.ts
+import * as R18 from "ramda";
+var OperationDefinitionNestjsMethodRenderer = class {
+  constructor(operationDefinition, options) {
+    this.operationDefinition = operationDefinition;
+    this.options = options;
+    this.typeName = typeNameFactory(operationDefinition);
+    this.helper = new OperationDefinitionSnippet(operationDefinition, options);
+  }
+  helper;
+  typeName;
+  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(R18.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>>`;
     }
-    lines.splice(anchorIndex, 0, content);
-    this.artifact.content = lines.join("\n");
+    throw new Exception(operationDefinition.module, "[operationDeclarationRenderer] Unreachable");
   }
 };
 
-// src/tasks/utils/artifact.ts
-import * as path8 from "path";
-import * as changeCase from "change-case";
+// 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/tasks/utils/dependency.ts
+// src/transformers/entrypoint/entrypoint.transformer.ts
 import * as path7 from "path";
+var EntrypointTransformer = class {
+  static toTypescript(exports, options) {
+    const $exports = exports.map((exportArtifact) => {
+      const relativePath = path7.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/tasks/utils/to-comment.ts
-function toComment(msg) {
-  if (!msg) return "";
-  return msg.split("\n").map((str) => `// ${str}`).join("\n");
-}
-
-// src/tasks/utils/dependency.ts
-var DependencyIdentifier = class {
-  constructor(name, alias, type = false) {
-    this.name = name;
-    this.alias = alias;
-    this.type = type;
+// src/transformers/api-document/nestjs-client.renderer.ts
+import * as R19 from "ramda";
+import * as changeCase2 from "change-case";
+var NestjsClientRenderer = class {
+  constructor(document, options) {
+    this.document = document;
+    this.options = options;
   }
-  toCode() {
-    const $type = this.type ? "type " : "";
-    if (this.alias) {
-      return `${$type}${this.name} as ${this.alias}`;
-    }
-    return `${$type}${this.name}`;
+  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");
   }
-};
-var Dependency = class {
-  source;
-  identifiers;
-  export;
-  belongTo;
-  constructor(source, identifiers, belongTo, options) {
-    this.source = source;
-    this.identifiers = identifiers.map((i) => typeof i === "string" ? new DependencyIdentifier(i) : i);
-    if (options?.type) {
-      for (const identifier of this.identifiers) {
-        identifier.type = true;
-      }
-    }
-    this.export = !!options?.export;
-    this.belongTo = belongTo;
+  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(R19.isNotNil).join("\n");
   }
-  get realSource() {
-    if (typeof this.source === "string") {
-      if (this.source.startsWith(".")) return path7.relative(this.belongTo.filepath, this.source);
-      return this.source;
-    }
-    return this.source.relativeTo(this.belongTo.dirname);
+};
+
+// src/transformers/api-document/nestjs-module.renderer.ts
+import * as changeCase3 from "change-case";
+var NestjsModuleRenderer = class {
+  constructor(document, options) {
+    this.document = document;
+    this.options = options;
   }
-  toCode(options) {
-    const { esm } = options;
-    try {
-      let fullpath = this.realSource;
-      if (fullpath.startsWith(".") && fullpath.endsWith(".ts")) {
-        if (esm) {
-          fullpath = fullpath.replace(/\.ts$/, ".js");
-        } else {
-          fullpath = fullpath.replace(/\.ts$/, "");
-        }
-      }
-      if (this.identifiers.length > 0) {
-        const $identifiers = this.identifiers.map((i) => i.toCode()).join(", ");
-        return `${this.export ? "export" : "import"} { ${$identifiers} } from '${fullpath}'`;
-      }
-      if (this.export) {
-        return `export * from '${fullpath}'`;
-      }
-      return `import '${fullpath}'`;
-    } catch (err) {
-      return toComment(String(err));
-    }
+  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/tasks/utils/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 = class {
-  id;
-  filepath;
-  dependencies = [];
-  warns = [];
-  content;
-  extensionName;
-  anchor = new Anchor(this);
-  constructor(options) {
-    this.id = options.id;
-    this.filepath = options.filepath;
-    this.extensionName = options.extensionName || path8.extname(options.filepath);
-    this.content = options.content;
-    if (options.dependencies) this.dependencies = options.dependencies;
+// src/transformers/api-document/api-document.transformer.ts
+var ApiDocumentTransformer = class {
+  static toNestjsModule(document, options) {
+    return new NestjsModuleRenderer(document, options).render();
   }
-  get dirname() {
-    return path8.dirname(this.filepath);
+  static toNestjsClient(document, options) {
+    return new NestjsClientRenderer(document, options).render();
   }
-  changeFileNameCase(style) {
-    this.filepath = this.filepath.split("/").map((part, index, arr) => {
-      if (part === "." || part === "..") return part;
-      if (index !== arr.length - 1) {
-        return `${changeCase[style](part)}`;
-      }
-      const baesname = path8.basename(part, this.extensionName);
-      return `${changeCase[style](baesname)}${this.extensionName}`;
-    }).join("/");
-    return this;
-  }
-  relativeTo(filepath) {
-    const relativePath = path8.relative(filepath, this.filepath);
-    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-  }
-  addDependence(source, identifiers, options) {
-    const dependence = new Dependency(
-      source,
-      identifiers,
-      this,
-      options
+};
+
+// src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
+import * as R20 from "ramda";
+import * as path8 from "path";
+import * as changeCase4 from "change-case";
+
+// src/plugins/generate-declaration/constants/metadata-storage.ts
+var MetadataStorage2 = /* @__PURE__ */ new WeakMap();
+
+// 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 = MetadataStorage2.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
+          )
+        ])
+      )
     );
-    this.dependencies.push(dependence);
-    return dependence;
+    const entrypoints = R20.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 = path8.dirname(filepath);
+    const artifact = new Artifact({
+      id: _SchemaDeclarationGenerator.getSchemaDefinitionArtifactId(schemaDefinition),
+      filepath,
+      content: SchemaDefinitionTransformer.toDeclaration(
+        schemaDefinition,
+        {
+          esm: rc.esm,
+          getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
+            const relativePath = path8.relative(
+              dirpath,
+              _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
+            );
+            return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+          }
+        }
+      ),
+      extensionName: ".schema.ts"
+    });
+    return artifact;
   }
-  addWarn(message) {
-    this.warns.push(message);
+  generateEntrypointArtifact(moduleDefinition, exports, rc) {
+    const filepath = _SchemaDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
+    const dirpath = path8.dirname(filepath);
+    const artifact = new Artifact({
+      id: _SchemaDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
+      filepath,
+      content: EntrypointTransformer.toTypescript(exports, { dirpath })
+    });
+    return artifact;
   }
-  toCode(options) {
-    let $dependencies = this.dependencies.map((dependency) => dependency.toCode(options)).filter((line) => line.trim() !== "").join("\n");
-    if ($dependencies) {
-      $dependencies += "\n\n";
-    }
-    let $warns = "";
-    if (this.warns.length) {
-      $warns = toComment([
-        "!!! Here is some Problems !!!",
-        "",
-        this.warns
-      ].join("\n"));
-      $warns += "\n\n";
-    }
-    return `${HeaderComment}${$warns}${$dependencies}${this.content}`;
+  static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
+    return [
+      ".",
+      changeCase4[fileNamingStyle](moduleDefinition.name),
+      "types",
+      "components",
+      "schemas",
+      "index.ts"
+    ].join("/");
+  }
+  static getEntrypointArtifactId(moduleDefinition) {
+    return `${moduleDefinition.address}/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/tasks/utils/json-schema.ts
-import * as R13 from "ramda";
-import { JSONPath as JSONPath5 } from "jsonpath-plus";
-
-// src/tasks/compile/utils/compile-schema-definition.ts
-function genSchemaDefinitionFilepath(schemaDefinition) {
-  const filename = `${schemaDefinition.name}.schema.ts`;
-  return [
-    ".",
-    schemaDefinition.module.name,
-    "components",
-    "schemas",
-    filename
-  ].join("/");
-}
-function genEntrypointFilepath(moduleName) {
-  return [
-    ".",
-    moduleName,
-    "components",
-    "schemas",
-    "index.ts"
-  ].join("/");
-}
-var isArtifactCompiledBy = function(schemaDefinition) {
-  return (artifact) => artifact.id === genSchemaDefinitionFilepath(schemaDefinition);
-};
-async function compileSchemaDefinition(options) {
-  const { task, compiler, schemaDefinitions } = options;
-  const artifacts = await Promise.all(
-    schemaDefinitions.map(async (schemaDefinition) => {
-      const content = await jsonSchemaRenderer(schemaDefinition);
-      const filepath = genSchemaDefinitionFilepath(schemaDefinition);
-      const artifact = new Artifact({
-        id: filepath,
-        filepath,
-        content,
-        extensionName: ".schema.ts"
-      });
-      return await compiler.hooks.afterCompileSchema.promise(artifact, schemaDefinition, task);
-    })
-  );
-  for (const schemaDefinition of schemaDefinitions) {
-    const artifact = artifacts.find(isArtifactCompiledBy(schemaDefinition));
-    if (!artifact) continue;
-    const dependentSchemaDefinitions = schemaDefinition.getDependencies();
-    for (const dependentSchemaDefinition of dependentSchemaDefinitions) {
-      const dependentArtifact = artifacts.find(isArtifactCompiledBy(dependentSchemaDefinition));
-      if (!dependentArtifact) {
-        artifact.addWarn(`Cannot find dependent $ref: ${dependentSchemaDefinition.id}`);
-        continue;
-      }
-      artifact.addDependence(dependentArtifact, [dependentSchemaDefinition.name]);
-    }
+// 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 = MetadataStorage2.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());
   }
-  const schemaDefinitionsGroupByModuleName = R14.groupBy(
-    (schemaDefinition) => schemaDefinition.module.name,
-    schemaDefinitions
-  );
-  const entrypointArtifacts = Object.entries(schemaDefinitionsGroupByModuleName).map(([moduleName, schemaDefinitions2]) => {
-    const filepath = genEntrypointFilepath(moduleName);
+  generateOperationDefinitionArtifact(operationDefinition, rc) {
+    const filepath = _OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
+    const dirpath = path9.dirname(filepath);
     const artifact = new Artifact({
-      id: filepath,
+      id: _OperationDeclarationGenerator.getOperationDefinitionArtifactId(operationDefinition),
       filepath,
-      content: [
-        "/* @anchor:file:start */",
-        "/* @anchor:file:end */"
-      ].join("\n")
+      content: OperationDefinitionTransformer.toDeclaration(
+        operationDefinition,
+        {
+          esm: rc.esm,
+          getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
+            const relativePath = path9.relative(
+              dirpath,
+              SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
+            );
+            return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+          }
+        }
+      ),
+      extensionName: ".type.ts"
     });
-    for (const schemaDefinition of schemaDefinitions2 || []) {
-      const dependentArtifact = artifacts.find(isArtifactCompiledBy(schemaDefinition));
-      if (!dependentArtifact) {
-        artifact.addWarn(`Cannot find dependent $ref: ${schemaDefinition.id}`);
-        continue;
-      }
-      artifact.addDependence(dependentArtifact, [], { export: true });
-    }
     return artifact;
-  });
-  return [...artifacts, ...entrypointArtifacts];
-}
-
-// src/tasks/compile/utils/compile-operation-definition.ts
-import * as R18 from "ramda";
+  }
+  generateEntrypointArtifact(moduleDefinition, exports, rc) {
+    const filepath = _OperationDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
+    const dirpath = path9.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}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
+  }
+};
 
-// src/renderer/operation-type/index.ts
-import * as R15 from "ramda";
-import * as changeCase2 from "change-case";
-function typeNameFactory(operationDefinition) {
-  const pascalCaseOperationId = changeCase2.pascalCase(operationDefinition.operationId);
-  return (name) => `${pascalCaseOperationId}${name}`;
-}
-function responseBodies(operation, alias = R15.identity, typeName) {
-  if (!operation.responses || R15.isEmpty(operation.responses)) {
-    return `export interface ${typeName("ResponseBodies")} {}`;
-  }
-  const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
-    if (!JsonSchemaUtils.isRef(response)) {
-      const $value = Object.values(response.content || {}).map((mediaTypeObject) => mediaTypeObject.schema).filter((schema) => !!schema).map((schema) => generateSchema(schema, alias)).join(" | ");
-      return indent(2, `${statusCode}: ${$value || "void"}`);
+// src/plugins/generate-declaration/generate-declaration.plugin.ts
+var DECLARATION_GENERATOR = "declarationGenerator";
+var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
+  name = DECLARATION_GENERATOR;
+  operationGenerator = new OperationDeclarationGenerator();
+  schemaGenerator = new SchemaDeclarationGenerator();
+  constructor() {
+  }
+  apply(compiler) {
+    _GenerateDeclarationPlugin.register(compiler);
+    compiler.hooks.compile.tapPromise(_GenerateDeclarationPlugin.name, async (task) => {
+      compiler.context.artifacts?.push(
+        ...await this.schemaGenerator.compile(compiler, task),
+        ...await this.operationGenerator.compile(compiler, task)
+      );
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage2.has(compiler)) {
+      MetadataStorage2.set(compiler, {
+        hooks: {
+          afterEntrypointArtifactGenerated: new AsyncSeriesWaterfallHook(["artifact", "task"]),
+          afterSchemaDeclarationArtifactGenerated: new AsyncSeriesWaterfallHook(["artifact", "schemaDefinition", "task"]),
+          afterOperationDeclarationArtifactGenerated: new AsyncSeriesWaterfallHook(["artifact", "operationDefinition", "task"])
+        }
+      });
     }
-  }).join("\n");
-  return [
-    `export interface ${typeName("ResponseBodies")} {`,
-    $responses,
-    "}"
-  ].join("\n");
-}
-function requestBodies(operation, alias = R15.identity, typeName) {
-  let $requestBodies = `export interface ${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)}: ${generateSchema(schema, alias)}`;
-    }).map((pair) => indent(2, pair));
-    $requestBodies = [
-      `export interface ${typeName("RequestBodies")} {`,
-      ...$mediaTypes,
-      "}"
-    ].join("\n");
+    return MetadataStorage2.get(compiler);
   }
-  return $requestBodies;
-}
-function parameterBodies(operationDefinition, alias = R15.identity, typeName) {
-  const { operation } = operationDefinition;
-  let parameterBodies2 = "";
-  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)}: ${generateSchema(schemaOrRef, alias)} & { [key: string]: any }`;
-      }
-      return `${JSON.stringify(mediaType)}: { [key: string]: any }`;
-    }).map((pair) => indent(2, pair));
-    parameterBodies2 = [
-      `interface ${typeName("ParameterBodies")} {`,
-      ...$mediaTypes,
-      "}",
-      ""
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// 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
+    });
   }
-  return parameterBodies2;
-}
-function requestParameters(operation, alias = R15.identity, typeName) {
-  const mediaTypes = operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody) ? Object.keys(operation.requestBody.content || {}) : [];
-  const base = `${typeName("RequestQuery")} & ${typeName("RouteParameters")} & ${typeName("RequestHeaders")}`;
-  if (mediaTypes.length === 1) {
-    return `export type ${typeName("RequestParameters")} = ${base} & ${typeName("RequestBodies")}[${JSON.stringify(mediaTypes[0])}]`;
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async compile(compiler, task) {
+    return [
+      this.generateRequestArtifact()
+    ];
   }
-  if (mediaTypes.length > 1) {
-    const unions = mediaTypes.map((mediaType) => `(${base} & ${typeName("RequestBodies")}[${JSON.stringify(mediaType)}] & { "content-type": ${JSON.stringify(mediaType)} })`).join("\n| ");
-    return `export type ${typeName("RequestParameters")} = ${unions}`;
+  static getRequestArtifactFilepath() {
+    return "./request.ts";
   }
-  return `export type ${typeName("RequestParameters")} = ${base}`;
-}
-async function operationTypeRenderer(operationDefinition, alias = R15.identity) {
-  const { operation } = operationDefinition;
-  if (!operation.responses) return "";
-  const typeName = typeNameFactory(operationDefinition);
-  const $responseBodies = responseBodies(operation, alias, typeName);
-  const $requestBodies = requestBodies(operation, alias, typeName);
-  const $parameterBodies = parameterBodies(operationDefinition, alias, typeName);
-  const $requestParameters = requestParameters(operation, alias, typeName);
-  return [
-    "/* @anchor:file:start */",
-    "",
-    $responseBodies,
-    "",
-    $requestBodies,
-    "",
-    generateParameters(`${typeName("RequestQuery")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "query") || [], alias),
-    "",
-    generateParameters(`${typeName("RouteParameters")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "path") || [], alias),
-    "",
-    generateParameters(`${typeName("RequestHeaders")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "header") || [], alias),
-    "",
-    $parameterBodies || void 0,
-    $requestParameters,
-    "",
-    `export interface Operation<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${$parameterBodies ? `keyof ${typeName("ParameterBodies")}` : "string"} > extends KeqOperation {`,
-    `  requestParams: ${typeName("RouteParameters")} & { [key: string]: KeqPathParameterInit }`,
-    `  requestQuery: ${typeName("RequestQuery")} & { [key: string]: KeqQueryInit }`,
-    `  requestHeaders: ${typeName("RequestHeaders")} & { [key: string]: string | number }`,
-    `  requestBody: ${$parameterBodies ? `${typeName("ParameterBodies")}[CONTENT_TYPE] | ` : "object | "}BodyInit`,
-    `  responseBody: ${typeName("ResponseBodies")}[STATUS]`,
-    "}",
-    "",
-    "/* @anchor:file:end */"
-  ].filter(R15.isNotNil).join("\n");
-}
-function generateParameters(name, parameters, alias) {
-  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 = generateSchema(parameter.schema || { type: "any" }, alias);
-    return indent(2, `${$key}: ${$value}`);
-  }).join("\n");
-  return [
-    `export type ${name} = {`,
-    $parameters,
-    "}"
-  ].filter(Boolean).join("\n");
-}
-
-// src/renderer/operation-request/index.ts
-import * as R17 from "ramda";
-
-// src/renderer/operation-request/request-body.ts
-import * as R16 from "ramda";
+  static getRequestArtifactId() {
+    return `request?generator=${MICRO_FUNCTION_REQUEST_GENERATOR}`;
+  }
+};
 
-// src/renderer/operation-request/error-to-comment.ts
-function errorToComment(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/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 = MetadataStorage.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(
+      R21.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 = path10.dirname(filepath);
+    const artifact = new Artifact({
+      id: _MicroFunctionGenerator.getOperationDefinitionArtifactId(operationDefinition),
+      filepath,
+      content: OperationDefinitionTransformer.toMicroFunction(operationDefinition, {
+        esm: rc.esm,
+        getOperationDefinitionDeclarationFilepath(operationDefinition2) {
+          const relativePath = path10.relative(
+            dirpath,
+            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition2, rc.fileNamingStyle)
+          );
+          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        },
+        getRequestFilepath() {
+          const relativePath = path10.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/renderer/operation-request/request-body.ts
-function requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition) {
-  try {
-    const $propertyName = JSON.stringify(propertyName);
-    const schema = JsonSchemaUtils.isRef(propertySchema) ? OpenapiUtils.dereferenceDeep(propertySchema.$ref, 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}]))`;
+// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
+var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
+  microFunctionGenerator = new MicroFunctionGenerator();
+  requestGenerator = new RequestGenerator();
+  apply(compiler) {
+    _GenerateMicroFunctionPlugin.register(compiler);
+    compiler.hooks.compile.tapPromise(_GenerateMicroFunctionPlugin.name, async (task) => {
+      const artifacts = [
+        ...await this.requestGenerator.compile(compiler, task),
+        ...await this.microFunctionGenerator.compile(compiler, task)
+      ];
+      compiler.context.artifacts.push(...artifacts);
+    });
+  }
+  static register(compiler) {
+    if (!MetadataStorage.has(compiler)) {
+      MetadataStorage.set(compiler, {
+        hooks: {
+          afterEntrypointArtifactGenerated: new AsyncSeriesWaterfallHook2(["artifact", "task"]),
+          afterMicroFunctionArtifactGenerated: new AsyncSeriesWaterfallHook2(["artifact", "operationDefinition", "task"])
+        }
+      });
     }
-    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 errorToComment(err, mediaType);
+    return MetadataStorage.get(compiler);
   }
-}
-function requestBodyPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition) {
-  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 requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition);
-  } else {
-    throw new Error(`Unsupported media type: ${mediaType}`);
+  static of(compiler) {
+    return this.register(compiler);
   }
-}
-function requestBodyRenderer(operationDefinition, typeName) {
-  const { operation } = operationDefinition;
-  const requestBodyContent = operation.requestBody?.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, operationDefinition.document.specification) : mediaTypeObject.schema;
-      if (schema.type !== "object") return;
-      const properties = schema.properties || {};
-      return Object.entries(properties).map(([propertyName, propertySchema]) => {
-        return indent(
-          2,
-          requestBodyPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition)
-        );
-      }).join("\n");
-    } catch (err) {
-      return indent(2, errorToComment(err, mediaType));
-    }
-  }).filter(R16.isNotNil).join("\n");
-  return $requestBody;
-}
+};
 
-// src/renderer/operation-request/index.ts
-function requestHeadersRenderer(operationDefinition, typeName) {
-  const { operation } = 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)}])`).concat("").join("\n");
-  return $headers;
-}
-function requestQueryRenderer(operationDefinition, qs, typeName) {
-  const { operation } = operationDefinition;
-  const $query = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
-    const option = qs(p);
-    const $option = !option || R17.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})`;
-  }).concat("").join("\n");
-  return $query;
-}
-function requestPathParametersRenderer(operationDefinition, typeName) {
-  const { operation } = 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)}])`).concat("").join("\n");
-  return $pathParameters;
-}
-function getRequestMediaTypes(operationDefinition) {
-  const { operation } = operationDefinition;
-  const requestBodyContent = operation.requestBody?.content || {};
-  return Object.keys(requestBodyContent);
-}
-function mediaTypeRenderer(operationDefinition) {
-  const mediaTypes = getRequestMediaTypes(operationDefinition);
-  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 "";
-}
-function operationDeclarationRenderer(operationDefinition, typeName) {
-  const { operationId } = operationDefinition;
-  const mediaTypes = getRequestMediaTypes(operationDefinition);
-  if (mediaTypes.length === 0) {
-    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends never = never>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, CONTENT_TYPE>>`;
-  } else if (mediaTypes.length === 1) {
-    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${JSON.stringify(mediaTypes[0])} = ${JSON.stringify(mediaTypes[0])}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, CONTENT_TYPE>>`;
-  } else if (mediaTypes.length > 1) {
-    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${typeName("RequestParameters")}["content-type"]>(args?: Extract<${typeName("RequestParameters")}, { "content-type": CONTENT_TYPE }>): Keq<Operation<STATUS, CONTENT_TYPE>>`;
-  }
-  throw new Error("[operationDeclarationRenderer] Unreachable");
-}
-async function operationRequestRenderer(operationDefinition, options) {
-  const { operation, operationId, method, pathname } = operationDefinition;
-  const { qs } = options;
-  if (!operation.responses) return "";
-  const typeName = typeNameFactory(operationDefinition);
-  const moduleName = operationDefinition.module.name;
-  const $method = method.toLowerCase();
-  const $queryParameters = requestQueryRenderer(operationDefinition, qs, typeName);
-  const $headerParameters = requestHeadersRenderer(operationDefinition, typeName);
-  const $pathParameters = requestPathParametersRenderer(operationDefinition, typeName);
-  const $mediaType = mediaTypeRenderer(operationDefinition);
-  const $requestBody = requestBodyRenderer(operationDefinition, typeName);
-  const $operationDeclaration = operationDeclarationRenderer(operationDefinition, typeName);
-  return [
-    "/* @anchor:file:start */",
-    "",
-    `const moduleName = "${moduleName}"`,
-    `const method = "${method}"`,
-    `const pathname = "${pathname}"`,
-    "",
-    "/* @anchor:operation-declaration */",
-    `export ${$operationDeclaration} {`,
-    `  const req = request.${$method}<${typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
-    "    .option('module', { name: moduleName, pathname, method })",
-    "",
-    $mediaType || void 0,
-    "  /* @anchor:query:start */",
-    $queryParameters || void 0,
-    "  /* @anchor:query:end */",
-    "",
-    "  /* @anchor:headers:start */",
-    $headerParameters || void 0,
-    "  /* @anchor:headers:end */",
-    "",
-    "  /* @anchor:path-parameters:start */",
-    $pathParameters || void 0,
-    "  /* @anchor:path-parameters:end */",
-    "",
-    "  /* @anchor:body:start */",
-    $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(R17.isNotNil).join("\n");
-}
+// src/plugins/generate-nestjs-module/generate-nestjs-module.ts
+import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook3 } from "tapable";
 
-// src/tasks/compile/utils/compile-operation-definition.ts
-function genOperationTypeFilepath(operationDefinition) {
-  const filename = `${operationDefinition.operationId}.type.ts`;
-  return [
-    ".",
-    operationDefinition.module.name,
-    "types",
-    filename
-  ].join("/");
-}
-function genOperationRequestFilepath(operationDefinition) {
-  const filename = `${operationDefinition.operationId}.request.ts`;
-  return [
-    ".",
-    operationDefinition.module.name,
-    "operations",
-    filename
-  ].join("/");
-}
-function genEntrypointFilepath2(moduleName) {
-  return [
-    ".",
-    moduleName,
-    "operations",
-    "index.ts"
-  ].join("/");
-}
-async function compileOperationDefinition(options) {
-  const { compiler, task, rc, requestArtifact, schemaArtifacts, operationDefinitions } = options;
-  const alias = (name) => `${name}Schema`;
-  const qs = (parameter) => {
-    if (typeof rc.qs === "function") {
-      return rc.qs(parameter);
-    } else if (typeof rc.qs === "object") {
-      return rc.qs;
-    }
-    const style = parameter.style || "form";
-    const explode = parameter.explode ?? true;
-    if (style === "deepObject") {
-      return { arrayFormat: "brackets" };
-    } else if (explode) {
-      return { arrayFormat: "repeat" };
-    } else {
-      if (style === "form") {
-        return { arrayFormat: "comma" };
-      } else if (style === "spaceDelimited") {
-        return { arrayFormat: "space" };
-      } else if (style === "pipeDelimited") {
-        return { arrayFormat: "pipe" };
-      }
-    }
-    return {};
-  };
-  async function createTypeArtifact(operationDefinition) {
-    const content = await operationTypeRenderer(operationDefinition, alias);
-    const filepath = genOperationTypeFilepath(operationDefinition);
-    const typeArtifact = new Artifact({
-      id: filepath,
+// src/plugins/generate-nestjs-module/constants/metadata-storage.ts
+var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/generate-nestjs-module/generators/nestjs-module.generator.ts
+import * as path11 from "path";
+import * as changeCase7 from "change-case";
+var NESTJS_MODULE_GENERATOR = "nestjs-module-generator";
+var NestjsModuleGenerator = class _NestjsModuleGenerator {
+  generateNestjsModuleArtifact(document, rc) {
+    const filepath = _NestjsModuleGenerator.getNestjsModuleArtifactFilepath(document, rc.fileNamingStyle);
+    const dirname6 = path11.dirname(filepath);
+    const artifact = new Artifact({
+      id: _NestjsModuleGenerator.getNestjsModuleArtifactId(document),
       filepath,
-      content,
-      extensionName: ".type.ts"
+      content: ApiDocumentTransformer.toNestjsModule(document, {
+        esm: rc.esm,
+        getNestjsClientFilepath(document2) {
+          const relativePath = path11.relative(
+            dirname6,
+            _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document2, rc.fileNamingStyle)
+          );
+          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        }
+      })
     });
-    typeArtifact.addDependence("keq", ["KeqOperation", "KeqQueryInit", "KeqPathParameterInit"]);
-    const dependentSchemaDefinitions = operationDefinition.getDependencies();
-    for (const dependentSchemaDefinition of dependentSchemaDefinitions) {
-      const dependentArtifact = schemaArtifacts.find(isArtifactCompiledBy(dependentSchemaDefinition));
-      if (!dependentArtifact) {
-        typeArtifact.addWarn(`Cannot find dependent $ref: ${dependentSchemaDefinition.id}`);
-        continue;
-      }
-      typeArtifact.addDependence(dependentArtifact, [
-        new DependencyIdentifier(dependentSchemaDefinition.name, alias(dependentSchemaDefinition.name))
-      ]);
-    }
-    return await compiler.hooks.afterCompileOperationType.promise(typeArtifact, operationDefinition, task);
+    return artifact;
   }
-  async function createRequestArtifact(operationDefinition, typeArtifact) {
-    const typeName = typeNameFactory(operationDefinition);
-    const content = await operationRequestRenderer(operationDefinition, { qs });
-    const filepath = genOperationRequestFilepath(operationDefinition);
+  generateNestjsClientArtifact(document, rc) {
+    const filepath = _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document, rc.fileNamingStyle);
+    const dirpath = path11.dirname(filepath);
     const artifact = new Artifact({
-      id: filepath,
+      id: _NestjsModuleGenerator.getNestjsClientArtifactId(document),
       filepath,
-      content,
-      extensionName: ".request.ts"
+      content: ApiDocumentTransformer.toNestjsClient(document, {
+        esm: rc.esm,
+        getOperationDefinitionDeclarationFilepath(operationDefinition) {
+          const relativePath = path11.relative(
+            dirpath,
+            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle)
+          );
+          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        }
+      })
     });
-    artifact.addDependence("keq", ["Keq"]);
-    artifact.addDependence(requestArtifact, ["request"]);
-    artifact.addDependence(
-      typeArtifact,
-      [
-        "Operation",
-        typeName("ResponseBodies"),
-        typeName("RequestParameters")
-      ],
-      { type: true }
+    return artifact;
+  }
+  async compile(compiler, task) {
+    const metadata = MetadataStorage3.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
+      ))
     );
-    artifact.addDependence(
-      typeArtifact,
-      [
-        `${typeName("RequestQuery")}`,
-        `${typeName("RequestHeaders")}`,
-        `${typeName("RequestBodies")}`
-      ],
-      { export: true, type: true }
+    const nestjsClientArtifacts = await Promise.all(
+      documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(
+        this.generateNestjsClientArtifact(document, rc),
+        document,
+        task
+      ))
     );
-    return await compiler.hooks.afterCompileOperationRequest.promise(artifact, operationDefinition, task);
-  }
-  const artifacts = R18.unnest(
-    await Promise.all(
-      operationDefinitions.map(async (operationDefinition) => {
-        const typeArtifact = await createTypeArtifact(operationDefinition);
-        const operationArtifact = await createRequestArtifact(operationDefinition, typeArtifact);
-        return [typeArtifact, operationArtifact];
-      })
-    )
-  );
-  const operationDefinitionsGroupByModuleName = R18.groupBy(
-    (operationDefinition) => operationDefinition.module.name,
-    operationDefinitions
-  );
-  const entrypointArtifacts = Object.entries(operationDefinitionsGroupByModuleName).map(([moduleName, operationDefinitions2]) => {
-    const filepath = genEntrypointFilepath2(moduleName);
-    const artifact = new Artifact({
-      id: filepath,
-      filepath,
-      content: [
-        "/* @anchor:file:start */",
-        "/* @anchor:file:end */"
-      ].join("\n")
+    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 = class _GenerateNestjsModulePlugin {
+  nestjsModuleGenerator = new NestjsModuleGenerator();
+  apply(compiler) {
+    _GenerateNestjsModulePlugin.register(compiler);
+    compiler.hooks.compile.tapPromise(_GenerateNestjsModulePlugin.name, async (task) => {
+      const artifacts = await this.nestjsModuleGenerator.compile(compiler, task);
+      compiler.context.artifacts.push(...artifacts);
     });
-    for (const operationDefinition of operationDefinitions2 || []) {
-      const dependentArtifact = artifacts.find((artifact2) => artifact2.filepath === genOperationRequestFilepath(operationDefinition));
-      if (!dependentArtifact) {
-        artifact.addWarn(`Cannot find operation: operation = ${operationDefinition.operationId}, pathname = ${operationDefinition.pathname}, method = ${operationDefinition.method}`);
-        continue;
-      }
-      artifact.addDependence(dependentArtifact, [], { export: true });
+  }
+  static register(compiler) {
+    if (!MetadataStorage3.has(compiler)) {
+      MetadataStorage3.set(compiler, {
+        hooks: {
+          afterNestjsModuleArtifactGenerated: new AsyncSeriesWaterfallHook3(["artifact", "document", "task"])
+        }
+      });
     }
-    return artifact;
-  });
-  return [...artifacts, ...entrypointArtifacts];
-}
+    return MetadataStorage3.get(compiler);
+  }
+  static of(compiler) {
+    return MetadataStorage3.get(compiler);
+  }
+};
 
-// src/renderer/request/index.ts
-async function requestRenderer() {
-  return [
-    "/* @anchor:file:start */",
-    "",
-    "/* @anchor:request-declaration */",
-    "export const request = new KeqRequest()",
-    "",
-    "/* @anchor:file:end */"
-  ].join("\n");
-}
+// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
+import { fixSwagger } from "swagger-fix";
 
-// src/tasks/compile/index.ts
-function main6(compiler) {
-  return {
-    task: async (context, task) => {
-      if (!context.setup) throw new Error("Please run setup task first.");
-      if (!context.shaken) throw new Error("Please run shaking task first.");
-      const rc = context.setup.rc;
-      const matcher = context.setup.matcher;
-      const documents = context.shaken.documents.filter((document) => !matcher.isModuleIgnored(document.module));
-      let requestArtifact = new Artifact({
-        id: "request",
-        filepath: "request",
-        content: await requestRenderer(),
-        extensionName: ".ts"
-      });
-      requestArtifact.addDependence("keq", ["KeqRequest"]);
-      requestArtifact = await compiler.hooks.afterCompileKeqRequest.promise(
-        requestArtifact,
-        task
-      );
-      const schemaDefinitions = documents.flatMap((document) => document.schemas);
-      const operationDefinitions = documents.flatMap((document) => document.operations);
-      const schemaArtifacts = await compileSchemaDefinition({ compiler, task, schemaDefinitions });
-      const operationArtifacts = await compileOperationDefinition({ compiler, task, rc, operationDefinitions, schemaArtifacts, requestArtifact });
-      const artifacts = [requestArtifact, ...schemaArtifacts, ...operationArtifacts];
-      context.compiled = {
-        artifacts
-      };
+// src/plugins/download-http-file/download-http-file.plugin.ts
+import * as validUrl from "valid-url";
+var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
+  apply(compiler) {
+    compiler.hooks.download.tapPromise(_DownloadHttpFilePlugin.name, async (address, task) => {
+      if (!validUrl.isUri(address)) return void 0;
+      const content = await this.download(address);
+      const spec = this.deserialize(content);
+      return JSON.stringify(spec);
+    });
+  }
+  async download(address) {
+    try {
+      const res = await fetch(address);
+      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 ${address}: ${e.message}`;
+      }
+      throw e;
     }
-  };
-}
-function createCompileTask(compiler, options) {
-  return {
-    title: "Compile",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main6(compiler),
-        {
-          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
+  }
+  deserialize(content) {
+    const json = JSON.parse(content);
+    const spec = OpenapiUtils.to3_1(json);
+    return spec;
+  }
+};
+
+// src/plugins/download-local-file/download-local-file.plugin.ts
+import * as path12 from "path";
+import * as fs5 from "fs/promises";
+import * as yaml from "js-yaml";
+var DownloadLocalFilePlugin = class _DownloadLocalFilePlugin {
+  apply(compiler) {
+    compiler.hooks.download.tapPromise(_DownloadLocalFilePlugin.name, async (address, task) => {
+      if (!address.startsWith("./") && !address.startsWith("/") && !address.startsWith("../")) return void 0;
+      const fileExt = path12.extname(address);
+      const content = await fs5.readFile(address, "utf8");
+      if ([".yml", ".yaml"].includes(fileExt)) {
+        const value = yaml.load(content);
+        return JSON.stringify(OpenapiUtils.to3_1(value));
+      } else if (fileExt === ".json") {
+        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(content)));
       }
-    )
-  };
-}
+    });
+  }
+};
+
+// src/plugins/shaking/shaking.plugin.ts
+import { openapiShakingSync } from "@opendoc/openapi-shaking";
+var ShakingPlugin = class _ShakingPlugin {
+  apply(compiler) {
+    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 = openapiShakingSync(
+      document.specification,
+      isAccepted,
+      { tolerant: rc.tolerant }
+    );
+    return new ApiDocumentV3_1(
+      sharkedSwagger,
+      new ModuleDefinition(
+        document.module.name,
+        `file://${document.module.name}.v3_1.sharked.json`
+      )
+    );
+  }
+};
 
-// src/tasks/interactive/utils/select-operation-definitions.ts
+// src/plugins/terminal-select/utils/select-operation-definitions.ts
 import { select } from "inquirer-select-pro";
 import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
 async function selectOperationDefinitions(task, operationDefinitions) {
@@ -2125,19 +2647,19 @@ async function selectOperationDefinitions(task, operationDefinitions) {
   return selectedOperationDefinitions;
 }
 
-// src/tasks/interactive/index.ts
-function createInteractiveTask(options) {
-  return {
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: async (context, task) => {
-      if (!context.setup) throw new Error("Please run setup task first.");
-      if (!context.validated) throw new Error("Please run validate task first.");
-      const matcher = context.setup.matcher;
-      const documents = context.validated.documents;
+// src/plugins/terminal-select/terminal-select.plugin.ts
+var TerminalSelectPlugin = class _TerminalSelectPlugin {
+  constructor(options) {
+    this.options = options;
+  }
+  apply(compiler) {
+    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 (options.clear) {
+      if (this.options.clear) {
         matcher.append({
           persist: false,
           ignore: true,
@@ -2148,109 +2670,74 @@ function createInteractiveTask(options) {
       }
       for (const op of selectedOperationDefinitions) {
         matcher.append({
-          persist: !!options.persist,
-          ignore: options.mode === "add",
+          persist: !!this.options.persist,
+          ignore: this.options.mode === "add",
           moduleName: op.module.name,
           operationMethod: op.method,
           operationPathname: op.pathname
         });
       }
-    }
-  };
-}
+    });
+  }
+};
 
-// src/compiler/intercepter/perfect-error-message.ts
-import * as R19 from "ramda";
-function perfectErrorMessage() {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      function prefix(err) {
-        if (err instanceof Error) {
-          err.message = `[Plugin: ${tap.name}] ${err.message}`;
-        }
+// src/plugins/initialize/initialize.plugin.ts
+import * as R23 from "ramda";
+var InitializePlugin = class _InitializePlugin {
+  constructor(options) {
+    this.options = options;
+  }
+  apply(compiler) {
+    compiler.hooks.setup.tap(_InitializePlugin.name, (task) => {
+      new DownloadHttpFilePlugin().apply(compiler);
+      new DownloadLocalFilePlugin().apply(compiler);
+      new GenerateDeclarationPlugin().apply(compiler);
+      if (this.options.build) {
+        new ShakingPlugin().apply(compiler);
       }
-      if (tap.type === "promise") {
-        tap.fn = async (...args) => {
-          try {
-            return await fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
+      if (this.options.interactive) {
+        new TerminalSelectPlugin(
+          typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
+        ).apply(compiler);
       }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          try {
-            return fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
+      const rc = compiler.context.rc;
+      if (rc.mode === "micro-function") {
+        new GenerateMicroFunctionPlugin().apply(compiler);
+      } else if (rc.mode === "nestjs-module") {
+        new GenerateNestjsModulePlugin().apply(compiler);
       }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const callback = R19.last(args);
-          return fn(...R19.init(args), (err, result) => {
-            prefix(err);
-            return callback(err, result);
-          });
-        };
+      if (rc.plugins && rc.plugins.length) {
+        for (const plugin of rc.plugins) {
+          plugin.apply(compiler);
+        }
       }
-      return tap;
+    });
+    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 = R23.difference(R23.keys(rc.modules), modulesIncludes);
+        for (const moduleName of ignoredModules) {
+          matcher.append({
+            persist: false,
+            ignore: true,
+            moduleName,
+            operationMethod: "*",
+            operationPathname: "*"
+          });
+        }
+      });
     }
-  };
-}
+  }
+};
 
-// src/compiler/intercepter/print-information.ts
-function proxyTaskWrapper(pluginName, task) {
-  return new Proxy(task, {
-    set(target, prop2, value) {
-      if (prop2 !== "output") {
-        return Reflect.set(target, prop2, value);
-      }
-      target.output = `[Plugin: ${pluginName}] ${value}`;
-      return true;
-    }
-  });
-}
-function printInformation(taskIndex) {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      if (tap.type === "promise") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      return tap;
-    }
-  };
-}
+// src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
+var QsArrayFormatUnion = Object.values(QsArrayFormat);
 
 // src/compiler/compiler.ts
 var Compiler = class {
@@ -2261,22 +2748,26 @@ var Compiler = class {
     }
     this.hooks.afterSetup.intercept(printInformation(0));
     this.hooks.afterPersist.intercept(printInformation(0));
+    new InitializePlugin({
+      build: options.build,
+      interactive: options.interactive,
+      includes: options.includes
+    }).apply(this);
   }
   context = {};
   hooks = {
-    // core
+    setup: new AsyncParallelHook(["task"]),
     afterSetup: new AsyncSeriesHook(["task"]),
+    beforeDownload: new AsyncSeriesHook(["task"]),
+    download: new AsyncSeriesBailHook(["address", "moduleDefinition", "task"]),
     afterDownload: new AsyncSeriesHook(["task"]),
-    afterValidate: new AsyncSeriesHook(["task"]),
-    afterShaking: new AsyncSeriesHook(["task"]),
+    beforeCompile: new AsyncSeriesHook(["task"]),
+    compile: new AsyncParallelHook(["task"]),
     afterCompile: new AsyncSeriesHook(["task"]),
+    beforePersist: new AsyncSeriesHook(["task"]),
+    persist: new AsyncParallelHook(["task"]),
     afterPersist: new AsyncSeriesHook(["task"]),
-    done: new SyncHook(),
-    // compile
-    afterCompileKeqRequest: new AsyncSeriesWaterfallHook(["artifact", "task"]),
-    afterCompileSchema: new AsyncSeriesWaterfallHook(["artifact", "schema", "task"]),
-    afterCompileOperationType: new AsyncSeriesWaterfallHook(["artifact", "operation", "task"]),
-    afterCompileOperationRequest: new AsyncSeriesWaterfallHook(["artifact", "operation", "task"])
+    done: new SyncHook()
   };
   async run() {
     const options = this.options;
@@ -2284,9 +2775,6 @@ var Compiler = class {
       [
         createSetupTask(this, options),
         createDownloadTask(this, { skipIgnoredModules: !options.interactive }),
-        createValidateTask(this),
-        createInteractiveTask({ enabled: !!options.interactive, ...typeof options.interactive === "object" ? options.interactive : { mode: "except" } }),
-        createShakingTask(this, { enabled: !!options.build, ...typeof options.build === "object" ? options.build.shaking : void 0 }),
         createCompileTask(this, { enabled: !!options.build }),
         createPersistTask(this)
       ],
@@ -2305,9 +2793,9 @@ var Compiler = class {
   }
 };
 export {
-  ApiDocument,
   ApiDocumentV3_1,
   Artifact,
+  Asset,
   Compiler,
   FileNamingStyle,
   ModuleDefinition,