@ps-aux/api-client-gen 0.7.0-rc.3 → 0.7.0-rc.5

package/dist/generateApiClient.mjs

@@ -1,12 +1,11 @@
-import Path from 'path';
+import Path$1 from 'path';
 import * as fs from 'fs';
-import fs__default from 'fs';
 import fs$1 from 'fs/promises';
+import Path from 'node:path';
 import { generateApi } from 'swagger-typescript-api';
 import { fileURLToPath } from 'node:url';
 import { readFile } from 'node:fs/promises';
-import Path$1 from 'node:path';
-import fs$2 from 'node:fs';
+import fs__default from 'node:fs';
 import { generate } from 'ts-to-zod';
 
 /** A special constant with type `never` */
@@ -701,6 +700,7 @@ const string$1 = (params) => {
     const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
     return new RegExp(`^${regex}$`);
 };
+const number = /^-?\d+(?:\.\d+)?$/;
 const boolean$1 = /^(?:true|false)$/i;
 // regex for string with no uppercase letters
 const lowercase = /^[^A-Z]*$/;
@@ -1897,6 +1897,122 @@ function handleIntersectionResults(result, left, right) {
     result.value = merged.data;
     return result;
 }
+const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+        const input = payload.value;
+        if (!isPlainObject(input)) {
+            payload.issues.push({
+                expected: "record",
+                code: "invalid_type",
+                input,
+                inst,
+            });
+            return payload;
+        }
+        const proms = [];
+        const values = def.keyType._zod.values;
+        if (values) {
+            payload.value = {};
+            const recordKeys = new Set();
+            for (const key of values) {
+                if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+                    recordKeys.add(typeof key === "number" ? key.toString() : key);
+                    const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+                    if (result instanceof Promise) {
+                        proms.push(result.then((result) => {
+                            if (result.issues.length) {
+                                payload.issues.push(...prefixIssues(key, result.issues));
+                            }
+                            payload.value[key] = result.value;
+                        }));
+                    }
+                    else {
+                        if (result.issues.length) {
+                            payload.issues.push(...prefixIssues(key, result.issues));
+                        }
+                        payload.value[key] = result.value;
+                    }
+                }
+            }
+            let unrecognized;
+            for (const key in input) {
+                if (!recordKeys.has(key)) {
+                    unrecognized = unrecognized ?? [];
+                    unrecognized.push(key);
+                }
+            }
+            if (unrecognized && unrecognized.length > 0) {
+                payload.issues.push({
+                    code: "unrecognized_keys",
+                    input,
+                    inst,
+                    keys: unrecognized,
+                });
+            }
+        }
+        else {
+            payload.value = {};
+            for (const key of Reflect.ownKeys(input)) {
+                if (key === "__proto__")
+                    continue;
+                let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+                if (keyResult instanceof Promise) {
+                    throw new Error("Async schemas not supported in object keys currently");
+                }
+                // Numeric string fallback: if key is a numeric string and failed, retry with Number(key)
+                // This handles z.number(), z.literal([1, 2, 3]), and unions containing numeric literals
+                const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+                if (checkNumericKey) {
+                    const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+                    if (retryResult instanceof Promise) {
+                        throw new Error("Async schemas not supported in object keys currently");
+                    }
+                    if (retryResult.issues.length === 0) {
+                        keyResult = retryResult;
+                    }
+                }
+                if (keyResult.issues.length) {
+                    if (def.mode === "loose") {
+                        // Pass through unchanged
+                        payload.value[key] = input[key];
+                    }
+                    else {
+                        // Default "strict" behavior: error on invalid key
+                        payload.issues.push({
+                            code: "invalid_key",
+                            origin: "record",
+                            issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                            input: key,
+                            path: [key],
+                            inst,
+                        });
+                    }
+                    continue;
+                }
+                const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+                if (result instanceof Promise) {
+                    proms.push(result.then((result) => {
+                        if (result.issues.length) {
+                            payload.issues.push(...prefixIssues(key, result.issues));
+                        }
+                        payload.value[keyResult.value] = result.value;
+                    }));
+                }
+                else {
+                    if (result.issues.length) {
+                        payload.issues.push(...prefixIssues(key, result.issues));
+                    }
+                    payload.value[keyResult.value] = result.value;
+                }
+            }
+        }
+        if (proms.length) {
+            return Promise.all(proms).then(() => payload);
+        }
+        return payload;
+    };
+});
 const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def) => {
     $ZodType.init(inst, def);
     const values = getEnumValues(def.entries);
@@ -3293,6 +3409,49 @@ const intersectionProcessor = (schema, ctx, json, params) => {
     ];
     json.allOf = allOf;
 };
+const recordProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    json.type = "object";
+    // For looseRecord with regex patterns, use patternProperties
+    // This correctly represents "only validate keys matching the pattern" semantics
+    // and composes well with allOf (intersections)
+    const keyType = def.keyType;
+    const keyBag = keyType._zod.bag;
+    const patterns = keyBag?.patterns;
+    if (def.mode === "loose" && patterns && patterns.size > 0) {
+        // Use patternProperties for looseRecord with regex patterns
+        const valueSchema = process(def.valueType, ctx, {
+            ...params,
+            path: [...params.path, "patternProperties", "*"],
+        });
+        json.patternProperties = {};
+        for (const pattern of patterns) {
+            json.patternProperties[pattern.source] = valueSchema;
+        }
+    }
+    else {
+        // Default behavior: use propertyNames + additionalProperties
+        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+            json.propertyNames = process(def.keyType, ctx, {
+                ...params,
+                path: [...params.path, "propertyNames"],
+            });
+        }
+        json.additionalProperties = process(def.valueType, ctx, {
+            ...params,
+            path: [...params.path, "additionalProperties"],
+        });
+    }
+    // Add required for keys with discrete values (enum, literal, etc.)
+    const keyValues = keyType._zod.values;
+    if (keyValues) {
+        const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+        if (validKeyValues.length > 0) {
+            json.required = validKeyValues;
+        }
+    }
+};
 const nullableProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
     const inner = process(def.innerType, ctx, params);
@@ -3796,6 +3955,21 @@ function intersection(left, right) {
         right: right,
     });
 }
