@ps-aux/api-client-gen 0.7.0-rc.2 → 0.7.0-rc.4

package/dist/generateApiClient.mjs

@@ -1,12 +1,12 @@
-import Path$1 from 'path';
+import Path from 'path';
 import * as fs from 'fs';
-import fs__default from 'fs';
+import fs__default$1 from 'fs';
 import fs$1 from 'fs/promises';
-import Path from 'node:path';
-import { readFile } from 'node:fs/promises';
-import fs$2 from 'node:fs';
 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__default from 'node:fs';
 import { generate } from 'ts-to-zod';
 
 /** A special constant with type `never` */
@@ -551,69 +551,6 @@ function formatError(error, mapper = (issue) => issue.message) {
     processError(error);
     return fieldErrors;
 }
-/** Format a ZodError as a human-readable string in the following form.
- *
- * From
- *
- * ```ts
- * ZodError {
- *   issues: [
- *     {
- *       expected: 'string',
- *       code: 'invalid_type',
- *       path: [ 'username' ],
- *       message: 'Invalid input: expected string'
- *     },
- *     {
- *       expected: 'number',
- *       code: 'invalid_type',
- *       path: [ 'favoriteNumbers', 1 ],
- *       message: 'Invalid input: expected number'
- *     }
- *   ];
- * }
- * ```
- *
- * to
- *
- * ```
- * username
- *   ✖ Expected number, received string at "username
- * favoriteNumbers[0]
- *   ✖ Invalid input: expected number
- * ```
- */
-function toDotPath(_path) {
-    const segs = [];
-    const path = _path.map((seg) => (typeof seg === "object" ? seg.key : seg));
-    for (const seg of path) {
-        if (typeof seg === "number")
-            segs.push(`[${seg}]`);
-        else if (typeof seg === "symbol")
-            segs.push(`[${JSON.stringify(String(seg))}]`);
-        else if (/[^\w$]/.test(seg))
-            segs.push(`[${JSON.stringify(seg)}]`);
-        else {
-            if (segs.length)
-                segs.push(".");
-            segs.push(seg);
-        }
-    }
-    return segs.join("");
-}
-function prettifyError(error) {
-    const lines = [];
-    // sort by path length
-    const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
-    // Process each issue
-    for (const issue of issues) {
-        lines.push(`✖ ${issue.message}`);
-        if (issue.path?.length)
-            lines.push(`  → at ${toDotPath(issue.path)}`);
-    }
-    // Convert Map to formatted string
-    return lines.join("\n");
-}
 
 const _parse = (_Err) => (schema, value, _ctx, _params) => {
     const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
@@ -764,6 +701,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]*$/;
@@ -1960,6 +1898,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);
@@ -3356,6 +3410,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);
@@ -3859,6 +3956,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);
@@ -4082,6 +4194,73 @@ function superRefine(fn) {
     return _superRefine(fn);
 }
 
+const vNextOasGeneratorSchema = strictObject({
+  selection: strictObject({
+    ignoreOperationsWithTags: array(string()).default([]),
+    allSchemas: boolean().default(true)
+  }).optional(),
+  codegen: strictObject({
+    unwrap: boolean().default(true),
+    withRequestParams: boolean().default(false),
+    pathParamsStyle: _enum(["object", "positional"]).default("positional"),
+    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()
+  }).optional()
+});
+const legacyOasGeneratorSchema = strictObject({
+  legacy: strictObject({
+    ignoreOperationsWithTags: array(string()).optional()
+  })
+});
+const profileConfigSchema = strictObject({
+  srcSpec: string().trim().min(1),
+  dstDir: string().trim().min(1),
+  apiName: string().trim().min(1),
+  openApiGenerator: union([
+    vNextOasGeneratorSchema,
+    legacyOasGeneratorSchema
+  ]),
+  responseWrapper: strictObject({
+    symbol: string().trim().min(1),
+    import: string().trim().min(1).optional(),
+    unwrapExpr: string().optional()
+  }).optional(),
+  zodSchemas: strictObject({
+    enabled: boolean().optional(),
+    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;
+  throw new Error(`Invalid config at ${filePath}: ${parsed.error.message}`, {
+    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;
   try {
@@ -4101,6 +4280,86 @@ const downloadSpec = async (path, url) => {
   await fs$1.writeFile(path, content);
 };
 
+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("");
+  if (!pascalCase.length) return "Api";
+  if (/^[0-9]/.test(pascalCase)) return `Api${pascalCase}`;
+  return pascalCase;
+};
+const groupBy = (values, getKey) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const key = getKey(value);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(value);
+    } else {
+      groups.set(key, [value]);
+    }
+  }
+  return groups;
+};
+
+const generateOpenApiClient = async (inputFile, {
+  name,
+  outputDir,
+  ignoreOperationsWithTags
+}, log) => {
+  log(`Will generate API client name=${name} to ${outputDir}`);
+  const fileName = "index";
+  const dstFile = Path.join(outputDir, `${fileName}.ts`);
+  const prettier = await import('prettier');
+  const prettierConfig = await prettier.resolveConfig(dstFile) ?? {};
+  const prettierConfigForGenerator = {
+    ...prettierConfig,
+    // swagger-typescript-api defaults to printWidth=120; keep Prettier default 80 unless explicitly configured.
+    printWidth: prettierConfig.printWidth ?? 80
+  };
+  const ignoreTags = ignoreOperationsWithTags && new Set(ignoreOperationsWithTags);
+  await generateApi({
+    name: "index",
+    output: outputDir,
+    input: inputFile,
+    // modular: true,
+    httpClientType: "axios",
+    templates: getTemplatesDir(),
+    defaultResponseAsSuccess: true,
+    sortTypes: true,
+    // generateRouteTypes: true,
+    singleHttpClient: true,
+    // extractRequestBody: true,
+    prettier: prettierConfigForGenerator,
+    moduleNameFirstTag: true,
+    apiClassName: toPascalCaseIdentifier(name),
+    hooks: {
+      onCreateRoute: (routeData) => {
+        if (ignoreTags) {
+          const ignore = routeData.raw.tags?.find(
+            (t) => ignoreTags.has(t)
+          );
+          if (ignore) return false;
+        }
+        return routeData;
+      }
+    },
+    // @ts-ignore
+    codeGenConstructs: () => ({
+      Keyword: {}
+    })
+    // extractRequestParams: true,
+  });
+  return { types: dstFile, promiseWrapper: [dstFile] };
+};
+const getThisScriptDirname = () => {
+  return Path.dirname(fileURLToPath(import.meta.url));
+};
+const getTemplatesDir = () => {
+  const currentDir = getThisScriptDirname();
+  const templatesRelativePath = Path.basename(currentDir) === "dist" ? "../templates" : "../../../templates";
+  return Path.resolve(currentDir, templatesRelativePath);
+};
+
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const asRecord = (value) => {
   return isRecord(value) ? value : void 0;
@@ -4155,9 +4414,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",
@@ -4183,7 +4442,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");
@@ -4526,44 +4785,24 @@ const syntheticOperationId = (method, path) => {
   return `_${compact}`;
 };
 
-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("");
-  if (!pascalCase.length) return "Api";
-  if (/^[0-9]/.test(pascalCase)) return `Api${pascalCase}`;
-  return pascalCase;
-};
-const groupBy = (values, getKey) => {
-  const groups = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const key = getKey(value);
-    const existing = groups.get(key);
-    if (existing) {
-      existing.push(value);
-    } else {
-      groups.set(key, [value]);
-    }
-  }
-  return groups;
-};
-
-var httpClientCommonTypesSource = "export type KnownRequestContentType =\n    | 'application/json'\n    | 'multipart/form-data'\n    | 'application/x-www-form-urlencoded'\n\nexport type RequestContentType = KnownRequestContentType | string\n\nexport type QueryValue =\n    | string\n    | number\n    | boolean\n    | null\n    | undefined\n    | QueryValue[]\n    | Record<string, any>\n    // Empty schema support\n    | unknown\n\nexport type QueryParams = Record<string, QueryValue>\n\nexport type Request = {\n    path: string\n    method: 'GET' | 'POST' | 'PUT' | 'DELETE'\n    format?: 'json' | 'document'\n    headers?: Record<string, string>\n    query?: QueryParams\n    body?: any\n    requestContentType?: RequestContentType\n}\n\nexport type QuerySerializer = (params: QueryParams) => string\n";
-
-var httpClientPromiseTypesSource = "import type { Request } from './common-types'\n\nexport type HttpClient<RequestParams = never> = {\n    request: <Data>(req: Request, params?: RequestParams) => Promise<Data>\n}\n";
-
-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, "toCode", (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, "toChunk", (name, code, exports$1) => {
+    __publicField$9(this, "declaration", (name, declaration, options = {}) => {
+      this.collectTypeRefsFromDeclaration(declaration);
+      return this.toDeclarationCode(name, declaration, options);
+    });
+    __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);
@@ -4575,9 +4814,44 @@ class TsCodegen {
         refs
       };
     });
-    __publicField$8(this, "getTypeRefs", () => {
+    __publicField$9(this, "getTypeRefs", () => {
       return this.usedTypeRefs.map((ref) => ({ ...ref }));
     });
+    __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) => {
+            const code = `${member.name} = ${JSON.stringify(member.value)}`;
+            return this.addDoc(code, member.doc);
+          }).join(",\n");
+          return `enum ${name} {
+${members}
+}`;
+        }
+        default: {
+          const exhaustive = declaration;
+          throw new Error(
+            `Unsupported TypeScript declaration: ${String(exhaustive)}`
+          );
+        }
+      }
+    });
+    __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;
@@ -4586,6 +4860,11 @@ class TsCodegen {
     this.usedTypeRefKeys.add(key);
     this.usedTypeRefs.push({ ...typeRef });
   }
+  collectTypeRefsFromDeclaration(declaration) {
+    if (declaration.kind === "typeAlias") {
+      this.collectTypeRefsFromExpr(declaration.typeExpr);
+    }
+  }
   collectTypeRefsFromExpr(typeExpr) {
     if (typeExpr.kind === "reference") {
       this.collectTypeRef(typeExpr.ref);
@@ -4666,20 +4945,45 @@ const RESERVED_WORDS = /* @__PURE__ */ new Set([
   "with",
   "yield"
 ]);
-const TS_IDENTIFIER_PATTERN = /^[$A-Z_][0-9A-Z_$]*$/i;
+const TS_IDENTIFIER_PATTERN$1 = /^[$A-Z_][0-9A-Z_$]*$/i;
 const isTsIdentifier = (value) => {
-  return TS_IDENTIFIER_PATTERN.test(value);
+  return TS_IDENTIFIER_PATTERN$1.test(value);
+};
+const splitIdentifierWords = (value) => {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).filter(Boolean);
+};
+const toTsCamelIdentifier = (value, opts = {}) => {
+  const words = splitIdentifierWords(value);
+  if (!words.length) {
+    throw new Error(
+      `Could not derive a TypeScript identifier from "${value}".`
+    );
+  }
+  const [firstWord, ...restWords] = words;
+  let identifier = [
+    firstWord[0].toLowerCase() + firstWord.substring(1),
+    ...restWords.map((word) => word[0].toUpperCase() + word.substring(1))
+  ].join("");
+  if (/^[0-9]/.test(identifier)) {
+    const prefix = opts.leadingDigitPrefix ?? "value";
+    identifier = `${prefix}${identifier[0].toUpperCase()}${identifier.substring(1)}`;
+  }
+  if (RESERVED_WORDS.has(identifier)) {
+    identifier = `${identifier}_`;
+  }
+  return identifier;
 };
 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);
@@ -4695,7 +4999,7 @@ class TypeExprCodegen {
         }
       }
     });