+const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
+    $ZodRecord.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+    return new ZodRecord({
+        type: "record",
+        keyType,
+        valueType: valueType,
+        ...normalizeParams(params),
+    });
+}
 const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def) => {
     $ZodEnum.init(inst, def);
     ZodType.init(inst, def);
@@ -4028,8 +4202,19 @@ const vNextOasGeneratorSchema = strictObject({
     unwrap: boolean().default(true),
     withRequestParams: boolean().default(false),
     pathParamsStyle: _enum(["object", "positional"]).default("positional"),
-    enumStyle: _enum(["enum", "union"]).default("enum")
-  }),
+    enumStyle: _enum(["enum", "union"]).default("enum"),
+    comments: strictObject({
+      enabled: boolean().default(true),
+      operation: strictObject({
+        tags: boolean().default(true),
+        summary: boolean().default(true),
+        description: boolean().default(true)
+      }).prefault({}),
+      schema: strictObject({
+        metadata: boolean().default(true)
+      }).prefault({})
+    }).prefault({})
+  }).prefault({}),
   compat: strictObject({
     uppercaseEnumKeys: boolean(),
     swaggerTsApiRequiredBooleans: boolean()
@@ -4040,7 +4225,7 @@ const legacyOasGeneratorSchema = strictObject({
     ignoreOperationsWithTags: array(string()).optional()
   })
 });
-const configSchema = strictObject({
+const profileConfigSchema = strictObject({
   srcSpec: string().trim().min(1),
   dstDir: string().trim().min(1),
   apiName: string().trim().min(1),
@@ -4058,6 +4243,8 @@ const configSchema = strictObject({
     localDateTimes: boolean().optional()
   }).optional()
 });
+const configSchema = record(string(), profileConfigSchema);
+const defineConfig = (config) => config;
 const parseConfig = (userConfig, filePath) => {
   const parsed = configSchema.safeParse(userConfig);
   if (parsed.success) return parsed.data;
@@ -4065,6 +4252,13 @@ const parseConfig = (userConfig, filePath) => {
     cause: parsed.error
   });
 };
+const parseProfileConfig = (userConfig, filePath) => {
+  const parsed = profileConfigSchema.safeParse(userConfig);
+  if (parsed.success) return parsed.data;
+  throw new Error(`Invalid config at ${filePath}: ${parsed.error.message}`, {
+    cause: parsed.error
+  });
+};
 
 const downloadSpec = async (path, url) => {
   let response;
@@ -4085,6 +4279,34 @@ const downloadSpec = async (path, url) => {
   await fs$1.writeFile(path, content);
 };
 
+const EMPTY_LINE_MARKER = "/*__EMPTY_LINE_MARKER__*/";
+
+var __defProp$b = Object.defineProperty;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$b = (obj, key, value) => __defNormalProp$b(obj, key + "" , value);
+const EMPTY_LINE_MARKER_LINE = new RegExp(
+  `\\n[\\t ]*${EMPTY_LINE_MARKER.replaceAll("/", "\\/").replaceAll(
+    "*",
+    "\\*"
+  )}\\n`,
+  "g"
+);
+class CodeFormatter {
+  constructor(opts) {
+    this.opts = opts;
+    __publicField$b(this, "format", async (code) => {
+      const filePath = Path.resolve(this.opts.resolveConfFrom, "generated.ts");
+      const prettier = await import('prettier');
+      const prettierConfig = await prettier.resolveConfig(filePath) ?? {};
+      const formattedCode = await prettier.format(code, {
+        ...prettierConfig,
+        filepath: filePath
+      });
+      return formattedCode.replaceAll(EMPTY_LINE_MARKER_LINE, "\n\n");
+    });
+  }
+}
+
 const toPascalCaseIdentifier = (str) => {
   const words = str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).filter(Boolean);
   const pascalCase = words.map((word) => word[0].toUpperCase() + word.substring(1)).join("");
@@ -4105,6 +4327,12 @@ const groupBy = (values, getKey) => {
   }
   return groups;
 };
+const findRelativePath = (src, dst) => {
+  const relativePath = Path$1.relative(Path$1.dirname(src), dst);
+  const withoutExtension = relativePath.replace(/\.ts$/u, "");
+  const normalizedPath = withoutExtension.split(Path$1.sep).join("/");
+  return normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
+};
 
 const generateOpenApiClient = async (inputFile, {
   name,
@@ -4113,7 +4341,7 @@ const generateOpenApiClient = async (inputFile, {
 }, log) => {
   log(`Will generate API client name=${name} to ${outputDir}`);
   const fileName = "index";
-  const dstFile = Path.join(outputDir, `${fileName}.ts`);
+  const dstFile = Path$1.join(outputDir, `${fileName}.ts`);
   const prettier = await import('prettier');
   const prettierConfig = await prettier.resolveConfig(dstFile) ?? {};
   const prettierConfigForGenerator = {
@@ -4157,12 +4385,12 @@ const generateOpenApiClient = async (inputFile, {
   return { types: dstFile, promiseWrapper: [dstFile] };
 };
 const getThisScriptDirname = () => {
-  return Path.dirname(fileURLToPath(import.meta.url));
+  return Path$1.dirname(fileURLToPath(import.meta.url));
 };
 const getTemplatesDir = () => {
   const currentDir = getThisScriptDirname();
-  const templatesRelativePath = Path.basename(currentDir) === "dist" ? "../templates" : "../../../templates";
-  return Path.resolve(currentDir, templatesRelativePath);
+  const templatesRelativePath = Path$1.basename(currentDir) === "dist" ? "../templates" : "../../../templates";
+  return Path$1.resolve(currentDir, templatesRelativePath);
 };
 
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4219,9 +4447,9 @@ const resolveLocalRef = (root, ref) => {
   return current;
 };
 
-var __defProp$9 = Object.defineProperty;
-var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$9 = (obj, key, value) => __defNormalProp$9(obj, key + "" , value);
+var __defProp$a = Object.defineProperty;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$a = (obj, key, value) => __defNormalProp$a(obj, key + "" , value);
 const PARAMETER_LOCATIONS = [
   "path",
   "query",
@@ -4247,7 +4475,7 @@ const mergeParameters = (base, override) => {
 class OpenApiNormalizer {
   constructor(doc) {
     this.doc = doc;
-    __publicField$9(this, "problems", []);
+    __publicField$a(this, "problems", []);
   }
   load() {
     const info = readRecord(this.doc, "info");
@@ -4590,23 +4818,24 @@ const syntheticOperationId = (method, path) => {
   return `_${compact}`;
 };
 
-var __defProp$8 = Object.defineProperty;
-var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$8 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$9 = Object.defineProperty;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$9 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
 class TsCodegen {
-  constructor(typeExprCodegen) {
+  constructor(typeExprCodegen, docRenderer) {
     this.typeExprCodegen = typeExprCodegen;
-    __publicField$8(this, "usedTypeRefs", []);
-    __publicField$8(this, "usedTypeRefKeys", /* @__PURE__ */ new Set());
-    __publicField$8(this, "typeExpr", (typeExpr) => {
+    __publicField$9(this, "usedTypeRefs", []);
+    __publicField$9(this, "usedTypeRefKeys", /* @__PURE__ */ new Set());
+    __publicField$9(this, "docRenderer");
+    __publicField$9(this, "typeExpr", (typeExpr) => {
       this.collectTypeRefsFromExpr(typeExpr);
       return this.typeExprCodegen.toCode(typeExpr).code;
     });
-    __publicField$8(this, "declaration", (name, declaration) => {
+    __publicField$9(this, "declaration", (name, declaration, options = {}) => {
       this.collectTypeRefsFromDeclaration(declaration);
-      return this.toDeclarationCode(name, declaration);
+      return this.toDeclarationCode(name, declaration, options);
     });
-    __publicField$8(this, "toChunk", (name, code, exports$1) => {
+    __publicField$9(this, "toChunk", (name, code, exports$1) => {
       const exportedSymbols = new Set(exports$1);
       const refs = this.getTypeRefs().filter((ref) => {
         return ref.kind !== "internal" || !exportedSymbols.has(ref.name);
@@ -4618,17 +4847,25 @@ class TsCodegen {
         refs
       };
     });
-    __publicField$8(this, "getTypeRefs", () => {
+    __publicField$9(this, "getTypeRefs", () => {
       return this.usedTypeRefs.map((ref) => ({ ...ref }));
     });
-    __publicField$8(this, "toDeclarationCode", (name, declaration) => {
+    __publicField$9(this, "toDeclarationCode", (name, d, o) => {
+      let code = this.toDeclarationBodyCode(name, d);
+      if (o.exported) {
+        code = `export ${code}`;
+      }
+      return this.addDoc(code, d.doc);
+    });
+    __publicField$9(this, "toDeclarationBodyCode", (name, declaration) => {
       switch (declaration.kind) {
         case "typeAlias":
           return `type ${name} = ${this.typeExprCodegen.toCode(declaration.typeExpr).code}`;
         case "enum": {
-          const members = declaration.members.map(
-            (member) => `    ${member.name} = ${JSON.stringify(member.value)}`
-          ).join(",\n");
+          const members = declaration.members.map((member) => {
+            const code = `${member.name} = ${JSON.stringify(member.value)}`;
+            return this.addDoc(code, member.doc);
+          }).join(",\n");
           return `enum ${name} {
 ${members}
 }`;
@@ -4641,6 +4878,13 @@ ${members}
         }
       }
     });
+    __publicField$9(this, "addDoc", (code, doc) => {
+      if (!doc) return code;
+      const rendered = this.docRenderer.render(doc);
+      return rendered ? `${rendered}
+${code}` : code;
+    });
+    this.docRenderer = docRenderer;
   }
   collectTypeRef(typeRef) {
     if (typeRef.kind === "builtin") return;
@@ -4766,12 +5010,13 @@ const toTsPropertyKey = (value) => {
   return isTsIdentifier(value) ? value : JSON.stringify(value);
 };
 
-var __defProp$7 = Object.defineProperty;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
 class TypeExprCodegen {
-  constructor() {
-    __publicField$7(this, "toCode", (typeExpr) => {
+  constructor(docRenderer) {
+    __publicField$8(this, "docRenderer");
+    __publicField$8(this, "toCode", (typeExpr) => {
       switch (typeExpr.kind) {
         case "reference":
           return this.toReferenceCode(typeExpr);
@@ -4787,7 +5032,7 @@ class TypeExprCodegen {
         }
       }
     });
-    __publicField$7(this, "toReferenceCode", (typeExpr) => {
+    __publicField$8(this, "toReferenceCode", (typeExpr) => {
       if (!typeExpr.typeArgs?.length) {
         return {
           code: typeExpr.ref.name,
@@ -4800,7 +5045,7 @@ class TypeExprCodegen {
         ref: typeExpr.ref
       };
     });
-    __publicField$7(this, "toInlineCode", (expr) => {
+    __publicField$8(this, "toInlineCode", (expr) => {
       switch (expr.node) {
         case "scalar":
           return expr.name === "integer" ? "number" : expr.name;
@@ -4825,55 +5070,66 @@ class TypeExprCodegen {
         }
       }
     });
-    __publicField$7(this, "toIntersectionMemberCode", (typeExpr) => {
+    __publicField$8(this, "toIntersectionMemberCode", (typeExpr) => {
       const rendered = this.toCode(typeExpr).code;
       return this.isUnion(typeExpr) ? `(${rendered})` : rendered;
     });
-    __publicField$7(this, "toArrayElementCode", (typeExpr) => {
+    __publicField$8(this, "toArrayElementCode", (typeExpr) => {
       const rendered = this.toCode(typeExpr).code;
       return this.needsGroupingForArrayElement(typeExpr) ? `(${rendered})` : rendered;
     });
-    __publicField$7(this, "isUnion", (typeExpr) => {
+    __publicField$8(this, "isUnion", (typeExpr) => {
       return typeExpr.kind === "inline" && typeExpr.expr.node === "union";
     });
-    __publicField$7(this, "needsGroupingForArrayElement", (typeExpr) => {
+    __publicField$8(this, "needsGroupingForArrayElement", (typeExpr) => {
       return typeExpr.kind === "inline" && (typeExpr.expr.node === "union" || typeExpr.expr.node === "intersection");
     });
-    __publicField$7(this, "toLiteralCode", (value) => {
+    __publicField$8(this, "toLiteralCode", (value) => {
       if (value === null) return "null";
       return JSON.stringify(value);
     });
-    __publicField$7(this, "toObjectCode", (properties, additionalProperties) => {
+    __publicField$8(this, "toObjectCode", (properties, additionalProperties) => {
       const members = properties.map(
         (property) => this.toPropertyCode(property)
       );
       if (additionalProperties === true) {
-        members.push("[key: string]: unknown");
+        members.push("[key: string]: unknown;");
       } else if (additionalProperties !== void 0 && additionalProperties !== false) {
         members.push(
-          `[key: string]: ${this.toCode(additionalProperties).code}`
+          `[key: string]: ${this.toCode(additionalProperties).code};`
         );
       }
-      if (!members.length) return "{}";
-      return `{ ${members.join("; ")} }`;
+      return `{
+${members.join("\n")}
+}`;
     });
-    __publicField$7(this, "toPropertyCode", (property) => {
+    __publicField$8(this, "toPropertyCode", (property) => {
       const name = toTsPropertyKey(property.name);
       const optional = property.required ? "" : "?";
-      return `${name}${optional}: ${this.toCode(property.typeExpr).code}`;
-    });
+      const propertyCode = `${name}${optional}: ${this.toCode(property.typeExpr).code}`;
+      const docCode = property.doc ? this.docRenderer.render(property.doc, {
+        compactText: true
+      }) : "";
+      const renderedProperty = `${propertyCode};`;
+      return docCode ? `${docCode}
+${renderedProperty}` : renderedProperty;
+    });
+    this.docRenderer = docRenderer;
   }
 }
 
-var __defProp$6 = Object.defineProperty;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
 class TsCodegenFactory {
-  constructor() {
-    __publicField$6(this, "typeExprCodegen", new TypeExprCodegen());
-    __publicField$6(this, "forNewChunk", () => {
-      return new TsCodegen(this.typeExprCodegen);
-    });
+  constructor(docRenderer) {
+    __publicField$7(this, "typeExprCodegen");
+    __publicField$7(this, "docRenderer");
+    __publicField$7(this, "forNewChunk", () => {
+      return new TsCodegen(this.typeExprCodegen, this.docRenderer);
+    });
+    this.docRenderer = docRenderer;
+    this.typeExprCodegen = new TypeExprCodegen(this.docRenderer);
   }
 }
 
@@ -4922,13 +5178,13 @@ const isReservedWord = (value) => {
   return RESERVED_WORDS.has(value);
 };
 
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
 class ParamsConstructor {
   constructor(options) {
     this.options = options;
-    __publicField$5(this, "process", (params, httpPath) => {
+    __publicField$6(this, "process", (params, httpPath) => {
       const pathParamSpec = validatePathParams(params, httpPath);
       const pathParamBindings = pathParamSpec?.bindings;
       const funParams = params.flatMap(
@@ -4948,7 +5204,7 @@ class ParamsConstructor {
         hasQuery
       };
     });
-    __publicField$5(this, "renderOperationParams", (param, pathParamSpec) => {
+    __publicField$6(this, "renderOperationParams", (param, pathParamSpec) => {
       if (param.kind !== "path" || !pathParamSpec) {
         return [
           {
@@ -4972,7 +5228,7 @@ class ParamsConstructor {
         }
       ];
     });
-    __publicField$5(this, "renderPathTemplateLiteral", (path, pathParamVarName, pathParamBindings) => {
+    __publicField$6(this, "renderPathTemplateLiteral", (path, pathParamVarName, pathParamBindings) => {
       const escapedPath = path.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
       const pathWithParams = escapedPath.replace(
         /\{([^}]+)\}/g,
@@ -4986,7 +5242,7 @@ class ParamsConstructor {
       );
       return `\`${pathWithParams}\``;
     });
-    __publicField$5(this, "renderPathParamDestructuring", (pathParamBindings) => {
+    __publicField$6(this, "renderPathParamDestructuring", (pathParamBindings) => {
       const members = Object.entries(pathParamBindings).map(
         ([paramName, binding]) => {
           const key = toTsPropertyKey(paramName);
@@ -4995,7 +5251,7 @@ class ParamsConstructor {
       );
       return `{ ${members.join(", ")} }`;
     });
-    __publicField$5(this, "paramName", (p) => {
+    __publicField$6(this, "paramName", (p) => {
       switch (p.kind) {
         case "body":
           return this.options.paramNames.body;
@@ -5107,19 +5363,25 @@ const validatePathParams = (params, httpPath) => {
   };
 };
 
-const EMPTY_LINE_MARKER = "/*__EMPTY_LINE_MARKER__*/";
+const indentBlock = (value, indent) => {
+  if (!value || !indent) {
+    return value;
+  }
+  return value.split("\n").map((line) => `${indent}${line}`).join("\n");
+};
 
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
 const REQUEST_PARAMS_TYPE = "RequestParams";
 const REQUEST_PARAMS_DEFAULT = "never";
 const REQUEST_PARAMS_ARG = "params";
 class ApiClientCodegen {
-  constructor(opts, tsCodegenFactory) {
+  constructor(opts, tsCodegenFactory, docRenderer) {
     this.opts = opts;
     this.tsCodegenFactory = tsCodegenFactory;
-    __publicField$4(this, "generate", (apiName, operations) => {
+    this.docRenderer = docRenderer;
+    __publicField$5(this, "generate", (apiName, operations, doc) => {
       const tsCodegen = this.tsCodegenFactory.forNewChunk();
       const httpClientType = tsCodegen.typeExpr(this.opts.httpClient.typeName);
       let clientType = httpClientType;
@@ -5129,16 +5391,18 @@ class ApiClientCodegen {
         classTypeParams = `<${REQUEST_PARAMS_TYPE} = ${REQUEST_PARAMS_DEFAULT}>`;
       }
       const methodsCode = Array.isArray(operations) ? this.opsCode(tsCodegen, operations) : this.groupsOpsCode(tsCodegen, operations);
+      const classDocCode = this.renderApiClientDoc(doc, "");
       const code = `
-            export class ${apiName}${classTypeParams} {
-                constructor(private readonly client: ${clientType}) {}
+            ${classDocCode ? `${classDocCode}
+` : ""}export class ${apiName}${classTypeParams} {
+                constructor(private readonly http: ${clientType}) {}
 
                 ${methodsCode}
             }
         `;
       return tsCodegen.toChunk("api", code, [apiName]);
     });
-    __publicField$4(this, "groupsOpsCode", (codegen, groupedOps) => Object.entries(groupedOps).map(([groupName, ops]) => {
+    __publicField$5(this, "groupsOpsCode", (codegen, groupedOps) => Object.entries(groupedOps).map(([groupName, ops]) => {
       const methodsCode = this.opsCode(codegen, ops, "object");
       return `
                     ${toTsPropertyKey(groupName)} = {
@@ -5146,14 +5410,14 @@ class ApiClientCodegen {
                     }
                 `;
     }).join("\n\n"));
-    __publicField$4(this, "opsCode", (codegen, operations, target = "class") => {
+    __publicField$5(this, "opsCode", (codegen, operations, target = "class") => {
       const separator = target === "object" ? `,
 ${EMPTY_LINE_MARKER}
 ` : "\n\n";
       const methodsCode = operations.map((op) => this.renderOp(op, codegen, target)).join(separator);
       return methodsCode;
     });
-    __publicField$4(this, "renderOp", (op, tsCodegen, target) => {
+    __publicField$5(this, "renderOp", (op, tsCodegen, target) => {
       const { signature: sig, http } = op;
       const invocationVars = this.opts.httpClient.invocation.vars;
       const paramNames = {
@@ -5179,6 +5443,7 @@ ${EMPTY_LINE_MARKER}
       const responseType = tsCodegen.typeExpr(sig.returnType);
       const returnType = this.wrapInResponseWrapper(sig.returnType, tsCodegen);
       return this.renderFunctionCode({
+        doc: sig.doc,
         funName: sig.name,
         responseType,
         returnType,
@@ -5194,13 +5459,14 @@ ${EMPTY_LINE_MARKER}
         target
       });
     });
-    __publicField$4(this, "wrapInResponseWrapper", (typeExpr, tsCodegen) => {
+    __publicField$5(this, "wrapInResponseWrapper", (typeExpr, tsCodegen) => {
       return tsCodegen.typeExpr({
         ...this.opts.httpClient.responseWrapper,
         typeArgs: [typeExpr]
       });
     });
-    __publicField$4(this, "renderFunctionCode", ({
+    __publicField$5(this, "renderFunctionCode", ({
+      doc,
       funName,
       responseType,
       returnType,
@@ -5232,9 +5498,74 @@ ${EMPTY_LINE_MARKER}
       invocation = invocation.replaceAll("\n", "");
       const operator = target === "object" ? ":" : "=";
       const returnTypeCode = this.opts.httpClient.inferMethodReturnType ? "" : `:${returnType}`;
-      return `${funName} ${operator} (${params})${returnTypeCode} => 
-             this.client${invocation}
+      const functionCode = `${funName} ${operator} (${params})${returnTypeCode} => 
+             this.http${invocation}
         `;
+      const docCode = this.renderOperationDoc(
+        doc,
+        this.opts.comments,
+        target === "object" ? "        " : "    "
+      );
+      return docCode ? `${docCode}
+${functionCode}` : functionCode;
+    });
+    __publicField$5(this, "renderOperationDoc", (doc, comments, indent = "") => {
+      if (!doc) return null;
+      return indentBlock(this.docRenderer.render(this.toTsDoc(doc)), indent);
+    });
+    __publicField$5(this, "renderApiClientDoc", (doc, indent = "") => {
+      if (!doc) return "";
+      return indentBlock(
+        this.docRenderer.render({
+          nodes: [
+            {
+              key: "title",
+              value: doc.title
+            },
+            {
+              key: "version",
+              value: doc.version
+            },
+            ...doc.description ? [doc.description] : []
+          ]
+        }),
+        indent
+      );
+    });
+    __publicField$5(this, "toTsDoc", (doc) => {
+      const nodes = [
+        {
+          key: "id",
+          value: doc.id
+        }
+      ];
+      const comms = this.opts.comments;
+      if ((comms.summary ?? true) && doc.summary) {
+        nodes.push({
+          key: "summary",
+          value: doc.summary
+        });
+      }
+      if ((comms.description ?? true) && doc.description) {
+        nodes.push({
+          key: "description",
+          value: doc.description
+        });
+      }
+      nodes.push({
+        key: "request",
+        value: doc.request
+      });
+      if ((comms.tags ?? true) && doc.tags.length) {
+        nodes.push({
+          key: "tags",
+          value: doc.tags.join(", ")
+        });
+      }
+      return {
+        deprecated: doc.deprecated,
+        nodes
+      };
     });
   }
 }
@@ -5403,21 +5734,102 @@ const provideHttpClientCode = (gen, opts) => gen.toChunk(
   ["HttpRequest", "HttpResponse", "HttpClient"]
 );
 
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+class TsDocRenderer {
+  constructor(options) {
+    this.options = options;
+    __publicField$4(this, "render", (doc, options = {}) => {
+      if (!this.options.enabled) return "";
+      const lines = [];
+      this.appendNodes(lines, doc.nodes, options);
+      if (doc.deprecated) {
+        this.appendDeprecated(lines, { separate: lines.length > 0 });
+      }
+      return this.renderComment(lines);
+    });
+    __publicField$4(this, "renderComment", (lines) => {
+      if (!this.options.enabled) return "";
+      if (!lines.length) return "";
+      if (lines.length === 1) {
+        return `/** ${lines[0]} */`;
+      }
+      const body = lines.map((line) => line ? ` * ${line}` : " *").join("\n");
+      return `/**
+${body}
+ */`;
+    });
+    __publicField$4(this, "appendDocText", (lines, value) => {
+      const normalized = this.normalizeLines(value);
+      if (!normalized.length) return;
+      if (lines.length > 0) {
+        lines.push("");
+      }
+      lines.push(...normalized);
+    });
+    __publicField$4(this, "appendField", (lines, key, value) => {
+      const normalized = this.normalizeLines(value);
+      if (!normalized.length) return;
+      lines.push(`@${key} ${normalized[0]}`.trimEnd());
+      lines.push(...normalized.slice(1));
+    });
+    __publicField$4(this, "appendDeprecated", (lines, options) => {
+      if (options.separate) {
+        lines.push("");
+      }
+      lines.push("@deprecated");
+    });
+    __publicField$4(this, "appendNodes", (lines, nodes = [], options = {}) => {
+      nodes.forEach((node) => {
+        if (typeof node === "string") {
+          if (options.compactText) {
+            lines.push(...this.normalizeNonEmptyLines(node));
+            return;
+          }
+          this.appendDocText(lines, node);
+          return;
+        }
+        this.appendField(lines, node.key, node.value);
+      });
+    });
+    __publicField$4(this, "normalizeLines", (value) => {
+      const trimmed = value?.trim();
+      if (!trimmed) return [];
+      return trimmed.split(/\r?\n/u).map((line) => line.trimEnd().replaceAll("*/", "*\\/"));
+    });
+    __publicField$4(this, "normalizeNonEmptyLines", (value) => this.normalizeLines(value).filter((line) => line.length > 0));
+  }
+}
+
 const generateTsCode = (clientName, projectResult, opts) => {
-  const tsCodegenFac = new TsCodegenFactory();
+  const docRenderer = new TsDocRenderer({
+    enabled: opts.comments.enabled
+  });
+  const tsCodegenFac = new TsCodegenFactory(docRenderer);
   const { schemaDefinitions } = projectResult;
   const types = [...schemaDefinitions].sort((a, b) => a.name.localeCompare(b.name)).map((def) => {
     const cg = tsCodegenFac.forNewChunk();
-    const code = `export ${cg.declaration(def.name, def.declaration)}`;
+    const code = cg.declaration(def.name, def.declaration, {
+      exported: true
+    });
     return cg.toChunk(def.name, code, [def.name]);
   });
   const clientCodegen = new ApiClientCodegen(
-    { httpClient: promiseHttpClientCodegenSpec(), ...opts },
-    tsCodegenFac
+    {
+      httpClient: promiseHttpClientCodegenSpec(),
+      comments: opts.comments.operation,
+      unwrap: opts.unwrap,
+      pathParamsStyle: opts.pathParamsStyle,
+      withRequestParams: opts.withRequestParams
+    },
+    tsCodegenFac,
+    docRenderer
   );
   const generated = clientCodegen.generate(
     clientName,
-    groupsOpsByTag(projectResult.operations)
+    groupsOpsByTag(projectResult.operations),
+    projectResult.api
   );
   const clientChunk = {
     ...generated,
@@ -5627,6 +6039,7 @@ class ToTypeExprConverter {
       }
       return {
         kind: "typeAlias",
+        doc: this.getSchemaDoc(schema),
         typeExpr: this.fromTypeExpr(schema)
       };
     });
@@ -5640,6 +6053,7 @@ class ToTypeExprConverter {
       }
       return {
         kind: "enum",
+        doc: this.getSchemaDoc(schema),
         valueType,
         members: this.toEnumMembers(schema.enum)
       };
@@ -5755,6 +6169,7 @@ class ToTypeExprConverter {
             );
           }
           return {
+            doc: this.getSchemaDoc(propertySchema),
             name,
             required: this.isRequiredProperty(
               name,
@@ -5815,6 +6230,71 @@ class ToTypeExprConverter {
     __publicField$3(this, "isBinaryFileSchema", (schema) => {
       return schema.type === "string" && schema.format === "binary";
     });
+    __publicField$3(this, "getSchemaDoc", (schema) => {
+      const summary = typeof schema.summary === "string" ? schema.summary : void 0;
+      const description = typeof schema.description === "string" ? schema.description : void 0;
+      const deprecated = typeof schema.deprecated === "boolean" ? schema.deprecated : void 0;
+      const annotations = this.getSchemaAnnotations(schema);
+      if (!summary && !description && !deprecated && !annotations.length) {
+        return void 0;
+      }
+      const nodes = [];
+      if (summary) {
+        nodes.push(summary);
+      }
+      if (description) {
+        nodes.push(description);
+      }
+      nodes.push(...annotations);
+      return {
+        deprecated,
+        nodes
+      };
+    });
+    __publicField$3(this, "getSchemaAnnotations", (schema) => {
+      if (this.options.comments?.metadata === false) return [];
+      return [
+        this.annotationNode("format", schema.format),
+        this.annotationNode("min", schema.minimum),
+        this.annotationNode("multipleOf", schema.multipleOf),
+        this.annotationNode("exclusiveMin", schema.exclusiveMinimum),
+        this.annotationNode("max", schema.maximum),
+        this.annotationNode("minLength", schema.minLength),
+        this.annotationNode("maxLength", schema.maxLength),
+        this.annotationNode("exclusiveMax", schema.exclusiveMaximum),
+        this.annotationNode("maxItems", schema.maxItems),
+        this.annotationNode("minItems", schema.minItems),
+        this.annotationNode("uniqueItems", schema.uniqueItems),
+        this.annotationNode(
+          "default",
+          this.stringifyAnnotationValue(schema.default)
+        ),
+        this.annotationNode("pattern", schema.pattern),
+        this.annotationNode(
+          "example",
+          this.stringifyAnnotationValue(schema.example)
+        )
+      ].filter(
+        (value) => value !== void 0
+      );
+    });
+    __publicField$3(this, "annotationNode", (name, value) => {
+      if (value === void 0) return void 0;
+      return {
+        key: name,
+        value: String(value)
+      };
+    });
+    __publicField$3(this, "stringifyAnnotationValue", (value) => {
+      if (value === void 0) return void 0;
+      if (value && typeof value === "object") {
+        return JSON.stringify(value);
+      }
+      if (typeof value === "string") {
+        return JSON.stringify(value);
+      }
+      return String(value);
+    });
     __publicField$3(this, "fromSchemaCore", (schema) => {
       if (this.isUnconstrainedSchema(schema)) {
         return this.scalar("unknown");
@@ -6001,6 +6481,11 @@ class OperationProjector {
         return this.projectOne(operationName, operation);
       });
       return {
+        api: {
+          title: openApi.info.title,
+          version: openApi.info.version,
+          description: openApi.info.description
+        },
         operations,
         schemaDefinitions: this.typeExprConverter.getSchemaDefinitions()
       };
@@ -6017,6 +6502,7 @@ class OperationProjector {
       return {
         op: {
           signature: {
+            doc: this.toOperationDoc(operationName, operation),
             name: operationName,
             parameters,
             returnType: this.projectReturnType(operation)
@@ -6065,6 +6551,7 @@ class OperationProjector {
     });
     __publicField$2(this, "projectParameterGroupTypeExpr", (params) => {
       const properties = Object.entries(params).map(([name, parameter]) => ({
+        doc: this.toParameterDoc(parameter),
         name,
         required: parameter.required,
         typeExpr: this.typeExprConverter.fromTypeExpr(
@@ -6137,45 +6624,38 @@ class OperationProjector {
     __publicField$2(this, "selectResponseSchema", (response) => {
       return getPreferredMediaTypeEntry(response.content).media?.schema;
     });
+    __publicField$2(this, "toParameterDoc", (parameter) => {
+      if (!parameter.description && !parameter.deprecated) {
+        return void 0;
+      }
+      return {
+        deprecated: parameter.deprecated,
+        nodes: parameter.description ? [parameter.description] : []
+      };
+    });
+    __publicField$2(this, "toOperationDoc", (operationName, operation) => {
+      return {
+        id: operationName,
+        request: `${toHttpMethodUpper(operation.method)}:${operation.path}`,
+        summary: operation.summary,
+        description: operation.description,
+        deprecated: operation.deprecated,
+        tags: operation.tags.map((tag) => tag.trim()).filter(Boolean)
+      };
+    });
   }
 }
 
 var __defProp$1 = Object.defineProperty;
 var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
-const EMPTY_LINE_MARKER_LINE = new RegExp(
-  `\\n[\\t ]*${EMPTY_LINE_MARKER.replaceAll("/", "\\/").replaceAll(
-    "*",
-    "\\*"
-  )}\\n`,
-  "g"
-);
-class CodeFormatter {
-  constructor(opts) {
-    this.opts = opts;
-    __publicField$1(this, "format", async (code) => {
-      const filePath = Path$1.resolve(this.opts.resolveConfFrom, "generated.ts");
-      const prettier = await import('prettier');
-      const prettierConfig = await prettier.resolveConfig(filePath) ?? {};
-      const formattedCode = await prettier.format(code, {
-        ...prettierConfig,
-        filepath: filePath
-      });
-      return formattedCode.replaceAll(EMPTY_LINE_MARKER_LINE, "\n\n");
-    });
-  }
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
 class CodeWriter {
   constructor(formatter) {
     this.formatter = formatter;
-    __publicField(this, "symbolChunkMap", /* @__PURE__ */ new Map());
-    __publicField(this, "write", async (dir, chunks) => {
+    __publicField$1(this, "symbolChunkMap", /* @__PURE__ */ new Map());
+    __publicField$1(this, "write", async (dir, chunks) => {
       this.symbolChunkMap = this.createSymbolChunkMap(chunks);
-      fs$2.mkdirSync(dir, { recursive: true });
+      fs__default.mkdirSync(dir, { recursive: true });
       for (const chunk of chunks) {
         const imports = this.collectImports(chunk);
         const importStatements = this.genImportStatements(imports);
@@ -6185,10 +6665,10 @@ class CodeWriter {
         let code = importCode + chunk.code;
         code = await this.formatter.format(code);
         code = ensureSingleTrailingNewline(code);
-        fs$2.writeFileSync(`${dir}/${chunk.name}.ts`, code, "utf8");
+        fs__default.writeFileSync(`${dir}/${chunk.name}.ts`, code, "utf8");
       }
     });
-    __publicField(this, "createSymbolChunkMap", (chunks) => {
+    __publicField$1(this, "createSymbolChunkMap", (chunks) => {
       const map = /* @__PURE__ */ new Map();
       for (const chunk of chunks) {
         for (const exportedSymbol of chunk.exports) {
@@ -6202,7 +6682,7 @@ class CodeWriter {
       }
       return map;
     });
-    __publicField(this, "collectImports", (chunk) => {
+    __publicField$1(this, "collectImports", (chunk) => {
       const imports = [];
       for (const ref of chunk.refs) {
         if (ref.kind === "builtin") continue;
@@ -6225,7 +6705,7 @@ class CodeWriter {
       }
       return imports;
     });
-    __publicField(this, "genImportStatements", (imports) => {
+    __publicField$1(this, "genImportStatements", (imports) => {
       const symbolsBySource = groupBy(
         imports.map((i) => ({
           name: i.name,
@@ -6238,7 +6718,7 @@ class CodeWriter {
         return `import type { ${sortedSymbols.join(", ")} } from '${source}'`;
       });
     });
-    __publicField(this, "importSourcetoString", (src) => {
+    __publicField$1(this, "importSourcetoString", (src) => {
       return "externalModule" in src ? src.externalModule : (
         // TODO generalize later when we have different paths
         `./${src.name}`
@@ -6253,7 +6733,7 @@ class VNextOasClientGenerator {
     this.options = options;
     this.log = log;
   }
-  async generate(cmd) {
+  async generate(cmd, formatter) {
     const { inputFile, outputDir, apiName } = cmd;
     this.log(`Will generate API client name=${apiName} to ${outputDir}`);
     const sourceSchema = await loadSourceSchema(inputFile);
@@ -6262,6 +6742,7 @@ class VNextOasClientGenerator {
     const projectResult = new OperationProjector({
       includeAllSchema: this.options.selection?.allSchemas === true,
       typeExtraction: {
+        comments: this.options.codegen.comments.schema,
         enumStyle: this.options.codegen.enumStyle,
         uppercaseEnumKeys: this.options.compat?.uppercaseEnumKeys,
         swaggerTsApiRequiredBooleans: this.options.compat?.swaggerTsApiRequiredBooleans
@@ -6273,12 +6754,9 @@ class VNextOasClientGenerator {
       projectResult,
       this.options.codegen
     );
-    const codeFormatter = new CodeFormatter({
-      resolveConfFrom: outputDir
-    });
-    const writer = new CodeWriter(codeFormatter);
+    const writer = new CodeWriter(formatter);
     await writer.write(outputDir, chunks.all);
-    const tsFilePath = (name) => Path.join(outputDir, `${name}.ts`);
+    const tsFilePath = (name) => Path$1.join(outputDir, `${name}.ts`);
     return {
       promiseWrapper: chunks.promiseWrappersNames.map(tsFilePath),
       types: tsFilePath(chunks.typesName)
@@ -6344,7 +6822,7 @@ const toErrorMessage = (error) => {
   return error instanceof Error ? error.message : String(error);
 };
 
-const generateOpenApiModel = async (spectPath, config, log) => {
+const generateOpenApiModel = async (spectPath, config, log, codeFormatter) => {
   let outFiles;
   const { openApiGenerator, responseWrapper } = config;
   if ("legacy" in openApiGenerator) {
@@ -6361,11 +6839,14 @@ const generateOpenApiModel = async (spectPath, config, log) => {
     outFiles = await new VNextOasClientGenerator(
       openApiGenerator,
       log
-    ).generate({
-      inputFile: spectPath,
-      apiName: config.apiName,
-      outputDir: config.dstDir
-    });
+    ).generate(
+      {
+        inputFile: spectPath,
+        apiName: config.apiName,
+        outputDir: config.dstDir
+      },
+      codeFormatter
+    );
   }
   if (responseWrapper) {
     await modifyHttpClientAsyncWrapper(
@@ -6454,46 +6935,51 @@ const findMatchingBrace = (code, openBraceIndex) => {
   return -1;
 };
 
-const generateSchemas = async (inputFile, outputFile, opts = {}) => {
-  const code = fs__default.readFileSync(inputFile).toString();
-  const { getZodSchemasFile } = generate({
-    sourceText: removeGenericTypes(code)
-  });
-  let f = getZodSchemasFile(getModuleImportPath(inputFile, outputFile));
-  f = f.replaceAll(".optional()", ".nullable()");
-  if (opts.localDateTimes) {
-    f = f.replaceAll(
-      "z.string().datetime()",
-      "z.string().datetime({local: true})"
-    );
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+class ZodSchemaGenerator {
+  constructor(codeFormatter) {
+    this.codeFormatter = codeFormatter;
+    __publicField(this, "generate", async ({
+      sourceText,
+      moduleImportPath,
+      options = {}
+    }) => {
+      const { getZodSchemasFile } = generate({
+        sourceText: removeGenericTypes(sourceText)
+      });
+      let generated = getZodSchemasFile(moduleImportPath);
+      generated = generated.replaceAll(".optional()", ".nullable()");
+      generated = generated.replaceAll(".int64()", ".int()");
+      if (options.localDateTimes) {
+        generated = generated.replaceAll(
+          "z.string().datetime()",
+          "z.string().datetime({local: true})"
+        );
+      }
+      return this.codeFormatter.format(generated);
+    });
   }
-  const prettier = await import('prettier');
-  const prettierConfig = await prettier.resolveConfig(outputFile) ?? {};
-  const formatted = await prettier.format(f, {
-    ...prettierConfig,
-    filepath: outputFile
-  });
-  fs__default.writeFileSync(outputFile, formatted);
-};
-const getModuleImportPath = (inputFile, outputFile) => {
-  const sourceDir = Path.dirname(outputFile);
-  const relativePath = Path.relative(sourceDir, inputFile);
-  const withoutExtension = relativePath.replace(/\.ts$/u, "");
-  const normalizedPath = withoutExtension.split(Path.sep).join("/");
-  return normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
-};
+}
 
 const generateApiClient = async (params, configFilePath, log = console.log) => {
-  const config = parseConfig(params, configFilePath);
+  const config = parseProfileConfig(params, configFilePath);
+  return generateApiClientFromConfig(config, log);
+};
+const generateApiClientFromConfig = async (config, log = console.log) => {
   const { dstDir, apiName, srcSpec, zodSchemas } = config;
-  const dir = Path.resolve(dstDir, apiName);
+  const dir = Path$1.resolve(dstDir, apiName);
   if (!fs.existsSync(dir)) {
     log(`Creating dir ${dir}`);
     fs.mkdirSync(dir, {
       recursive: true
     });
   }
-  const clientDir = Path.resolve(dir, "client");
+  const clientDir = Path$1.resolve(dir, "client");
+  const formatter = new CodeFormatter({
+    resolveConfFrom: dir
+  });
   const specPath = await getSpecPath(srcSpec, dir, log);
   log(`Cleaning client output dir ${clientDir}`);
   fs.rmSync(clientDir, {
@@ -6509,15 +6995,20 @@ const generateApiClient = async (params, configFilePath, log = console.log) => {
       ...config,
       dstDir: clientDir
     },
-    log
+    log,
+    formatter
   );
   if (zodSchemas?.enabled === false) return;
   log("Generating Zod schemas");
-  await generateSchemas(
-    typesFilePath,
-    Path.resolve(dir, "./zod.ts"),
-    zodSchemas
-  );
+  const zodOutputFile = Path$1.resolve(dir, "./zod.ts");
+  const generator = new ZodSchemaGenerator(formatter);
+  const sourceText = fs.readFileSync(typesFilePath, "utf8");
+  const generated = await generator.generate({
+    sourceText,
+    moduleImportPath: findRelativePath(zodOutputFile, typesFilePath),
+    options: zodSchemas
+  });
+  fs.writeFileSync(zodOutputFile, generated);
 };
 const getSpecPath = async (urlOrPath, dir, log) => {
   if (!urlOrPath.startsWith("http")) {
@@ -6525,10 +7016,10 @@ const getSpecPath = async (urlOrPath, dir, log) => {
       throw new Error(`Spec file ${urlOrPath} does not exists`);
     return urlOrPath;
   }
-  const specPath = Path.resolve(dir, `spec.json`);
+  const specPath = Path$1.resolve(dir, `spec.json`);
   log(`Will download the API spec from ${urlOrPath} to ${specPath}`);
   await downloadSpec(specPath, urlOrPath);
   return specPath;
 };
 
-export { generateApiClient as g };
+export { generateApiClientFromConfig as a, defineConfig as d, generateApiClient as g, parseConfig as p };