-    __publicField$7(this, "toReferenceCode", (typeExpr) => {
+    __publicField$8(this, "toReferenceCode", (typeExpr) => {
       if (!typeExpr.typeArgs?.length) {
         return {
           code: typeExpr.ref.name,
@@ -4708,7 +5012,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;
@@ -4733,1054 +5037,1583 @@ 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);
   }
 }
 
-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);
-class ToTypeExprConverter {
-  constructor(schemas = {}, options = {}) {
-    this.schemas = schemas;
-    this.options = options;
-    __publicField$5(this, "schemaCache", /* @__PURE__ */ new WeakMap());
-    __publicField$5(this, "refCache", /* @__PURE__ */ new Map());
-    __publicField$5(this, "schemaDefinitions", []);
-    __publicField$5(this, "schemaDefinitionsById", /* @__PURE__ */ new Map());
-    __publicField$5(this, "schemaDefinitionsInProgress", /* @__PURE__ */ new Set());
-    __publicField$5(this, "getSchemaDefinitions", () => {
-      return this.schemaDefinitions.map((definition) => ({
-        ...definition
-      }));
-    });
-    __publicField$5(this, "fromSchema", (schema) => {
-      if (!schema) {
-        return this.scalar("unknown");
-      }
-      const bySchema = this.schemaCache.get(schema);
-      if (bySchema) {
-        return bySchema;
-      }
-      if (typeof schema.$ref === "string") {
-        const byRef = this.refCache.get(this.refCacheKey(schema));
-        if (byRef) {
-          this.schemaCache.set(schema, byRef);
-          return byRef;
-        }
-      }
-      const projected = this.fromSchemaCore(schema);
-      const result = schema.nullable === true ? this.withNullable(projected) : projected;
-      this.schemaCache.set(schema, result);
-      if (typeof schema.$ref === "string") {
-        this.refCache.set(this.refCacheKey(schema), result);
-      }
-      return result;
-    });
-    __publicField$5(this, "scalar", (name) => ({
-      kind: "inline",
-      expr: {
-        node: "scalar",
-        name
-      }
-    }));
-    __publicField$5(this, "union", (members) => {
-      const flatMembers = [];
-      for (const member of members) {
-        if (member.kind === "inline" && member.expr.node === "union") {
-          flatMembers.push(...member.expr.members);
-        } else {
-          flatMembers.push(member);
-        }
-      }
-      if (flatMembers.length === 1) {
-        return flatMembers[0];
-      }
-      return {
-        kind: "inline",
-        expr: {
-          node: "union",
-          members: flatMembers
-        }
-      };
-    });
-    __publicField$5(this, "literal", (value) => ({
-      kind: "inline",
-      expr: {
-        node: "literal",
-        value
-      }
-    }));
-    __publicField$5(this, "ref", (id) => {
-      const name = this.refNameFromPath(id);
+const buildPathParamBindings = (paramNames) => {
+  const usedBindings = /* @__PURE__ */ new Set();
+  return paramNames.reduce((acc, paramName) => {
+    acc[paramName] = toUniqueBindingName(paramName, usedBindings);
+    return acc;
+  }, {});
+};
+const toUniqueBindingName = (paramName, usedBindings) => {
+  let base = toBindingBase(paramName);
+  if (isReservedWord(base)) {
+    base = `${base}_param`;
+  }
+  if (!usedBindings.has(base)) {
+    usedBindings.add(base);
+    return base;
+  }
+  let suffix = 2;
+  let candidate = `${base}_${suffix}`;
+  while (usedBindings.has(candidate)) {
+    suffix += 1;
+    candidate = `${base}_${suffix}`;
+  }
+  usedBindings.add(candidate);
+  return candidate;
+};
+const toBindingBase = (paramName) => {
+  if (isIdentifier(paramName)) {
+    return paramName;
+  }
+  const sanitized = paramName.replace(/[^0-9A-Za-z_$]/g, "_");
+  if (!sanitized.length) {
+    return "pathParam";
+  }
+  if (/^[A-Za-z_$]/.test(sanitized)) {
+    return sanitized;
+  }
+  return `_${sanitized}`;
+};
+const isIdentifier = (value) => {
+  return /^[$A-Z_][0-9A-Z_$]*$/i.test(value);
+};
+const isReservedWord = (value) => {
+  return RESERVED_WORDS.has(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$6(this, "process", (params, httpPath) => {
+      const pathParamSpec = validatePathParams(params, httpPath);
+      const pathParamBindings = pathParamSpec?.bindings;
+      const funParams = params.flatMap(
+        (param) => this.renderOperationParams(param, pathParamSpec)
+      );
+      const hasBody = params.some((p) => p.kind === "body");
+      const hasQuery = params.some((p) => p.kind === "query");
+      const path = this.renderPathTemplateLiteral(
+        httpPath,
+        this.options.paramNames.path,
+        pathParamBindings
+      );
       return {
-        kind: "reference",
-        ref: {
-          kind: "internal",
-          name
-        }
+        funParams,
+        path,
+        hasBody,
+        hasQuery
       };
     });
-    __publicField$5(this, "builtinRef", (name) => ({
-      kind: "reference",
-      ref: {
-        kind: "builtin",
-        name
+    __publicField$6(this, "renderOperationParams", (param, pathParamSpec) => {
+      if (param.kind !== "path" || !pathParamSpec) {
+        return [
+          {
+            identifier: this.paramName(param),
+            typeExpr: param.typeExpr
+          }
+        ];
       }
-    }));
-    __publicField$5(this, "refNameFromPath", (ref) => {
-      const parts = ref.split("/");
-      const name = parts[parts.length - 1];
-      if (!name) {
-        throw new Error(`Unsupported schema reference: ${ref}`);
+      if (this.options.pathParamsStyle === "positional") {
+        return pathParamSpec.placeholderNames.map((name) => ({
+          identifier: pathParamSpec.bindings[name] ?? name,
+          typeExpr: pathParamSpec.propertiesByName[name].typeExpr
+        }));
       }
-      return name;
-    });
-    __publicField$5(this, "refCacheKey", (schema) => {
-      return `${schema.$ref}|nullable:${schema.nullable === true}`;
+      return [
+        {
+          identifier: this.renderPathParamDestructuring(
+            pathParamSpec.bindings
+          ),
+          typeExpr: param.typeExpr
+        }
+      ];
     });
-    __publicField$5(this, "isUnconstrainedSchema", (schema) => {
-      const meaningfulKeys = Object.keys(schema).filter(
-        (key) => key !== "nullable"
+    __publicField$6(this, "renderPathTemplateLiteral", (path, pathParamVarName, pathParamBindings) => {
+      const escapedPath = path.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+      const pathWithParams = escapedPath.replace(
+        /\{([^}]+)\}/g,
+        (_, paramName) => {
+          const binding = pathParamBindings?.[paramName];
+          if (binding !== void 0) {
+            return `\${${binding}}`;
+          }
+          return `\${${pathParamVarName}[${JSON.stringify(paramName)}]}`;
+        }
       );
-      return meaningfulKeys.length === 0;
-    });
-    __publicField$5(this, "ensureSchemaDefinition", (refId) => {
-      if (this.schemaDefinitionsById.has(refId) || this.schemaDefinitionsInProgress.has(refId)) {
-        return;
-      }
-      const schemaName = this.refNameFromPath(refId);
-      const schema = this.schemas[schemaName];
-      if (!schema) {
-        return;
-      }
-      this.schemaDefinitionsInProgress.add(refId);
-      try {
-        const definition = {
-          name: schemaName,
-          typeExpr: this.fromSchema(schema)
-        };
-        this.schemaDefinitionsById.set(refId, definition);
-        this.schemaDefinitions.push(definition);
-      } finally {
-        this.schemaDefinitionsInProgress.delete(refId);
-      }
+      return `\`${pathWithParams}\``;
     });
-    __publicField$5(this, "isSchemaNode", (value) => {
-      return Boolean(
-        value && typeof value === "object" && !Array.isArray(value)
+    __publicField$6(this, "renderPathParamDestructuring", (pathParamBindings) => {
+      const members = Object.entries(pathParamBindings).map(
+        ([paramName, binding]) => {
+          const key = toTsPropertyKey(paramName);
+          return binding === paramName ? key : `${key}: ${binding}`;
+        }
       );
+      return `{ ${members.join(", ")} }`;
     });
-    __publicField$5(this, "toLiteralValue", (value) => {
-      if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        return value;
-      }
-      throw new Error(`Unsupported literal value: ${String(value)}`);
-    });
-    __publicField$5(this, "isScalarName", (value) => {
-      switch (value) {
-        case "string":
-        case "number":
-        case "boolean":
-        case "integer":
-        case "null":
-        case "unknown":
-        case "any":
-        case "never":
-        case "void":
-          return true;
-        default:
-          return false;
-      }
-    });
-    __publicField$5(this, "hasNullMember", (expr) => {
-      if (expr.kind !== "inline") return false;
-      if (expr.expr.node === "scalar") {
-        return expr.expr.name === "null";
-      }
-      if (expr.expr.node === "union") {
-        return expr.expr.members.some((member) => this.hasNullMember(member));
-      }
-      return false;
-    });
-    __publicField$5(this, "withNullable", (expr) => {
-      if (this.hasNullMember(expr)) {
-        return expr;
+    __publicField$6(this, "paramName", (p) => {
+      switch (p.kind) {
+        case "body":
+          return this.options.paramNames.body;
+        case "query":
+          return this.options.paramNames.query;
+        case "path":
+          return this.options.paramNames.path;
+        default: {
+          const exhaustive = p;
+          throw new Error(
+            `Unsupported operation parameter kind: ${String(exhaustive)}`
+          );
+        }
       }
-      return this.union([expr, this.scalar("null")]);
-    });
-    __publicField$5(this, "projectObjectType", (schema) => {
-      const requiredRaw = schema.required;
-      if (requiredRaw !== void 0 && !Array.isArray(requiredRaw)) {
-        throw new Error(
-          "Unsupported object schema: required must be an array"
-        );
-      }
-      const required = new Set(
-        (requiredRaw ?? []).map((item) => {
-          if (typeof item !== "string") {
-            throw new Error(
-              "Unsupported object schema: required items must be strings"
-            );
-          }
-          return item;
-        })
-      );
-      const propertiesRaw = schema.properties;
-      if (propertiesRaw !== void 0 && (!propertiesRaw || typeof propertiesRaw !== "object" || Array.isArray(propertiesRaw))) {
-        throw new Error(
-          "Unsupported object schema: properties must be an object"
-        );
-      }
-      const properties = Object.entries(propertiesRaw ?? {}).map(
-        ([name, propertySchema]) => {
-          if (!this.isSchemaNode(propertySchema)) {
-            throw new Error(
-              `Unsupported object property schema for "${name}"`
-            );
-          }
-          return {
-            name,
-            required: this.isRequiredProperty(
-              name,
-              required,
-              propertySchema
-            ),
-            typeExpr: this.fromSchema(propertySchema)
-          };
-        }
-      );
-      let additionalProperties;
-      if (schema.additionalProperties !== void 0) {
-        if (typeof schema.additionalProperties === "boolean") {
-          additionalProperties = schema.additionalProperties;
-        } else if (this.isSchemaNode(schema.additionalProperties)) {
-          additionalProperties = this.fromSchema(
-            schema.additionalProperties
-          );
-        } else {
-          throw new Error(
-            "Unsupported object schema: additionalProperties must be boolean or schema object"
-          );
-        }
-      }
-      return {
-        kind: "inline",
-        expr: {
-          node: "object",
-          properties,
-          additionalProperties
-        }
-      };
-    });
-    __publicField$5(this, "isRequiredProperty", (name, required, propertySchema) => {
-      if (required.has(name)) {
-        return true;
-      }
-      if (!this.options.quirks?.swaggerTsApiRequiredBooleans) {
-        return false;
-      }
-      return propertySchema.required === true;
-    });
-    __publicField$5(this, "mapSchemaArrayMembers", (value, kind) => {
-      if (!Array.isArray(value) || !value.length) {
-        throw new Error(
-          `Unsupported schema: ${kind} must be a non-empty array`
-        );
-      }
-      return value.map((entry, index) => {
-        if (!this.isSchemaNode(entry)) {
-          throw new Error(
-            `Unsupported schema: ${kind}[${index}] must be a schema object`
-          );
-        }
-        return this.fromSchema(entry);
-      });
-    });
-    __publicField$5(this, "isBinaryFileSchema", (schema) => {
-      return schema.type === "string" && schema.format === "binary";
-    });
-    __publicField$5(this, "fromSchemaCore", (schema) => {
-      if (this.isUnconstrainedSchema(schema)) {
-        return this.scalar("unknown");
-      }
-      if (typeof schema.$ref === "string") {
-        this.ensureSchemaDefinition(schema.$ref);
-        return this.ref(schema.$ref);
-      }
-      if (schema.const !== void 0) {
-        return this.literal(this.toLiteralValue(schema.const));
-      }
-      if (Array.isArray(schema.enum)) {
-        if (!schema.enum.length) {
-          throw new Error(
-            "Unsupported enum schema: enum must be non-empty"
-          );
-        }
-        return this.union(
-          schema.enum.map(
-            (value) => this.literal(this.toLiteralValue(value))
-          )
-        );
-      }
-      if (schema.type === "array") {
-        if (schema.items === void 0) {
-          return {
-            kind: "inline",
-            expr: {
-              node: "array",
-              element: this.scalar("unknown")
-            }
-          };
-        }
-        if (Array.isArray(schema.items)) {
-          throw new Error("Unsupported array schema: tuple-style items");
-        }
-        if (!this.isSchemaNode(schema.items)) {
-          throw new Error(
-            "Unsupported array schema: items must be a schema"
-          );
-        }
-        return {
-          kind: "inline",
-          expr: {
-            node: "array",
-            element: this.fromSchema(schema.items)
-          }
-        };
-      }
-      if (schema.type === "object") {
-        return this.projectObjectType(schema);
-      }
-      if (schema.oneOf !== void 0) {
-        return this.union(this.mapSchemaArrayMembers(schema.oneOf, "oneOf"));
-      }
-      if (schema.anyOf !== void 0) {
-        return this.union(this.mapSchemaArrayMembers(schema.anyOf, "anyOf"));
-      }
-      if (schema.allOf !== void 0) {
-        return {
-          kind: "inline",
-          expr: {
-            node: "intersection",
-            members: this.mapSchemaArrayMembers(schema.allOf, "allOf")
-          }
-        };
-      }
-      if (this.isBinaryFileSchema(schema)) {
-        return this.builtinRef("File");
-      }
-      if (this.isScalarName(schema.type)) {
-        return this.scalar(schema.type);
-      }
-      throw new Error(
-        `Unsupported schema construct: ${JSON.stringify(schema, null, 2)}`
-      );
     });
   }
 }
-
-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);
-const pickPreferredMediaType = (mediaTypes) => {
-  if (!mediaTypes.length) return void 0;
-  const exactJson = mediaTypes.find((media) => media === "application/json");
-  if (exactJson) return exactJson;
-  const jsonLike = mediaTypes.find((media) => /\+json$/i.test(media));
-  if (jsonLike) return jsonLike;
-  const wildcardJson = mediaTypes.find(
-    (media) => /application\/\*\+json/i.test(media)
-  );
-  if (wildcardJson) return wildcardJson;
-  return mediaTypes[0];
+const extractPathPlaceholderNames = (pathTemplate) => {
+  const seen = /* @__PURE__ */ new Set();
+  const names = [];
+  const matcher = /\{([^}]+)\}/g;
+  let match = matcher.exec(pathTemplate);
+  while (match) {
+    const name = match[1];
+    if (!seen.has(name)) {
+      seen.add(name);
+      names.push(name);
+    }
+    match = matcher.exec(pathTemplate);
+  }
+  return names;
 };
-const isSuccessStatusCode = (statusCode) => {
-  const upper = statusCode.toUpperCase();
-  if (/^2XX$/.test(upper)) {
-    return true;
+const isPathParam = (param) => {
+  return param.kind === "path";
+};
+const isInlineObjectType = (typeExpr) => typeExpr.kind === "inline" && typeExpr.expr.node === "object";
+const renderNameList = (items) => {
+  const values = [...items];
+  if (!values.length) {
+    return "(none)";
   }
-  const numericCode = Number(statusCode);
-  return Number.isFinite(numericCode) && numericCode >= 200 && numericCode < 300;
+  return values.map((v) => JSON.stringify(v)).join(", ");
 };
-const selectReturnResponses = (responses) => {
-  const entries = Object.entries(responses);
-  if (!entries.length) {
-    return [];
+const validatePathParams = (params, httpPath) => {
+  const placeholders = extractPathPlaceholderNames(httpPath);
+  const placeholderSet = new Set(placeholders);
+  const pathParams = params.filter(isPathParam);
+  if (pathParams.length > 1) {
+    throw new Error(
+      `Path "${httpPath}" has ${pathParams.length} path parameter objects; expected at most one.`
+    );
   }
-  const success = entries.filter(([statusCode]) => isSuccessStatusCode(statusCode)).map(([, response]) => response);
-  if (success.length) {
-    return success;
+  const pathParam = pathParams[0];
+  if (!pathParam) {
+    if (placeholderSet.size > 0) {
+      throw new Error(
+        `Path "${httpPath}" is missing a path parameter object for placeholders: ${renderNameList(
+          placeholderSet
+        )}.`
+      );
+    }
+    return void 0;
   }
-  const defaultResponse = entries.find(
-    ([statusCode]) => statusCode.toLowerCase() === "default"
+  const pathParamExpr = pathParam.typeExpr.expr;
+  if (pathParamExpr.additionalProperties !== void 0 && pathParamExpr.additionalProperties !== false) {
+    throw new Error(
+      `Path "${httpPath}" path parameter object must not declare additionalProperties.`
+    );
+  }
+  const nestedObjectProps = pathParamExpr.properties.filter((prop) => isInlineObjectType(prop.typeExpr)).map((prop) => prop.name);
+  if (nestedObjectProps.length > 0) {
+    throw new Error(
+      `Path "${httpPath}" path parameters must be depth-1. Nested object properties: ${renderNameList(
+        nestedObjectProps
+      )}.`
+    );
+  }
+  const optionalPathProps = pathParamExpr.properties.filter((prop) => !prop.required).map((prop) => prop.name);
+  if (optionalPathProps.length > 0) {
+    throw new Error(
+      `Path "${httpPath}" path parameters must all be required. Optional properties: ${renderNameList(
+        optionalPathProps
+      )}.`
+    );
+  }
+  const declaredNames = pathParamExpr.properties.map((prop) => prop.name);
+  const declaredNameSet = new Set(declaredNames);
+  const missingInObject = [...placeholderSet].filter(
+    (name) => !declaredNameSet.has(name)
   );
-  if (defaultResponse) {
-    return [defaultResponse[1]];
+  const missingInPath = declaredNames.filter(
+    (name) => !placeholderSet.has(name)
+  );
+  if (missingInObject.length > 0 || missingInPath.length > 0) {
+    throw new Error(
+      `Path "${httpPath}" placeholders and path parameter object keys must match exactly. Missing in object: ${renderNameList(
+        missingInObject
+      )}. Missing in path: ${renderNameList(missingInPath)}.`
+    );
   }
-  return entries.map(([, response]) => response);
-};
-const getPreferredMediaTypeEntry = (content) => {
-  const mediaType = pickPreferredMediaType(Object.keys(content));
-  if (!mediaType) return {};
+  const bindings = buildPathParamBindings(placeholders);
+  const propertiesByName = Object.fromEntries(
+    pathParamExpr.properties.map((prop) => [prop.name, prop])
+  );
   return {
-    mediaType,
-    media: content[mediaType]
+    placeholderNames: placeholders,
+    bindings,
+    propertiesByName
   };
 };
-const isBinaryFileResponse = (response) => {
-  const { mediaType, media } = getPreferredMediaTypeEntry(response.content);
-  return media?.schema?.type === "string" && media.schema?.format === "binary" && mediaType !== "multipart/form-data";
-};
-const isJsonLikeMediaType = (mediaType) => {
-  return mediaType === "application/json" || typeof mediaType === "string" && /\+json$/i.test(mediaType);
-};
-const toHttpMethodUpper = (method) => {
-  switch (method) {
-    case "get":
-      return "GET";
-    case "post":
-      return "POST";
-    case "put":
-      return "PUT";
-    case "delete":
-      return "DELETE";
-    case "patch":
-      return "PATCH";
-    case "options":
-      return "OPTIONS";
-    case "head":
-      return "HEAD";
-    case "trace":
-      return "TRACE";
-    default: {
-      const exhaustive = method;
-      throw new Error(`Unsupported HTTP method: ${String(exhaustive)}`);
-    }
+
+const indentBlock = (value, indent) => {
+  if (!value || !indent) {
+    return value;
   }
+  return value.split("\n").map((line) => `${indent}${line}`).join("\n");
 };
-class OperationProjector {
-  constructor(options = {}) {
-    this.options = options;
-    __publicField$4(this, "seenOperationIds", /* @__PURE__ */ new Set());
-    __publicField$4(this, "typeExprConverter");
-    __publicField$4(this, "project", (openApi) => {
-      this.seenOperationIds.clear();
-      this.typeExprConverter = new ToTypeExprConverter(openApi.schemas, {
-        quirks: this.options.quirks
+
+const EMPTY_LINE_MARKER = "/*__EMPTY_LINE_MARKER__*/";
+
+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, docRenderer) {
+    this.opts = opts;
+    this.tsCodegenFactory = tsCodegenFactory;
+    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;
+      let classTypeParams = "";
+      if (this.opts.withRequestParams) {
+        clientType = `${httpClientType}<${REQUEST_PARAMS_TYPE}>`;
+        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 = `
+            ${classDocCode ? `${classDocCode}
+` : ""}export class ${apiName}${classTypeParams} {
+                constructor(private readonly http: ${clientType}) {}
+
+                ${methodsCode}
+            }
+        `;
+      return tsCodegen.toChunk("api", code, [apiName]);
+    });
+    __publicField$5(this, "groupsOpsCode", (codegen, groupedOps) => Object.entries(groupedOps).map(([groupName, ops]) => {
+      const methodsCode = this.opsCode(codegen, ops, "object");
+      return `
+                    ${toTsPropertyKey(groupName)} = {
+                        ${methodsCode}
+                    }
+                `;
+    }).join("\n\n"));
+    __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$5(this, "renderOp", (op, tsCodegen, target) => {
+      const { signature: sig, http } = op;
+      const invocationVars = this.opts.httpClient.invocation.vars;
+      const paramNames = {
+        path: "path",
+        query: invocationVars.query,
+        body: invocationVars.body
+      };
+      const paramsHelper = new ParamsConstructor({
+        paramNames,
+        pathParamsStyle: this.opts.pathParamsStyle
       });
-      const operations = openApi.operations.map((operation) => {
-        const operationName = (operation.operationId ?? syntheticOperationId(operation.method, operation.path)).trim();
-        if (!operationName) {
-          throw new Error(
-            `Operation id is empty for ${operation.method.toUpperCase()} ${operation.path}`
-          );
-        }
-        if (this.seenOperationIds.has(operationName)) {
-          throw new Error(`Duplicate operation id: ${operationName}`);
-        }
-        return this.projectOne(operationName, operation);
+      const { path, funParams, hasBody, hasQuery } = paramsHelper.process(
+        sig.parameters,
+        http.path
+      );
+      const params = funParams.map(
+        (r) => `${r.identifier}: ${tsCodegen.typeExpr(r.typeExpr)}`
+      );
+      if (this.opts.withRequestParams) {
+        params.push(`${REQUEST_PARAMS_ARG}?: ${REQUEST_PARAMS_TYPE}`);
+      }
+      const paramsCode = params.join(", ");
+      const responseType = tsCodegen.typeExpr(sig.returnType);
+      const returnType = this.wrapInResponseWrapper(sig.returnType, tsCodegen);
+      return this.renderFunctionCode({
+        doc: sig.doc,
+        funName: sig.name,
+        responseType,
+        returnType,
+        params: paramsCode,
+        path,
+        method: http.method,
+        hasQuery,
+        hasBody,
+        requestContentType: http.requestContentType,
+        responseFormat: http.responseFormat,
+        requestParamsVar: this.opts.withRequestParams ? REQUEST_PARAMS_ARG : void 0,
+        unwrap: this.opts.unwrap,
+        target
       });
-      return {
-        operations,
-        schemaDefinitions: this.typeExprConverter.getSchemaDefinitions()
-      };
     });
-    __publicField$4(this, "projectOne", (operationName, operation) => {
-      this.seenOperationIds.add(operationName);
-      const parameters = [];
-      const pathParameter = this.projectPathParameter(operation);
-      const queryParameter = this.projectQueryParameter(operation);
-      const bodyParameter = this.projectBodyParameter(operation);
-      if (pathParameter) parameters.push(pathParameter);
-      if (queryParameter) parameters.push(queryParameter);
-      if (bodyParameter) parameters.push(bodyParameter);
-      return {
-        op: {
-          signature: {
-            name: operationName,
-            parameters,
-            returnType: this.projectReturnType(operation)
-          },
-          http: {
-            method: toHttpMethodUpper(operation.method),
-            path: operation.path,
-            requestContentType: this.projectRequestContentType(
-              operation.requestBody
-            ),
-            responseFormat: this.projectResponseFormat(operation)
-          }
-        },
-        tags: [...operation.tags]
-      };
+    __publicField$5(this, "wrapInResponseWrapper", (typeExpr, tsCodegen) => {
+      return tsCodegen.typeExpr({
+        ...this.opts.httpClient.responseWrapper,
+        typeArgs: [typeExpr]
+      });
     });
-    __publicField$4(this, "projectRequestContentType", (requestBody) => {
-      const { mediaType } = getPreferredMediaTypeEntry(
-        requestBody?.content ?? {}
+    __publicField$5(this, "renderFunctionCode", ({
+      doc,
+      funName,
+      responseType,
+      returnType,
+      params,
+      path,
+      method,
+      hasQuery,
+      hasBody,
+      requestContentType,
+      responseFormat,
+      requestParamsVar,
+      unwrap,
+      target
+    }) => {
+      let invocation = this.opts.httpClient.invocation.expr({
+        funName,
+        returnType,
+        responseType,
+        params,
+        path,
+        method,
+        hasQuery,
+        hasBody,
+        requestContentType,
+        responseFormat,
+        requestParamsVar,
+        unwrap
+      });
+      invocation = invocation.replaceAll("\n", "");
+      const operator = target === "object" ? ":" : "=";
+      const returnTypeCode = this.opts.httpClient.inferMethodReturnType ? "" : `:${returnType}`;
+      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
       );
-      switch (mediaType) {
-        case "application/json":
-        case "multipart/form-data":
-        case "application/x-www-form-urlencoded":
-          return mediaType;
-        default:
-          return void 0;
-      }
     });
-    __publicField$4(this, "projectResponseFormat", (operation) => {
-      const selectedResponses = selectReturnResponses(operation.responses);
-      if (!selectedResponses.length) {
-        return void 0;
-      }
-      if (selectedResponses.some((response) => isBinaryFileResponse(response))) {
-        return "document";
+    __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 (selectedResponses.some(
-        (response) => isJsonLikeMediaType(
-          getPreferredMediaTypeEntry(response.content).mediaType
-        )
-      )) {
-        return "json";
+      if ((comms.description ?? true) && doc.description) {
+        nodes.push({
+          key: "description",
+          value: doc.description
+        });
       }
-      return void 0;
-    });
-    __publicField$4(this, "projectParameterGroupTypeExpr", (params) => {
-      const properties = Object.entries(params).map(([name, parameter]) => ({
-        name,
-        required: parameter.required,
-        typeExpr: this.typeExprConverter.fromSchema(
-          this.selectParameterSchema(parameter)
-        )
-      }));
-      return {
-        kind: "inline",
-        expr: {
-          node: "object",
-          properties
-        }
-      };
-    });
-    __publicField$4(this, "projectPathParameter", (operation) => {
-      const params = operation.parameters.path;
-      const entries = Object.values(params);
-      if (!entries.length) return null;
-      if (entries.some((parameter) => !parameter.required)) {
-        throw new Error("Unsupported path parameters: all must be required");
+      nodes.push({
+        key: "request",
+        value: doc.request
+      });
+      if ((comms.tags ?? true) && doc.tags.length) {
+        nodes.push({
+          key: "tags",
+          value: doc.tags.join(", ")
+        });
       }
       return {
-        kind: "path",
-        optional: false,
-        typeExpr: this.projectParameterGroupTypeExpr(params)
-      };
-    });
-    __publicField$4(this, "projectQueryParameter", (operation) => {
-      const params = operation.parameters.query;
-      const entries = Object.values(params);
-      if (!entries.length) return null;
-      return {
-        kind: "query",
-        optional: !entries.some((parameter) => parameter.required),
-        typeExpr: this.projectParameterGroupTypeExpr(params)
+        deprecated: doc.deprecated,
+        nodes
       };
     });
-    __publicField$4(this, "projectBodyParameter", (operation) => {
-      const requestBody = operation.requestBody;
-      if (!requestBody) return null;
-      return {
-        kind: "body",
-        optional: !requestBody.required,
-        typeExpr: this.typeExprConverter.fromSchema(
-          this.selectRequestBodySchema(requestBody)
-        )
-      };
-    });
-    __publicField$4(this, "projectReturnType", (operation) => {
-      const selectedResponses = selectReturnResponses(operation.responses);
-      if (!selectedResponses.length) {
-        return this.typeExprConverter.scalar("void");
-      }
-      const responseTypes = selectedResponses.map((response) => {
-        const schema = this.selectResponseSchema(response);
-        if (!schema) {
-          return this.typeExprConverter.scalar("void");
-        }
-        return this.typeExprConverter.fromSchema(schema);
-      });
-      return this.typeExprConverter.union(responseTypes);
-    });
-    __publicField$4(this, "selectParameterSchema", (parameter) => {
-      if (parameter.schema) return parameter.schema;
-      return getPreferredMediaTypeEntry(parameter.content).media?.schema;
-    });
-    __publicField$4(this, "selectRequestBodySchema", (requestBody) => {
-      return getPreferredMediaTypeEntry(requestBody.content).media?.schema;
-    });
-    __publicField$4(this, "selectResponseSchema", (response) => {
-      return getPreferredMediaTypeEntry(response.content).media?.schema;
-    });
-    this.typeExprConverter = new ToTypeExprConverter(void 0, {
-      quirks: this.options.quirks
-    });
   }
 }
 
-const buildPathParamBindings = (paramNames) => {
-  const usedBindings = /* @__PURE__ */ new Set();
-  return paramNames.reduce((acc, paramName) => {
-    acc[paramName] = toUniqueBindingName(paramName, usedBindings);
-    return acc;
-  }, {});
-};
-const toUniqueBindingName = (paramName, usedBindings) => {
-  let base = toBindingBase(paramName);
-  if (isReservedWord(base)) {
-    base = `${base}_param`;
+const promiseHttpClientCodegenSpec = () => ({
+  typeName: {
+    kind: "reference",
+    ref: {
+      kind: "internal",
+      name: "HttpClient"
+    }
+  },
+  responseWrapper: {
+    kind: "reference",
+    ref: {
+      kind: "builtin",
+      name: "Promise"
+    }
+  },
+  inferMethodReturnType: true,
+  invocation: {
+    vars: {
+      body: "body",
+      query: "query"
+    },
+    expr: ({
+      responseType,
+      path,
+      method,
+      hasBody,
+      hasQuery,
+      requestContentType,
+      responseFormat,
+      requestParamsVar,
+      unwrap
+    }) => `.request<${responseType}>({
+                method: '${method}',
+                path: ${path}
+                ${hasQuery ? `,
+query` : ""}
+                ${hasBody ? `,
+body` : ""}
+                ${requestContentType ? `,
+requestContentType: '${requestContentType}'` : ""}
+                ${responseFormat ? `,
+format: '${responseFormat}'` : ""}
+            }${requestParamsVar ? `,
+${requestParamsVar}` : ""})${unwrap ? `.then(res => res.body)` : ""}
+            `
   }
-  if (!usedBindings.has(base)) {
-    usedBindings.add(base);
-    return base;
+});
+
+const mergeChunks = (name, chunks, options = {}) => {
+  if (chunks.length === 0) {
+    if (options.allowEmpty) {
+      return {
+        name,
+        code: "export {}",
+        exports: [],
+        refs: []
+      };
+    }
+    throw new Error("Cannot merge empty chunk list.");
   }
-  let suffix = 2;
-  let candidate = `${base}_${suffix}`;
-  while (usedBindings.has(candidate)) {
-    suffix += 1;
-    candidate = `${base}_${suffix}`;
+  const orderedChunks = options.preserveChunkOrder ? chunks : orderByInternalDependencies(chunks);
+  const mergedCode = orderedChunks.map((chunk) => chunk.code).join("\n\n");
+  const exportedSymbols = /* @__PURE__ */ new Set();
+  const mergedExports = [];
+  for (const chunk of orderedChunks) {
+    for (const symbol of chunk.exports) {
+      if (exportedSymbols.has(symbol)) continue;
+      exportedSymbols.add(symbol);
+      mergedExports.push(symbol);
+    }
   }
-  usedBindings.add(candidate);
-  return candidate;
+  const seenRefKeys = /* @__PURE__ */ new Set();
+  const mergedRefs = orderedChunks.flatMap((chunk) => chunk.refs).filter((ref) => {
+    if (ref.kind === "internal" && exportedSymbols.has(ref.name)) {
+      return false;
+    }
+    const key = ref.kind === "internal" ? `internal:${ref.name}` : ref.kind === "external" ? `external:${ref.package}:${ref.name}` : `builtin:${ref.name}`;
+    if (seenRefKeys.has(key)) return false;
+    seenRefKeys.add(key);
+    return true;
+  });
+  return {
+    name,
+    code: mergedCode,
+    exports: mergedExports,
+    refs: mergedRefs
+  };
 };
-const toBindingBase = (paramName) => {
-  if (isIdentifier(paramName)) {
-    return paramName;
+const orderByInternalDependencies = (chunks) => {
+  const chunkIndex = /* @__PURE__ */ new Map();
+  const exportOwnerBySymbol = /* @__PURE__ */ new Map();
+  chunks.forEach((chunk, index) => {
+    chunkIndex.set(chunk.name, index);
+    for (const symbol of chunk.exports) {
+      if (exportOwnerBySymbol.has(symbol)) {
+        throw new Error(
+          `Assertion error. Symbol "${symbol}" exported multiple times while ordering chunks.`
+        );
+      }
+      exportOwnerBySymbol.set(symbol, chunk);
+    }
+  });
+  const dependentsByProvider = /* @__PURE__ */ new Map();
+  const inDegreeByChunk = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    dependentsByProvider.set(chunk, /* @__PURE__ */ new Set());
+    inDegreeByChunk.set(chunk, 0);
   }
-  const sanitized = paramName.replace(/[^0-9A-Za-z_$]/g, "_");
-  if (!sanitized.length) {
-    return "pathParam";
+  for (const chunk of chunks) {
+    const providers = /* @__PURE__ */ new Set();
+    for (const ref of chunk.refs) {
+      if (ref.kind !== "internal") continue;
+      const provider = exportOwnerBySymbol.get(ref.name);
+      if (!provider || provider === chunk) continue;
+      providers.add(provider);
+    }
+    for (const provider of providers) {
+      dependentsByProvider.get(provider).add(chunk);
+      inDegreeByChunk.set(chunk, inDegreeByChunk.get(chunk) + 1);
+    }
   }
-  if (/^[A-Za-z_$]/.test(sanitized)) {
-    return sanitized;
+  const ready = chunks.filter((chunk) => inDegreeByChunk.get(chunk) === 0).sort((a, b) => chunkIndex.get(a.name) - chunkIndex.get(b.name));
+  const ordered = [];
+  while (ready.length > 0) {
+    const provider = ready.shift();
+    ordered.push(provider);
+    for (const dependent of dependentsByProvider.get(provider)) {
+      const nextInDegree = inDegreeByChunk.get(dependent) - 1;
+      inDegreeByChunk.set(dependent, nextInDegree);
+      if (nextInDegree === 0) {
+        ready.push(dependent);
+      }
+    }
+    ready.sort((a, b) => chunkIndex.get(a.name) - chunkIndex.get(b.name));
   }
-  return `_${sanitized}`;
-};
-const isIdentifier = (value) => {
-  return /^[$A-Z_][0-9A-Z_$]*$/i.test(value);
-};
-const isReservedWord = (value) => {
-  return RESERVED_WORDS.has(value);
+  if (ordered.length !== chunks.length) {
+    const cycleChunkNames = chunks.filter((chunk) => inDegreeByChunk.get(chunk) > 0).map((chunk) => chunk.name).join(", ");
+    throw new Error(
+      `Cannot order chunks with cyclic internal dependencies: ${cycleChunkNames}`
+    );
+  }
+  return ordered;
 };
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
-class ParamsConstructor {
+var httpClientCommonTypesSource = "export type KnownRequestContentType =\n    | 'application/json'\n    | 'multipart/form-data'\n    | 'application/x-www-form-urlencoded'\n\nexport type RequestContentType = KnownRequestContentType | string\n\nexport type QueryValue =\n    | string\n    | number\n    | boolean\n    | null\n    | undefined\n    | QueryValue[]\n    | Record<string, any>\n    // Empty schema support\n    | unknown\n\nexport type QueryParams = Record<string, QueryValue>\n\nexport type Request = {\n    path: string\n    method: 'GET' | 'POST' | 'PUT' | 'DELETE'\n    format?: 'json' | 'document'\n    headers?: Record<string, string>\n    query?: QueryParams\n    body?: any\n    requestContentType?: RequestContentType\n}\n\nexport type HttpResponse<Data> = {\n    body: Data\n    headers: Record<string, string | string[]>\n    status: number\n}\n\nexport type QuerySerializer = (params: QueryParams) => string\n";
+
+var httpClientPromiseTypesSource = "import type { HttpResponse, Request } from './common-types'\n\nexport type HttpClient<RequestParams = never> = {\n    request: <Data>(\n        req: Request,\n        params?: RequestParams\n    ) => Promise<HttpResponse<Data>>\n}\n";
+
+const commonTypesCode = httpClientCommonTypesSource;
+const promiseHttpClientCode = httpClientPromiseTypesSource;
+const stripImports = (code) => code.replace(/^import[\s\S]*?from\s+['"][^'"]+['"]\s*;?\n?/gm, "").trim();
+const stripRequestParams = (code) => code.replace(/<RequestParams\s*=\s*never>/g, "").replace(/,\s*params\?:\s*RequestParams/g, "");
+const getHttpClientCode = (opts) => [
+  commonTypesCode,
+  opts.withRequestParams ? promiseHttpClientCode : stripRequestParams(promiseHttpClientCode)
+].map(stripImports).join("\n\n");
+const provideHttpClientCode = (gen, opts) => gen.toChunk(
+  "HttpClient",
+  getHttpClientCode({
+    withRequestParams: opts.withRequestParams
+  }),
+  ["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$3(this, "process", (params, httpPath) => {
-      const pathParamSpec = validatePathParams(params, httpPath);
-      const pathParamBindings = pathParamSpec?.bindings;
-      const funParams = params.flatMap(
-        (param) => this.renderOperationParams(param, pathParamSpec)
-      );
-      const hasBody = params.some((p) => p.kind === "body");
-      const hasQuery = params.some((p) => p.kind === "query");
-      const path = this.renderPathTemplateLiteral(
-        httpPath,
-        this.options.paramNames.path,
-        pathParamBindings
-      );
-      return {
-        funParams,
-        path,
-        hasBody,
-        hasQuery
-      };
+    __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$3(this, "renderOperationParams", (param, pathParamSpec) => {
-      if (param.kind !== "path" || !pathParamSpec) {
-        return [
-          {
-            identifier: this.paramName(param),
-            typeExpr: param.typeExpr
-          }
-        ];
+    __publicField$4(this, "renderComment", (lines) => {
+      if (!this.options.enabled) return "";
+      if (!lines.length) return "";
+      if (lines.length === 1) {
+        return `/** ${lines[0]} */`;
       }
-      if (this.options.pathParamsStyle === "positional") {
-        return pathParamSpec.placeholderNames.map((name) => ({
-          identifier: pathParamSpec.bindings[name] ?? name,
-          typeExpr: pathParamSpec.propertiesByName[name].typeExpr
-        }));
+      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("");
       }
-      return [
-        {
-          identifier: this.renderPathParamDestructuring(
-            pathParamSpec.bindings
-          ),
-          typeExpr: param.typeExpr
-        }
-      ];
+      lines.push(...normalized);
     });
-    __publicField$3(this, "renderPathTemplateLiteral", (path, pathParamVarName, pathParamBindings) => {
-      const escapedPath = path.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-      const pathWithParams = escapedPath.replace(
-        /\{([^}]+)\}/g,
-        (_, paramName) => {
-          const binding = pathParamBindings?.[paramName];
-          if (binding !== void 0) {
-            return `\${${binding}}`;
+    __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;
           }
-          return `\${${pathParamVarName}[${JSON.stringify(paramName)}]}`;
-        }
-      );
-      return `\`${pathWithParams}\``;
-    });
-    __publicField$3(this, "renderPathParamDestructuring", (pathParamBindings) => {
-      const members = Object.entries(pathParamBindings).map(
-        ([paramName, binding]) => {
-          const key = toTsPropertyKey(paramName);
-          return binding === paramName ? key : `${key}: ${binding}`;
+          this.appendDocText(lines, node);
+          return;
         }
-      );
-      return `{ ${members.join(", ")} }`;
+        this.appendField(lines, node.key, node.value);
+      });
     });
-    __publicField$3(this, "paramName", (p) => {
-      switch (p.kind) {
-        case "body":
-          return this.options.paramNames.body;
-        case "query":
-          return this.options.paramNames.query;
-        case "path":
-          return this.options.paramNames.path;
-        default: {
-          const exhaustive = p;
-          throw new Error(
-            `Unsupported operation parameter kind: ${String(exhaustive)}`
-          );
-        }
-      }
+    __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 extractPathPlaceholderNames = (pathTemplate) => {
-  const seen = /* @__PURE__ */ new Set();
-  const names = [];
-  const matcher = /\{([^}]+)\}/g;
-  let match = matcher.exec(pathTemplate);
-  while (match) {
-    const name = match[1];
-    if (!seen.has(name)) {
-      seen.add(name);
-      names.push(name);
-    }
-    match = matcher.exec(pathTemplate);
-  }
-  return names;
-};
-const isPathParam = (param) => {
-  return param.kind === "path";
-};
-const isInlineObjectType = (typeExpr) => typeExpr.kind === "inline" && typeExpr.expr.node === "object";
-const renderNameList = (items) => {
-  const values = [...items];
-  if (!values.length) {
-    return "(none)";
-  }
-  return values.map((v) => JSON.stringify(v)).join(", ");
-};
-const validatePathParams = (params, httpPath) => {
-  const placeholders = extractPathPlaceholderNames(httpPath);
-  const placeholderSet = new Set(placeholders);
-  const pathParams = params.filter(isPathParam);
-  if (pathParams.length > 1) {
-    throw new Error(
-      `Path "${httpPath}" has ${pathParams.length} path parameter objects; expected at most one.`
-    );
-  }
-  const pathParam = pathParams[0];
-  if (!pathParam) {
-    if (placeholderSet.size > 0) {
-      throw new Error(
-        `Path "${httpPath}" is missing a path parameter object for placeholders: ${renderNameList(
-          placeholderSet
-        )}.`
-      );
-    }
-    return void 0;
-  }
-  const pathParamExpr = pathParam.typeExpr.expr;
-  if (pathParamExpr.additionalProperties !== void 0 && pathParamExpr.additionalProperties !== false) {
-    throw new Error(
-      `Path "${httpPath}" path parameter object must not declare additionalProperties.`
-    );
-  }
-  const nestedObjectProps = pathParamExpr.properties.filter((prop) => isInlineObjectType(prop.typeExpr)).map((prop) => prop.name);
-  if (nestedObjectProps.length > 0) {
-    throw new Error(
-      `Path "${httpPath}" path parameters must be depth-1. Nested object properties: ${renderNameList(
-        nestedObjectProps
-      )}.`
-    );
-  }
-  const optionalPathProps = pathParamExpr.properties.filter((prop) => !prop.required).map((prop) => prop.name);
-  if (optionalPathProps.length > 0) {
-    throw new Error(
-      `Path "${httpPath}" path parameters must all be required. Optional properties: ${renderNameList(
-        optionalPathProps
-      )}.`
-    );
-  }
-  const declaredNames = pathParamExpr.properties.map((prop) => prop.name);
-  const declaredNameSet = new Set(declaredNames);
-  const missingInObject = [...placeholderSet].filter(
-    (name) => !declaredNameSet.has(name)
+
+const generateTsCode = (clientName, projectResult, opts) => {
+  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 = cg.declaration(def.name, def.declaration, {
+      exported: true
+    });
+    return cg.toChunk(def.name, code, [def.name]);
+  });
+  const clientCodegen = new ApiClientCodegen(
+    {
+      httpClient: promiseHttpClientCodegenSpec(),
+      comments: opts.comments.operation,
+      unwrap: opts.unwrap,
+      pathParamsStyle: opts.pathParamsStyle,
+      withRequestParams: opts.withRequestParams
+    },
+    tsCodegenFac,
+    docRenderer
   );
-  const missingInPath = declaredNames.filter(
-    (name) => !placeholderSet.has(name)
+  const generated = clientCodegen.generate(
+    clientName,
+    groupsOpsByTag(projectResult.operations),
+    projectResult.api
   );
-  if (missingInObject.length > 0 || missingInPath.length > 0) {
-    throw new Error(
-      `Path "${httpPath}" placeholders and path parameter object keys must match exactly. Missing in object: ${renderNameList(
-        missingInObject
-      )}. Missing in path: ${renderNameList(missingInPath)}.`
-    );
-  }
-  const bindings = buildPathParamBindings(placeholders);
-  const propertiesByName = Object.fromEntries(
-    pathParamExpr.properties.map((prop) => [prop.name, prop])
+  const clientChunk = {
+    ...generated,
+    name: `${clientName}.client`
+  };
+  const httpClientChunk = provideHttpClientCode(
+    tsCodegenFac.forNewChunk(),
+    opts
   );
+  const typesChunk = mergeChunks(`${clientName}.types`, types, {
+    preserveChunkOrder: true,
+    allowEmpty: true
+  });
+  const indexChunk = createIndexChunk(clientName);
+  const all = [typesChunk, httpClientChunk, clientChunk, indexChunk];
   return {
-    placeholderNames: placeholders,
-    bindings,
-    propertiesByName
+    all,
+    typesName: typesChunk.name,
+    promiseWrappersNames: [httpClientChunk.name, clientChunk.name]
   };
 };
-
-const EMPTY_LINE_MARKER = "/*__EMPTY_LINE_MARKER__*/";
-
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => __defNormalProp$2(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) {
-    this.opts = opts;
-    this.tsCodegenFactory = tsCodegenFactory;
-    __publicField$2(this, "generate", (apiName, operations) => {
-      const tsCodegen = this.tsCodegenFactory.forNewChunk();
-      const httpClientType = tsCodegen.toCode(this.opts.httpClient.typeName);
-      let clientType = httpClientType;
-      let classTypeParams = "";
-      if (this.opts.requestParams) {
-        clientType = `${httpClientType}<${REQUEST_PARAMS_TYPE}>`;
-        classTypeParams = `<${REQUEST_PARAMS_TYPE} = ${REQUEST_PARAMS_DEFAULT}>`;
-      }
-      const methodsCode = Array.isArray(operations) ? this.opsCode(tsCodegen, operations) : this.groupsOpsCode(tsCodegen, operations);
-      const code = `
-            export class ${apiName}${classTypeParams} {
-                constructor(private readonly client: ${clientType}) {}
-
-                ${methodsCode}
-            }
-        `;
-      return tsCodegen.toChunk("api", code, [apiName]);
-    });
-    __publicField$2(this, "groupsOpsCode", (codegen, groupedOps) => Object.entries(groupedOps).map(([groupName, ops]) => {
-      const methodsCode = this.opsCode(codegen, ops, "object");
-      return `
-                    ${toTsPropertyKey(groupName)} = {
-                        ${methodsCode}
-                    }
-                `;
-    }).join("\n\n"));
-    __publicField$2(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$2(this, "renderOp", (op, tsCodegen, target) => {
-      const { signature: sig, http } = op;
-      const invocationVars = this.opts.httpClient.invocation.vars;
-      const paramNames = {
-        path: "path",
-        query: invocationVars.query,
-        body: invocationVars.body
-      };
-      const paramsHelper = new ParamsConstructor({
-        paramNames,
-        pathParamsStyle: this.opts.pathParamsStyle
+const createIndexChunk = (clientName) => ({
+  name: "index",
+  code: [
+    `export { ${clientName} } from './${clientName}.client'`,
+    `export * from './${clientName}.types'`,
+    "export * from './HttpClient'"
+  ].join("\n"),
+  exports: [],
+  refs: []
+});
+const groupsOpsByTag = (operations) => {
+  const groupedOps = {};
+  const rawTagsByNormalizedName = /* @__PURE__ */ new Map();
+  operations.forEach((operation) => {
+    const rawTag = operation.tags.find((tag) => tag.trim())?.trim() || "root";
+    let groupName;
+    try {
+      groupName = toTsCamelIdentifier(rawTag, {
+        leadingDigitPrefix: "tag"
       });
-      const { path, funParams, hasBody, hasQuery } = paramsHelper.process(
-        sig.parameters,
-        http.path
+    } catch {
+      throw new Error(
+        `Invalid OpenAPI tag "${rawTag}": could not derive a client group name.`
       );
-      const params = funParams.map(
-        (r) => `${r.identifier}: ${tsCodegen.toCode(r.typeExpr)}`
+    }
+    const existingRawTag = rawTagsByNormalizedName.get(groupName);
+    if (existingRawTag && existingRawTag !== rawTag) {
+      throw new Error(
+        `Tag naming collision: "${existingRawTag}" and "${rawTag}" both normalize to "${groupName}". Rename one of these OpenAPI tags to continue.`
       );
-      if (this.opts.requestParams) {
-        params.push(`${REQUEST_PARAMS_ARG}?: ${REQUEST_PARAMS_TYPE}`);
-      }
-      const paramsCode = params.join(", ");
-      const responseType = tsCodegen.toCode(sig.returnType);
-      const returnType = this.wrapInResponseWrapper(sig.returnType, tsCodegen);
-      return this.renderFunctionCode({
-        funName: sig.name,
-        responseType,
-        returnType,
-        params: paramsCode,
-        path,
-        method: http.method,
-        hasQuery,
-        hasBody,
-        requestContentType: http.requestContentType,
-        responseFormat: http.responseFormat,
-        requestParamsVar: this.opts.requestParams ? REQUEST_PARAMS_ARG : void 0,
-        unwrap: this.opts.unwrap ?? false,
-        target
+    }
+    rawTagsByNormalizedName.set(groupName, rawTag);
+    const bucket = groupedOps[groupName] ?? [];
+    bucket.push(operation.op);
+    groupedOps[groupName] = bucket;
+  });
+  return groupedOps;
+};
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+const TS_IDENTIFIER_PATTERN = /^[$A-Z_][0-9A-Z_$]*$/i;
+class ToTypeExprConverter {
+  constructor(schemas = {}, options) {
+    this.schemas = schemas;
+    this.options = options;
+    __publicField$3(this, "schemaCache", /* @__PURE__ */ new WeakMap());
+    __publicField$3(this, "refCache", /* @__PURE__ */ new Map());
+    __publicField$3(this, "schemaDefinitions", []);
+    __publicField$3(this, "schemaDefinitionsById", /* @__PURE__ */ new Map());
+    __publicField$3(this, "schemaDefinitionsInProgress", /* @__PURE__ */ new Set());
+    __publicField$3(this, "getSchemaDefinitions", () => this.schemaDefinitions);
+    __publicField$3(this, "registerAllSchemaDefinitions", () => {
+      Object.keys(this.schemas).forEach((schemaName) => {
+        this.ensureSchemaDefinition(`#/components/schemas/${schemaName}`);
       });
     });
-    __publicField$2(this, "wrapInResponseWrapper", (typeExpr, tsCodegen) => {
-      return tsCodegen.toCode({
-        ...this.opts.httpClient.responseWrapper,
-        typeArgs: [typeExpr]
-      });
+    __publicField$3(this, "fromTypeExpr", (schema) => {
+      if (!schema) {
+        return this.scalar("unknown");
+      }
+      const bySchema = this.schemaCache.get(schema);
+      if (bySchema) {
+        return bySchema;
+      }
+      if (typeof schema.$ref === "string") {
+        const byRef = this.refCache.get(this.refCacheKey(schema));
+        if (byRef) {
+          this.schemaCache.set(schema, byRef);
+          return byRef;
+        }
+      }
+      const projected = this.fromSchemaCore(schema);
+      const result = schema.nullable === true ? this.withNullable(projected) : projected;
+      this.schemaCache.set(schema, result);
+      if (typeof schema.$ref === "string") {
+        this.refCache.set(this.refCacheKey(schema), result);
+      }
+      return result;
     });
-    __publicField$2(this, "renderFunctionCode", ({
-      funName,
-      responseType,
-      returnType,
-      params,
-      path,
-      method,
-      hasQuery,
-      hasBody,
-      requestContentType,
-      responseFormat,
-      requestParamsVar,
-      unwrap,
-      target
-    }) => {
-      let invocation = this.opts.httpClient.invocation.expr({
-        funName,
-        returnType,
-        responseType,
-        params,
-        path,
-        method,
-        hasQuery,
-        hasBody,
-        requestContentType,
-        responseFormat,
-        requestParamsVar,
-        unwrap
+    __publicField$3(this, "scalar", (name) => ({
+      kind: "inline",
+      expr: {
+        node: "scalar",
+        name
+      }
+    }));
+    __publicField$3(this, "union", (members) => {
+      const flatMembers = [];
+      for (const member of members) {
+        if (member.kind === "inline" && member.expr.node === "union") {
+          flatMembers.push(...member.expr.members);
+        } else {
+          flatMembers.push(member);
+        }
+      }
+      if (flatMembers.length === 1) {
+        return flatMembers[0];
+      }
+      return {
+        kind: "inline",
+        expr: {
+          node: "union",
+          members: flatMembers
+        }
+      };
+    });
+    __publicField$3(this, "literal", (value) => ({
+      kind: "inline",
+      expr: {
+        node: "literal",
+        value
+      }
+    }));
+    __publicField$3(this, "ref", (id) => {
+      const name = this.refNameFromPath(id);
+      return {
+        kind: "reference",
+        ref: {
+          kind: "internal",
+          name
+        }
+      };
+    });
+    __publicField$3(this, "builtinRef", (name) => ({
+      kind: "reference",
+      ref: {
+        kind: "builtin",
+        name
+      }
+    }));
+    __publicField$3(this, "refNameFromPath", (ref) => {
+      const parts = ref.split("/");
+      const name = parts[parts.length - 1];
+      if (!name) {
+        throw new Error(`Unsupported schema reference: ${ref}`);
+      }
+      return name;
+    });
+    __publicField$3(this, "refCacheKey", (schema) => {
+      return `${schema.$ref}|nullable:${schema.nullable === true}`;
+    });
+    __publicField$3(this, "isUnconstrainedSchema", (schema) => {
+      const meaningfulKeys = Object.keys(schema).filter(
+        (key) => key !== "nullable"
+      );
+      return meaningfulKeys.length === 0;
+    });
+    __publicField$3(this, "ensureSchemaDefinition", (refId) => {
+      if (this.schemaDefinitionsById.has(refId) || this.schemaDefinitionsInProgress.has(refId)) {
+        return;
+      }
+      const schemaName = this.refNameFromPath(refId);
+      const schema = this.schemas[schemaName];
+      if (!schema) {
+        return;
+      }
+      this.schemaDefinitionsInProgress.add(refId);
+      try {
+        const definition = {
+          name: schemaName,
+          declaration: this.toDeclaration(schema)
+        };
+        this.schemaDefinitionsById.set(refId, definition);
+        this.schemaDefinitions.push(definition);
+      } finally {
+        this.schemaDefinitionsInProgress.delete(refId);
+      }
+    });
+    __publicField$3(this, "isSchemaNode", (value) => {
+      return Boolean(
+        value && typeof value === "object" && !Array.isArray(value)
+      );
+    });
+    __publicField$3(this, "toLiteralValue", (value) => {
+      if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+      }
+      throw new Error(`Unsupported literal value: ${String(value)}`);
+    });
+    __publicField$3(this, "toDeclaration", (schema) => {
+      const enumDeclaration = this.toEnumDeclaration(schema);
+      if (enumDeclaration) {
+        return enumDeclaration;
+      }
+      return {
+        kind: "typeAlias",
+        doc: this.getSchemaDoc(schema),
+        typeExpr: this.fromTypeExpr(schema)
+      };
+    });
+    __publicField$3(this, "toEnumDeclaration", (schema) => {
+      if (this.options.enumStyle !== "enum" || !Array.isArray(schema.enum)) {
+        return void 0;
+      }
+      const valueType = this.getEnumValueType(schema.enum);
+      if (!valueType) {
+        return void 0;
+      }
+      return {
+        kind: "enum",
+        doc: this.getSchemaDoc(schema),
+        valueType,
+        members: this.toEnumMembers(schema.enum)
+      };
+    });
+    __publicField$3(this, "getEnumValueType", (values) => {
+      if (!values.length) {
+        return void 0;
+      }
+      if (values.every((value) => typeof value === "string")) {
+        return "string";
+      }
+      if (values.every((value) => typeof value === "number")) {
+        return "number";
+      }
+      return void 0;
+    });
+    __publicField$3(this, "toEnumMembers", (values) => {
+      const usedNames = /* @__PURE__ */ new Map();
+      return values.map((value, index) => {
+        const enumValue = value;
+        const baseName = this.toEnumMemberBaseName(enumValue, index);
+        const nextCount = (usedNames.get(baseName) ?? 0) + 1;
+        usedNames.set(baseName, nextCount);
+        return {
+          name: nextCount === 1 ? baseName : `${baseName}${nextCount}`,
+          value: enumValue
+        };
       });
-      invocation = invocation.replaceAll("\n", "");
-      const operator = target === "object" ? ":" : "=";
-      const returnTypeCode = this.opts.httpClient.inferMethodReturnType ? "" : `:${returnType}`;
-      return `${funName} ${operator} (${params})${returnTypeCode} => 
-             this.client${invocation}
-        `;
+    });
+    __publicField$3(this, "toEnumMemberBaseName", (value, index) => {
+      if (typeof value === "string" && this.options.uppercaseEnumKeys) {
+        const compatName = this.toCompatEnumMemberName(value);
+        if (compatName) {
+          return compatName;
+        }
+      }
+      if (typeof value === "string" && TS_IDENTIFIER_PATTERN.test(value) && !RESERVED_WORDS.has(value)) {
+        return value;
+      }
+      if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+        return `Value${value}`;
+      }
+      const pascalName = toPascalCaseIdentifier(String(value));
+      return pascalName === "Api" ? `Value${index + 1}` : pascalName;
+    });
+    __publicField$3(this, "toCompatEnumMemberName", (value) => {
+      if (/^([A-Z_]{1,})$/g.test(value)) {
+        return value;
+      }
+      const pascalName = toPascalCaseIdentifier(value);
+      return pascalName === "Api" ? void 0 : pascalName;
+    });
+    __publicField$3(this, "isScalarName", (value) => {
+      switch (value) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "integer":
+        case "null":
+        case "unknown":
+        case "any":
+        case "never":
+        case "void":
+          return true;
+        default:
+          return false;
+      }
+    });
+    __publicField$3(this, "hasNullMember", (expr) => {
+      if (expr.kind !== "inline") return false;
+      if (expr.expr.node === "scalar") {
+        return expr.expr.name === "null";
+      }
+      if (expr.expr.node === "union") {
+        return expr.expr.members.some((member) => this.hasNullMember(member));
+      }
+      return false;
+    });
+    __publicField$3(this, "withNullable", (expr) => {
+      if (this.hasNullMember(expr)) {
+        return expr;
+      }
+      return this.union([expr, this.scalar("null")]);
+    });
+    __publicField$3(this, "projectObjectType", (schema) => {
+      const requiredRaw = schema.required;
+      if (requiredRaw !== void 0 && !Array.isArray(requiredRaw)) {
+        throw new Error(
+          "Unsupported object schema: required must be an array"
+        );
+      }
+      const required = new Set(
+        (requiredRaw ?? []).map((item) => {
+          if (typeof item !== "string") {
+            throw new Error(
+              "Unsupported object schema: required items must be strings"
+            );
+          }
+          return item;
+        })
+      );
+      const propertiesRaw = schema.properties;
+      if (propertiesRaw !== void 0 && (!propertiesRaw || typeof propertiesRaw !== "object" || Array.isArray(propertiesRaw))) {
+        throw new Error(
+          "Unsupported object schema: properties must be an object"
+        );
+      }
+      const properties = Object.entries(propertiesRaw ?? {}).map(
+        ([name, propertySchema]) => {
+          if (!this.isSchemaNode(propertySchema)) {
+            throw new Error(
+              `Unsupported object property schema for "${name}"`
+            );
+          }
+          return {
+            doc: this.getSchemaDoc(propertySchema),
+            name,
+            required: this.isRequiredProperty(
+              name,
+              required,
+              propertySchema
+            ),
+            typeExpr: this.fromTypeExpr(propertySchema)
+          };
+        }
+      );
+      let additionalProperties;
+      if (schema.additionalProperties !== void 0) {
+        if (typeof schema.additionalProperties === "boolean") {
+          additionalProperties = schema.additionalProperties;
+        } else if (this.isSchemaNode(schema.additionalProperties)) {
+          additionalProperties = this.fromTypeExpr(
+            schema.additionalProperties
+          );
+        } else {
+          throw new Error(
+            "Unsupported object schema: additionalProperties must be boolean or schema object"
+          );
+        }
+      }
+      return {
+        kind: "inline",
+        expr: {
+          node: "object",
+          properties,
+          additionalProperties
+        }
+      };
+    });
+    __publicField$3(this, "isRequiredProperty", (name, required, propertySchema) => {
+      if (required.has(name)) {
+        return true;
+      }
+      if (!this.options.swaggerTsApiRequiredBooleans) {
+        return false;
+      }
+      return propertySchema.required === true;
+    });
+    __publicField$3(this, "mapSchemaArrayMembers", (value, kind) => {
+      if (!Array.isArray(value) || !value.length) {
+        throw new Error(
+          `Unsupported schema: ${kind} must be a non-empty array`
+        );
+      }
+      return value.map((entry, index) => {
+        if (!this.isSchemaNode(entry)) {
+          throw new Error(
+            `Unsupported schema: ${kind}[${index}] must be a schema object`
+          );
+        }
+        return this.fromTypeExpr(entry);
+      });
+    });
+    __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");
+      }
+      if (typeof schema.$ref === "string") {
+        this.ensureSchemaDefinition(schema.$ref);
+        return this.ref(schema.$ref);
+      }
+      if (schema.const !== void 0) {
+        return this.literal(this.toLiteralValue(schema.const));
+      }
+      if (Array.isArray(schema.enum)) {
+        if (!schema.enum.length) {
+          throw new Error(
+            "Unsupported enum schema: enum must be non-empty"
+          );
+        }
+        return this.union(
+          schema.enum.map(
+            (value) => this.literal(this.toLiteralValue(value))
+          )
+        );
+      }
+      if (schema.type === "array") {
+        if (schema.items === void 0) {
+          return {
+            kind: "inline",
+            expr: {
+              node: "array",
+              element: this.scalar("unknown")
+            }
+          };
+        }
+        if (Array.isArray(schema.items)) {
+          throw new Error("Unsupported array schema: tuple-style items");
+        }
+        if (!this.isSchemaNode(schema.items)) {
+          throw new Error(
+            "Unsupported array schema: items must be a schema"
+          );
+        }
+        return {
+          kind: "inline",
+          expr: {
+            node: "array",
+            element: this.fromTypeExpr(schema.items)
+          }
+        };
+      }
+      if (schema.type === "object") {
+        return this.projectObjectType(schema);
+      }
+      if (schema.oneOf !== void 0) {
+        return this.union(this.mapSchemaArrayMembers(schema.oneOf, "oneOf"));
+      }
+      if (schema.anyOf !== void 0) {
+        return this.union(this.mapSchemaArrayMembers(schema.anyOf, "anyOf"));
+      }
+      if (schema.allOf !== void 0) {
+        return {
+          kind: "inline",
+          expr: {
+            node: "intersection",
+            members: this.mapSchemaArrayMembers(schema.allOf, "allOf")
+          }
+        };
+      }
+      if (this.isBinaryFileSchema(schema)) {
+        return this.builtinRef("File");
+      }
+      if (this.isScalarName(schema.type)) {
+        return this.scalar(schema.type);
+      }
+      throw new Error(
+        `Unsupported schema construct: ${JSON.stringify(schema, null, 2)}`
+      );
     });
   }
 }
 
-const promiseHttpClientCodegenSpec = () => ({
-  typeName: {
-    kind: "reference",
-    ref: {
-      kind: "internal",
-      name: "HttpClient"
-    }
-  },
-  responseWrapper: {
-    kind: "reference",
-    ref: {
-      kind: "builtin",
-      name: "Promise"
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+const pickPreferredMediaType = (mediaTypes) => {
+  if (!mediaTypes.length) return void 0;
+  const exactJson = mediaTypes.find((media) => media === "application/json");
+  if (exactJson) return exactJson;
+  const jsonLike = mediaTypes.find((media) => /\+json$/i.test(media));
+  if (jsonLike) return jsonLike;
+  const wildcardJson = mediaTypes.find(
+    (media) => /application\/\*\+json/i.test(media)
+  );
+  if (wildcardJson) return wildcardJson;
+  return mediaTypes[0];
+};
+const isSuccessStatusCode = (statusCode) => {
+  const upper = statusCode.toUpperCase();
+  if (/^2XX$/.test(upper)) {
+    return true;
+  }
+  const numericCode = Number(statusCode);
+  return Number.isFinite(numericCode) && numericCode >= 200 && numericCode < 300;
+};
+const selectReturnResponses = (responses) => {
+  const entries = Object.entries(responses);
+  if (!entries.length) {
+    return [];
+  }
+  const success = entries.filter(([statusCode]) => isSuccessStatusCode(statusCode)).map(([, response]) => response);
+  if (success.length) {
+    return success;
+  }
+  const defaultResponse = entries.find(
+    ([statusCode]) => statusCode.toLowerCase() === "default"
+  );
+  if (defaultResponse) {
+    return [defaultResponse[1]];
+  }
+  return entries.map(([, response]) => response);
+};
+const getPreferredMediaTypeEntry = (content) => {
+  const mediaType = pickPreferredMediaType(Object.keys(content));
+  if (!mediaType) return {};
+  return {
+    mediaType,
+    media: content[mediaType]
+  };
+};
+const isBinaryFileResponse = (response) => {
+  const { mediaType, media } = getPreferredMediaTypeEntry(response.content);
+  return media?.schema?.type === "string" && media.schema?.format === "binary" && mediaType !== "multipart/form-data";
+};
+const isJsonLikeMediaType = (mediaType) => {
+  return mediaType === "application/json" || typeof mediaType === "string" && /\+json$/i.test(mediaType);
+};
+const toHttpMethodUpper = (method) => {
+  switch (method) {
+    case "get":
+      return "GET";
+    case "post":
+      return "POST";
+    case "put":
+      return "PUT";
+    case "delete":
+      return "DELETE";
+    case "patch":
+      return "PATCH";
+    case "options":
+      return "OPTIONS";
+    case "head":
+      return "HEAD";
+    case "trace":
+      return "TRACE";
+    default: {
+      const exhaustive = method;
+      throw new Error(`Unsupported HTTP method: ${String(exhaustive)}`);
     }
-  },
-  inferMethodReturnType: true,
-  invocation: {
-    vars: {
-      body: "body",
-      query: "query"
-    },
-    expr: ({
-      responseType,
-      path,
-      method,
-      hasBody,
-      hasQuery,
-      requestContentType,
-      responseFormat,
-      requestParamsVar,
-      unwrap
-    }) => `.request<${responseType}>({
-                method: '${method}',
-                path: ${path}
-                ${hasQuery ? `,
-query` : ""}
-                ${hasBody ? `,
-body` : ""}
-                ${requestContentType ? `,
-requestContentType: '${requestContentType}'` : ""}
-                ${responseFormat ? `,
-format: '${responseFormat}'` : ""}
-            }${requestParamsVar ? `,
-${requestParamsVar}` : ""})${unwrap ? `.then(res => res.body)` : ""}
-            `
   }
-});
+};
+class OperationProjector {
+  constructor(options) {
+    this.options = options;
+    __publicField$2(this, "seenOperationIds", /* @__PURE__ */ new Set());
+    __publicField$2(this, "typeExprConverter");
+    __publicField$2(this, "project", (openApi) => {
+      this.seenOperationIds.clear();
+      this.typeExprConverter = new ToTypeExprConverter(
+        openApi.schemas,
+        this.options.typeExtraction
+      );
+      if (this.options.includeAllSchema) {
+        this.typeExprConverter.registerAllSchemaDefinitions();
+      }
+      const operations = openApi.operations.map((operation) => {
+        const operationName = (operation.operationId ?? syntheticOperationId(operation.method, operation.path)).trim();
+        if (!operationName) {
+          throw new Error(
+            `Operation id is empty for ${operation.method.toUpperCase()} ${operation.path}`
+          );
+        }
+        if (this.seenOperationIds.has(operationName)) {
+          throw new Error(`Duplicate operation id: ${operationName}`);
+        }
+        return this.projectOne(operationName, operation);
+      });
+      return {
+        api: {
+          title: openApi.info.title,
+          version: openApi.info.version,
+          description: openApi.info.description
+        },
+        operations,
+        schemaDefinitions: this.typeExprConverter.getSchemaDefinitions()
+      };
+    });
+    __publicField$2(this, "projectOne", (operationName, operation) => {
+      this.seenOperationIds.add(operationName);
+      const parameters = [];
+      const pathParameter = this.projectPathParameter(operation);
+      const queryParameter = this.projectQueryParameter(operation);
+      const bodyParameter = this.projectBodyParameter(operation);
+      if (pathParameter) parameters.push(pathParameter);
+      if (queryParameter) parameters.push(queryParameter);
+      if (bodyParameter) parameters.push(bodyParameter);
+      return {
+        op: {
+          signature: {
+            doc: this.toOperationDoc(operationName, operation),
+            name: operationName,
+            parameters,
+            returnType: this.projectReturnType(operation)
+          },
+          http: {
+            method: toHttpMethodUpper(operation.method),
+            path: operation.path,
+            requestContentType: this.projectRequestContentType(
+              operation.requestBody
+            ),
+            responseFormat: this.projectResponseFormat(operation)
+          }
+        },
+        tags: [...operation.tags]
+      };
+    });
+    __publicField$2(this, "projectRequestContentType", (requestBody) => {
+      const { mediaType } = getPreferredMediaTypeEntry(
+        requestBody?.content ?? {}
+      );
+      switch (mediaType) {
+        case "application/json":
+        case "multipart/form-data":
+        case "application/x-www-form-urlencoded":
+          return mediaType;
+        default:
+          return void 0;
+      }
+    });
+    __publicField$2(this, "projectResponseFormat", (operation) => {
+      const selectedResponses = selectReturnResponses(operation.responses);
+      if (!selectedResponses.length) {
+        return void 0;
+      }
+      if (selectedResponses.some((response) => isBinaryFileResponse(response))) {
+        return "document";
+      }
+      if (selectedResponses.some(
+        (response) => isJsonLikeMediaType(
+          getPreferredMediaTypeEntry(response.content).mediaType
+        )
+      )) {
+        return "json";
+      }
+      return void 0;
+    });
+    __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(
+          this.selectParameterSchema(parameter)
+        )
+      }));
+      return {
+        kind: "inline",
+        expr: {
+          node: "object",
+          properties
+        }
+      };
+    });
+    __publicField$2(this, "projectPathParameter", (operation) => {
+      const params = operation.parameters.path;
+      const entries = Object.values(params);
+      if (!entries.length) return null;
+      if (entries.some((parameter) => !parameter.required)) {
+        throw new Error("Unsupported path parameters: all must be required");
+      }
+      return {
+        kind: "path",
+        optional: false,
+        typeExpr: this.projectParameterGroupTypeExpr(params)
+      };
+    });
+    __publicField$2(this, "projectQueryParameter", (operation) => {
+      const params = operation.parameters.query;
+      const entries = Object.values(params);
+      if (!entries.length) return null;
+      return {
+        kind: "query",
+        optional: !entries.some((parameter) => parameter.required),
+        typeExpr: this.projectParameterGroupTypeExpr(params)
+      };
+    });
+    __publicField$2(this, "projectBodyParameter", (operation) => {
+      const requestBody = operation.requestBody;
+      if (!requestBody) return null;
+      return {
+        kind: "body",
+        optional: !requestBody.required,
+        typeExpr: this.typeExprConverter.fromTypeExpr(
+          this.selectRequestBodySchema(requestBody)
+        )
+      };
+    });
+    __publicField$2(this, "projectReturnType", (operation) => {
+      const selectedResponses = selectReturnResponses(operation.responses);
+      if (!selectedResponses.length) {
+        return this.typeExprConverter.scalar("void");
+      }
+      const responseTypes = selectedResponses.map((response) => {
+        const schema = this.selectResponseSchema(response);
+        if (!schema) {
+          return this.typeExprConverter.scalar("void");
+        }
+        return this.typeExprConverter.fromTypeExpr(schema);
+      });
+      return this.typeExprConverter.union(responseTypes);
+    });
+    __publicField$2(this, "selectParameterSchema", (parameter) => {
+      if (parameter.schema) return parameter.schema;
+      return getPreferredMediaTypeEntry(parameter.content).media?.schema;
+    });
+    __publicField$2(this, "selectRequestBodySchema", (requestBody) => {
+      return getPreferredMediaTypeEntry(requestBody.content).media?.schema;
+    });
+    __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;
@@ -5796,7 +6629,7 @@ class CodeFormatter {
   constructor(opts) {
     this.opts = opts;
     __publicField$1(this, "format", async (code) => {
-      const filePath = Path.resolve(this.opts.resolveConfFrom, "generated.ts");
+      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, {
@@ -5817,7 +6650,7 @@ class CodeWriter {
     __publicField(this, "symbolChunkMap", /* @__PURE__ */ new Map());
     __publicField(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);
@@ -5827,7 +6660,7 @@ 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) => {
@@ -5890,185 +6723,77 @@ class CodeWriter {
 }
 const ensureSingleTrailingNewline = (code) => code.replace(/\n+$/u, "\n");
 
-const mergeChunks = (name, chunks) => {
-  if (chunks.length === 0) {
-    throw new Error("Cannot merge empty chunk list.");
-  }
-  const orderedChunks = orderByInternalDependencies(chunks);
-  const mergedCode = orderedChunks.map((chunk) => chunk.code).join("\n\n");
-  const exportedSymbols = /* @__PURE__ */ new Set();
-  const mergedExports = [];
-  for (const chunk of orderedChunks) {
-    for (const symbol of chunk.exports) {
-      if (exportedSymbols.has(symbol)) continue;
-      exportedSymbols.add(symbol);
-      mergedExports.push(symbol);
-    }
-  }
-  const seenRefKeys = /* @__PURE__ */ new Set();
-  const mergedRefs = orderedChunks.flatMap((chunk) => chunk.refs).filter((ref) => {
-    if (ref.kind === "internal" && exportedSymbols.has(ref.name)) {
-      return false;
-    }
-    const key = ref.kind === "internal" ? `internal:${ref.name}` : ref.kind === "external" ? `external:${ref.package}:${ref.name}` : `builtin:${ref.name}`;
-    if (seenRefKeys.has(key)) return false;
-    seenRefKeys.add(key);
-    return true;
-  });
-  return {
-    name,
-    code: mergedCode,
-    exports: mergedExports,
-    refs: mergedRefs
-  };
-};
-const orderByInternalDependencies = (chunks) => {
-  const chunkIndex = /* @__PURE__ */ new Map();
-  const exportOwnerBySymbol = /* @__PURE__ */ new Map();
-  chunks.forEach((chunk, index) => {
-    chunkIndex.set(chunk.name, index);
-    for (const symbol of chunk.exports) {
-      if (exportOwnerBySymbol.has(symbol)) {
-        throw new Error(
-          `Assertion error. Symbol "${symbol}" exported multiple times while ordering chunks.`
-        );
-      }
-      exportOwnerBySymbol.set(symbol, chunk);
-    }
-  });
-  const dependentsByProvider = /* @__PURE__ */ new Map();
-  const inDegreeByChunk = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    dependentsByProvider.set(chunk, /* @__PURE__ */ new Set());
-    inDegreeByChunk.set(chunk, 0);
-  }
-  for (const chunk of chunks) {
-    const providers = /* @__PURE__ */ new Set();
-    for (const ref of chunk.refs) {
-      if (ref.kind !== "internal") continue;
-      const provider = exportOwnerBySymbol.get(ref.name);
-      if (!provider || provider === chunk) continue;
-      providers.add(provider);
-    }
-    for (const provider of providers) {
-      dependentsByProvider.get(provider).add(chunk);
-      inDegreeByChunk.set(chunk, inDegreeByChunk.get(chunk) + 1);
-    }
+class VNextOasClientGenerator {
+  constructor(options, log) {
+    this.options = options;
+    this.log = log;
   }
-  const ready = chunks.filter((chunk) => inDegreeByChunk.get(chunk) === 0).sort((a, b) => chunkIndex.get(a.name) - chunkIndex.get(b.name));
-  const ordered = [];
-  while (ready.length > 0) {
-    const provider = ready.shift();
-    ordered.push(provider);
-    for (const dependent of dependentsByProvider.get(provider)) {
-      const nextInDegree = inDegreeByChunk.get(dependent) - 1;
-      inDegreeByChunk.set(dependent, nextInDegree);
-      if (nextInDegree === 0) {
-        ready.push(dependent);
+  async generate(cmd) {
+    const { inputFile, outputDir, apiName } = cmd;
+    this.log(`Will generate API client name=${apiName} to ${outputDir}`);
+    const sourceSchema = await loadSourceSchema(inputFile);
+    const normalizedSchema = this.normalizeSchema(sourceSchema, inputFile);
+    const openApiIr = this.filterOperations(normalizedSchema);
+    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
       }
-    }
-    ready.sort((a, b) => chunkIndex.get(a.name) - chunkIndex.get(b.name));
-  }
-  if (ordered.length !== chunks.length) {
-    const cycleChunkNames = chunks.filter((chunk) => inDegreeByChunk.get(chunk) > 0).map((chunk) => chunk.name).join(", ");
-    throw new Error(
-      `Cannot order chunks with cyclic internal dependencies: ${cycleChunkNames}`
+    }).project(openApiIr);
+    const clientName = toPascalCaseIdentifier(apiName);
+    const chunks = generateTsCode(
+      clientName,
+      projectResult,
+      this.options.codegen
     );
+    const codeFormatter = new CodeFormatter({
+      resolveConfFrom: outputDir
+    });
+    const writer = new CodeWriter(codeFormatter);
+    await writer.write(outputDir, chunks.all);
+    const tsFilePath = (name) => Path.join(outputDir, `${name}.ts`);
+    return {
+      promiseWrapper: chunks.promiseWrappersNames.map(tsFilePath),
+      types: tsFilePath(chunks.typesName)
+    };
   }
-  return ordered;
-};
-
-const generateFromIr = async ({
-  openApiIr,
-  clientName,
-  outputDir,
-  outputFilename,
-  codeFormattingConfigDir,
-  quirks,
-  requestParams: withRequestParams
-}) => {
-  const tsCodegenFac = new TsCodegenFactory();
-  const projectResult = new OperationProjector({
-    quirks
-  }).project(openApiIr);
-  const { schemaDefinitions } = projectResult;
-  const requestParams = withRequestParams;
-  const types = schemaDefinitions.map((def) => {
-    const cg = tsCodegenFac.forNewChunk();
-    const typeName = def.name;
-    const code = `export type ${typeName} = ${cg.toCode(def.typeExpr)}`;
-    return cg.toChunk(typeName, code, [typeName]);
-  });
-  const clientCodegen = new ApiClientCodegen(
-    {
-      httpClient: promiseHttpClientCodegenSpec(),
-      requestParams,
-      // TODO make configurable
-      pathParamsStyle: "positional"
-    },
-    tsCodegenFac
-  );
-  const generated = clientCodegen.generate(
-    clientName,
-    groupsOpsByTag(projectResult.operations)
-  );
-  const httpClientChunk = tsCodegenFac.forNewChunk().toChunk(
-    "HttpClient",
-    getHttpClientCode(),
-    ["HttpRequest", "HttpResponse", "HttpClient"]
-  );
-  const codeFormatter = new CodeFormatter({
-    resolveConfFrom: codeFormattingConfigDir
-  });
-  const writer = new CodeWriter(codeFormatter);
-  let chunks = [...types, httpClientChunk, generated];
-  chunks = [mergeChunks(outputFilename, chunks)];
-  await writer.write(outputDir, chunks);
-};
-const groupsOpsByTag = (operations) => {
-  const groupedOps = {};
-  operations.forEach((operation) => {
-    const groupName = operation.tags[0]?.trim() || "root";
-    const bucket = groupedOps[groupName] ?? [];
-    bucket.push(operation.op);
-    groupedOps[groupName] = bucket;
-  });
-  return groupedOps;
-};
-const commonTypesCode = httpClientCommonTypesSource;
-const promiseHttpClientCode = httpClientPromiseTypesSource;
-const stripImports = (code) => code.replace(/^import[\s\S]*?from\s+['"][^'"]+['"]\s*;?\n?/gm, "").trim();
-const getHttpClientCode = (opts) => [
-  commonTypesCode,
-  promiseHttpClientCode 
-].map(stripImports).join("\n\n");
-
-const generateOpenApiClient$1 = async ({ input, name, outputDir, quirks, ignoreOperationsWithTags }, log) => {
-  log(`Will generate API client name=${name} to ${outputDir}`);
-  const sourceSchema = await loadSourceSchema(input);
-  const { result, problems } = new OpenApiNormalizer(sourceSchema).load();
-  problems.forEach((problem) => {
-    log(`[open-api:${problem.level}] ${problem.path}: ${problem.message}`);
-  });
-  const errors = problems.filter((problem) => problem.level === "error");
-  if (errors.length) {
-    throw new Error(
-      `Failed to load OpenAPI IR from ${input}: ${errors.length} error(s).`
+  filterOperations(openApiIr) {
+    const ignoreTags = new Set(
+      this.options.selection?.ignoreOperationsWithTags || []
     );
+    return {
+      ...openApiIr,
+      operations: openApiIr.operations.filter((operation) => {
+        const hasUsableTags = operation.tags.some((tag) => tag.trim());
+        if (!hasUsableTags) {
+          this.log(
+            `[open-api:warning] Ignoring operation ${operation.method.toUpperCase()} ${operation.path} (${operation.operationId ?? "<missing operationId>"}): no tags`
+          );
+          return false;
+        }
+        return !operation.tags.some((tag) => ignoreTags.has(tag));
+      })
+    };
   }
-  const openApiIr = filterOperations(result, log, ignoreOperationsWithTags);
-  const outputFilename = "index";
-  await generateFromIr({
-    openApiIr,
-    clientName: toPascalCaseIdentifier(name),
-    outputDir,
-    outputFilename,
-    codeFormattingConfigDir: outputDir,
-    quirks,
-    requestParams: true
-  });
-  return Path.join(outputDir, `${outputFilename}.ts`);
-};
+  normalizeSchema(rawSchema, inputFile) {
+    const { result, problems } = new OpenApiNormalizer(rawSchema).load();
+    problems.forEach((problem) => {
+      this.log(
+        `[open-api:${problem.level}] ${problem.path}: ${problem.message}`
+      );
+    });
+    const errors = problems.filter((problem) => problem.level === "error");
+    if (errors.length) {
+      throw new Error(
+        `Failed to load OpenAPI IR from ${inputFile}: ${errors.length} error(s).`
+      );
+    }
+    return result;
+  }
+}
 const loadSourceSchema = async (input) => {
   let rawContent;
   try {
@@ -6091,109 +6816,60 @@ const loadSourceSchema = async (input) => {
   }
   return parsed;
 };
-const filterOperations = (openApiIr, log, ignoreOperationsWithTags) => {
-  const ignoreTags = new Set(ignoreOperationsWithTags);
-  return {
-    ...openApiIr,
-    operations: openApiIr.operations.filter((operation) => {
-      const hasUsableTags = operation.tags.some((tag) => tag.trim());
-      if (!hasUsableTags) {
-        log(
-          `[open-api:warning] Ignoring operation ${operation.method.toUpperCase()} ${operation.path} (${operation.operationId ?? "<missing operationId>"}): no tags`
-        );
-        return false;
-      }
-      return !operation.tags.some((tag) => ignoreTags.has(tag));
-    })
-  };
-};
 const toErrorMessage = (error) => {
   return error instanceof Error ? error.message : String(error);
 };
 
-const generateOpenApiClient = async ({ input, name, outputDir, ignoreOperationsWithTags }, log) => {
-  log(`Will generate API client name=${name} to ${outputDir}`);
-  const fileName = "index";
-  const dstFile = Path$1.join(outputDir, `${fileName}.ts`);
-  const prettier = await import('prettier');
-  const prettierConfig = await prettier.resolveConfig(dstFile) ?? {};
-  const prettierConfigForGenerator = {
-    ...prettierConfig,
-    // swagger-typescript-api defaults to printWidth=120; keep Prettier default 80 unless explicitly configured.
-    printWidth: prettierConfig.printWidth ?? 80
-  };
-  const ignoreTags = ignoreOperationsWithTags && new Set(ignoreOperationsWithTags);
-  await generateApi({
-    name: "index",
-    output: outputDir,
-    input,
-    // modular: true,
-    httpClientType: "axios",
-    templates: getTemplatesDir(),
-    defaultResponseAsSuccess: true,
-    sortTypes: true,
-    // generateRouteTypes: true,
-    singleHttpClient: true,
-    // extractRequestBody: true,
-    prettier: prettierConfigForGenerator,
-    moduleNameFirstTag: true,
-    apiClassName: toPascalCaseIdentifier(name),
-    hooks: {
-      onCreateRoute: (routeData) => {
-        if (ignoreTags) {
-          const ignore = routeData.raw.tags?.find(
-            (t) => ignoreTags.has(t)
-          );
-          if (ignore) return false;
-        }
-        return routeData;
-      }
-    },
-    // @ts-ignore
-    codeGenConstructs: () => ({
-      Keyword: {}
-    })
-    // extractRequestParams: true,
-  });
-  return dstFile;
-};
-const getThisScriptDirname = () => {
-  return Path$1.dirname(fileURLToPath(import.meta.url));
-};
-const getTemplatesDir = () => {
-  const currentDir = getThisScriptDirname();
-  const templatesRelativePath = Path$1.basename(currentDir) === "dist" ? "../templates" : "../../../templates";
-  return Path$1.resolve(currentDir, templatesRelativePath);
-};
-
-const SUPPORTED_GENERATORS = [
-  "swagger-ts-api",
-  "api-client-generator"
-];
-const OPEN_API_MODEL_GENERATORS = {
-  "swagger-ts-api": generateOpenApiClient,
-  "api-client-generator": generateOpenApiClient$1
-};
-const generateOpenApiModel = async (generator, cmd, log) => {
-  const generatorFun = OPEN_API_MODEL_GENERATORS[generator];
-  const outputPath = await generatorFun(cmd, log);
-  const outputModifiers = getOutputModifiers(cmd, log);
-  log(`Will modify the outputs ${JSON.stringify(outputModifiers)}`);
-  await modifyOutput(outputPath, outputModifiers);
-  return outputPath;
+const generateOpenApiModel = async (spectPath, config, log) => {
+  let outFiles;
+  const { openApiGenerator, responseWrapper } = config;
+  if ("legacy" in openApiGenerator) {
+    outFiles = await generateOpenApiClient(
+      spectPath,
+      {
+        ignoreOperationsWithTags: openApiGenerator.legacy.ignoreOperationsWithTags,
+        name: config.apiName,
+        outputDir: config.dstDir
+      },
+      log
+    );
+  } else {
+    outFiles = await new VNextOasClientGenerator(
+      openApiGenerator,
+      log
+    ).generate({
+      inputFile: spectPath,
+      apiName: config.apiName,
+      outputDir: config.dstDir
+    });
+  }
+  if (responseWrapper) {
+    await modifyHttpClientAsyncWrapper(
+      outFiles.promiseWrapper,
+      responseWrapper,
+      log
+    );
+  }
+  return { typesFilePath: outFiles.types };
 };
-const getOutputModifiers = ({ responseWrapper }, log) => {
+const modifyHttpClientAsyncWrapper = async (filePaths, responseWrapper, log) => {
+  log(
+    `Will use response wrapper '${JSON.stringify(responseWrapper)}' on file ${filePaths.join(", ")}`
+  );
   const addImports = [];
-  const replaces = [];
-  if (responseWrapper) {
-    log(`Will use response wrapper '${JSON.stringify(responseWrapper)}'`);
-    if (responseWrapper.import) addImports.push(responseWrapper.import);
-    replaces.push(["Promise", responseWrapper.symbol]);
+  if (responseWrapper.import) {
+    addImports.push(responseWrapper.import);
+  }
+  const replaces = [["Promise", responseWrapper.symbol]];
+  if (responseWrapper.unwrapExpr) {
+    replaces.push([".then(res => res.body)", responseWrapper.unwrapExpr]);
+  }
+  for (const filePath of filePaths) {
+    await modifyOutput(filePath, {
+      addImports,
+      replaces
+    });
   }
-  return {
-    addImports,
-    replaces
-  };
 };
 const modifyOutput = async (path, cmd) => {
   let content = await fs$1.readFile(path).then((r) => r.toString());
@@ -6255,13 +6931,11 @@ const findMatchingBrace = (code, openBraceIndex) => {
 };
 
 const generateSchemas = async (inputFile, outputFile, opts = {}) => {
-  const code = fs__default.readFileSync(inputFile).toString();
+  const code = fs__default$1.readFileSync(inputFile).toString();
   const { getZodSchemasFile } = generate({
     sourceText: removeGenericTypes(code)
   });
-  const fileName = Path$1.basename(inputFile);
-  let f = getZodSchemasFile(`./${fileName.replace(".ts", "")}`);
-  f = f.replaceAll('"./index";', '"./client"');
+  let f = getZodSchemasFile(getModuleImportPath(inputFile, outputFile));
   f = f.replaceAll(".optional()", ".nullable()");
   if (opts.localDateTimes) {
     f = f.replaceAll(
@@ -6275,52 +6949,30 @@ const generateSchemas = async (inputFile, outputFile, opts = {}) => {
     ...prettierConfig,
     filepath: outputFile
   });
-  fs__default.writeFileSync(outputFile, formatted);
+  fs__default$1.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 DEFAULT_GENERATOR = "api-client-generator";
-const generateApiClientParamsSchema = strictObject({
-  srcSpec: string().trim().min(1),
-  dstDir: string().trim().min(1),
-  apiName: string().trim().min(1),
-  generator: _enum(SUPPORTED_GENERATORS).default(DEFAULT_GENERATOR),
-  quirks: strictObject({
-    swaggerTsApiRequiredBooleans: boolean().optional()
-  }).optional(),
-  responseWrapper: strictObject({
-    symbol: string().trim().min(1),
-    import: string().trim().min(1).optional()
-  }).optional(),
-  ignoreOperationsWithTags: array(string()).optional(),
-  zodSchemas: strictObject({
-    enabled: boolean().optional(),
-    localDateTimes: boolean().optional()
-  }).optional()
-});
-const parseGenerateApiClientParams = (params) => {
-  const parsed = generateApiClientParamsSchema.safeParse(params);
-  if (parsed.success) return parsed.data;
-  throw new Error(prettifyError(parsed.error));
+const generateApiClient = async (params, configFilePath, log = console.log) => {
+  const config = parseProfileConfig(params, configFilePath);
+  return generateApiClientFromConfig(config, log);
 };
-const generateApiClient = async (params, log = console.log) => {
-  const {
-    dstDir,
-    apiName,
-    srcSpec,
-    quirks,
-    responseWrapper,
-    ignoreOperationsWithTags,
-    zodSchemas,
-    generator
-  } = parseGenerateApiClientParams(params);
-  const dir = Path$1.resolve(dstDir, apiName);
+const generateApiClientFromConfig = async (config, log = console.log) => {
+  const { dstDir, apiName, srcSpec, zodSchemas } = config;
+  const dir = Path.resolve(dstDir, apiName);
   if (!fs.existsSync(dir)) {
     log(`Creating dir ${dir}`);
     fs.mkdirSync(dir, {
       recursive: true
     });
   }
-  const clientDir = Path$1.resolve(dir, "client");
+  const clientDir = Path.resolve(dir, "client");
   const specPath = await getSpecPath(srcSpec, dir, log);
   log(`Cleaning client output dir ${clientDir}`);
   fs.rmSync(clientDir, {
@@ -6330,23 +6982,19 @@ const generateApiClient = async (params, log = console.log) => {
   fs.mkdirSync(clientDir, {
     recursive: true
   });
-  const clientFile = await generateOpenApiModel(
-    generator,
+  const { typesFilePath } = await generateOpenApiModel(
+    specPath,
     {
-      name: apiName,
-      input: specPath,
-      outputDir: clientDir,
-      quirks,
-      ignoreOperationsWithTags,
-      responseWrapper
+      ...config,
+      dstDir: clientDir
     },
     log
   );
   if (zodSchemas?.enabled === false) return;
   log("Generating Zod schemas");
   await generateSchemas(
-    Path$1.resolve(dir, clientFile),
-    Path$1.resolve(dir, "./zod.ts"),
+    typesFilePath,
+    Path.resolve(dir, "./zod.ts"),
     zodSchemas
   );
 };
@@ -6356,10 +7004,10 @@ const getSpecPath = async (urlOrPath, dir, log) => {
       throw new Error(`Spec file ${urlOrPath} does not exists`);
     return urlOrPath;
   }
-  const specPath = Path$1.resolve(dir, `spec.json`);
+  const specPath = Path.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 };