@workos/oagen 0.1.1 → 0.2.0

package/dist/scripts/smoke/baseline.js

@@ -1,1813 +0,0 @@
-// scripts/smoke/baseline.ts
-import { writeFileSync } from "fs";
-
-// src/errors.ts
-var OagenError = class extends Error {
-  hint;
-  constructor(message, hint) {
-    const fullMessage = hint ? `${message}
-Hint: ${hint}` : message;
-    super(fullMessage);
-    this.name = "OagenError";
-    this.hint = hint;
-  }
-};
-var SpecParseError = class extends OagenError {
-  constructor(message, hint) {
-    super(message, hint);
-    this.name = "SpecParseError";
-  }
-};
-
-// src/parser/refs.ts
-import { readFile } from "fs/promises";
-import { resolve } from "path";
-import { pathToFileURL } from "url";
-import { makeDocumentFromString, bundleDocument, createConfig, BaseResolver } from "@redocly/openapi-core";
-async function loadAndBundleSpec(specPath) {
-  const absolutePath = resolve(specPath);
-  const content = await readFile(absolutePath, "utf-8");
-  const document = makeDocumentFromString(content, pathToFileURL(absolutePath).href);
-  const config = await createConfig({});
-  const resolver = new BaseResolver();
-  const result = await bundleDocument({
-    document,
-    config: config.styleguide,
-    externalRefResolver: resolver,
-    dereference: false
-  });
-  if (result.problems.some((p) => p.severity === "error")) {
-    const errors = result.problems.filter((p) => p.severity === "error").map((p) => p.message).join("\n");
-    throw new SpecParseError(
-      `Failed to parse spec: ${errors}`,
-      `Check the OpenAPI spec at "${absolutePath}" for syntax errors. Run a linter such as \`npx @redocly/cli lint ${specPath}\` to identify issues.`
-    );
-  }
-  return {
-    parsed: result.bundle.parsed,
-    specPath: absolutePath
-  };
-}
-
-// src/ir/types.ts
-function assertNever(x) {
-  const kind = x.kind;
-  const err = new Error(
-    `Unexpected TypeRef kind: ${kind}
-Hint: If you added a new TypeRef variant, handle it in every switch/case that calls assertNever.`
-  );
-  err.name = "InternalError";
-  throw err;
-}
-function walkTypeRef(ref, visitor) {
-  switch (ref.kind) {
-    case "model":
-      visitor.model?.(ref);
-      break;
-    case "enum":
-      visitor.enum?.(ref);
-      break;
-    case "array":
-      walkTypeRef(ref.items, visitor);
-      break;
-    case "nullable":
-      walkTypeRef(ref.inner, visitor);
-      break;
-    case "union":
-      for (const v of ref.variants) walkTypeRef(v, visitor);
-      break;
-    case "map":
-      if (ref.keyType) walkTypeRef(ref.keyType, visitor);
-      walkTypeRef(ref.valueType, visitor);
-      break;
-    case "literal":
-      visitor.literal?.(ref);
-      break;
-    case "primitive":
-      visitor.primitive?.(ref);
-      break;
-    default:
-      assertNever(ref);
-  }
-}
-
-// src/utils/naming.ts
-function splitWords(s) {
-  if (!s) return [];
-  return s.replace(/[^a-zA-Z0-9_\-\s.]/g, "_").replace(/([a-z])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2").replace(/([a-zA-Z])(\d)/g, "$1\0$2").replace(/(\d)([a-zA-Z])/g, "$1\0$2").split(/[\0_\-\s.]+/).filter((w) => w.length > 0);
-}
-var ACRONYM_SET = /* @__PURE__ */ new Set(["SSO", "FGA", "SAML", "SCIM", "JWT", "HMAC"]);
-function toPascalCase(s, acronyms) {
-  const merged = acronyms ? /* @__PURE__ */ new Set([...ACRONYM_SET, ...acronyms]) : ACRONYM_SET;
-  return splitWords(s).map((w) => {
-    const upper = w.toUpperCase();
-    if (merged.has(upper)) return upper;
-    if (upper === "OAUTH") return "OAuth";
-    return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
-  }).join("");
-}
-function toCamelCase(s, acronyms) {
-  const merged = acronyms ? /* @__PURE__ */ new Set([...ACRONYM_SET, ...acronyms]) : ACRONYM_SET;
-  const words = splitWords(s);
-  if (words.length === 0) return "";
-  return words.map((w, i) => {
-    if (i === 0) return w.toLowerCase();
-    const upper = w.toUpperCase();
-    if (merged.has(upper)) return upper;
-    if (upper === "OAUTH") return "OAuth";
-    return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
-  }).join("");
-}
-function toSnakeCase(s) {
-  return splitWords(s).map((w) => w.toLowerCase()).join("_");
-}
-function toUpperSnakeCase(s) {
-  return splitWords(s).map((w) => w.toUpperCase()).join("_");
-}
-var BACKEND_SUFFIXES = ["Dto", "DTO", "Controller"];
-function stripBackendSuffixes(name) {
-  for (const suffix of BACKEND_SUFFIXES) {
-    if (name.endsWith(suffix) && name.length > suffix.length) {
-      return name.slice(0, -suffix.length);
-    }
-  }
-  return name;
-}
-function stripBackendPrefixes(name) {
-  return name.replace(/Userland/g, "").replace(/Controller/g, "");
-}
-function stripListItemMarkers(name) {
-  return name.replace(/ListItem/g, "").replace(/ByExternalId/g, "").replace(/ByResourceId/g, "").replace(/ForResource/g, "");
-}
-var SINGULAR_SAFE_LIST = /* @__PURE__ */ new Set([
-  "Status",
-  "Address",
-  "Access",
-  "Process",
-  "Progress",
-  "Success",
-  "Radius",
-  "Canvas",
-  "Alias",
-  "Basis",
-  "Bus"
-]);
-function singularize(word) {
-  if (SINGULAR_SAFE_LIST.has(word)) return word;
-  if (word.endsWith("ies") && word.length > 4) {
-    return word.slice(0, -3) + "y";
-  }
-  if (word.endsWith("ses") && word.length > 4) {
-    return word.slice(0, -2);
-  }
-  if (word.endsWith("s") && !word.endsWith("ss") && word.length > 4) {
-    return word.slice(0, -1);
-  }
-  return word;
-}
-function cleanSchemaName(name) {
-  let result = stripBackendPrefixes(stripBackendSuffixes(name));
-  result = stripListItemMarkers(result);
-  const match = result.match(/^([A-Z][a-z]*)/);
-  if (match) {
-    const leadWord = match[1];
-    const singular = singularize(leadWord);
-    if (singular !== leadWord) {
-      result = singular + result.slice(leadWord.length);
-    }
-  }
-  return result;
-}
-
-// src/parser/inline-models.ts
-function qualifyInlineModelName(baseName, parentName) {
-  if (!parentName) return baseName;
-  const cleanParent = stripListItemMarkers(parentName);
-  if (baseName.startsWith(cleanParent)) return baseName;
-  const trailingMatch = baseName.match(/^(.*?)([A-Z][a-z]*)$/);
-  if (trailingMatch) {
-    const [, prefix, trailingWord] = trailingMatch;
-    const singular = singularize(trailingWord);
-    return `${cleanParent}${prefix}${singular}`;
-  }
-  return `${cleanParent}${baseName}`;
-}
-function extractInlineModelsFromSchemas(schemas) {
-  if (!schemas) return [];
-  const inlineModels = [];
-  for (const [schemaName, schema] of Object.entries(schemas)) {
-    const parentName = cleanSchemaName(toPascalCase(schemaName));
-    extractInlineModelsFromProperties(schema, inlineModels, parentName);
-  }
-  return inlineModels;
-}
-function extractInlineModelsFromProperties(schema, results, parentName) {
-  const properties = schema.properties ?? {};
-  const allOfSchemas = schema.allOf ?? [];
-  for (const sub of allOfSchemas) {
-    if (sub.properties) {
-      extractInlineModelsFromProperties(sub, results, parentName);
-    }
-  }
-  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
-    if (!fieldSchema) continue;
-    if (fieldSchema.properties && (fieldSchema.type === "object" || !fieldSchema.type)) {
-      const baseName = toPascalCase(fieldName);
-      const modelName = qualifyInlineModelName(baseName, parentName);
-      results.push(buildInlineModel(modelName, fieldSchema));
-      extractInlineModelsFromProperties(fieldSchema, results, modelName);
-    }
-    if (fieldSchema.type === "array" && fieldSchema.items) {
-      const items = fieldSchema.items;
-      if (items.properties && (items.type === "object" || !items.type)) {
-        const baseName = toPascalCase(fieldName);
-        const modelName = qualifyInlineModelName(baseName, parentName);
-        results.push(buildInlineModel(modelName, items));
-        extractInlineModelsFromProperties(items, results, modelName);
-      }
-    }
-    if (fieldSchema.oneOf) {
-      const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
-      if (objectVariant) {
-        const baseName = toPascalCase(fieldName);
-        const modelName = qualifyInlineModelName(baseName, parentName);
-        const existingNames = new Set(results.map((r) => r.name));
-        if (!existingNames.has(modelName)) {
-          results.push(buildInlineModel(modelName, objectVariant));
-          extractInlineModelsFromProperties(objectVariant, results, modelName);
-        }
-      }
-    }
-  }
-}
-function buildInlineModel(name, schema) {
-  const requiredSet = new Set(schema.required ?? []);
-  const fields = [];
-  for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
-    if (!fieldSchema) continue;
-    fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
-  }
-  return { name, description: schema.description, fields };
-}
-
-// src/parser/schemas.ts
-function extractSchemas(schemas) {
-  const enums = [];
-  if (!schemas) return { models: [], enums };
-  const modelsByCleanName = /* @__PURE__ */ new Map();
-  for (const [name, schema] of Object.entries(schemas)) {
-    const pascalName = cleanSchemaName(toPascalCase(name));
-    if (schema.enum) {
-      enums.push(extractEnum(pascalName, schema));
-    } else {
-      const model = extractModel(pascalName, schema, schemas);
-      const existing = modelsByCleanName.get(pascalName);
-      if (existing) {
-        if (model.fields.length > existing.fields.length) {
-          modelsByCleanName.set(pascalName, model);
-        }
-      } else {
-        modelsByCleanName.set(pascalName, model);
-      }
-    }
-  }
-  const models = [...modelsByCleanName.values()];
-  const modelNames = new Set(models.map((m) => m.name));
-  const inlineQueue = [...models];
-  while (inlineQueue.length > 0) {
-    const model = inlineQueue.pop();
-    for (const field of model.fields) {
-      collectNestedInlineModels(field.type, field.name, model.name, schemas ?? {}, models, modelNames, inlineQueue);
-    }
-  }
-  for (const model of models) {
-    collectInlineEnums(model.fields, enums);
-  }
-  return { models, enums };
-}
-function collectInlineEnumFromRef(ref, enums, seen) {
-  walkTypeRef(ref, {
-    enum: (r) => {
-      if (r.values && !seen.has(r.name)) {
-        seen.add(r.name);
-        enums.push({
-          name: r.name,
-          values: r.values.map((v) => ({
-            name: toUpperSnakeCase(String(v)),
-            value: v,
-            description: void 0
-          }))
-        });
-      }
-    }
-  });
-}
-function collectInlineEnums(fields, enums) {
-  const seen = new Set(enums.map((e) => e.name));
-  for (const field of fields) {
-    collectInlineEnumFromRef(field.type, enums, seen);
-  }
-}
-function collectNestedInlineModels(ref, fieldName, parentModelName, schemas, models, modelNames, queue) {
-  walkTypeRef(ref, {
-    model: (modelRef) => {
-      if (modelNames.has(modelRef.name)) return;
-      const isComponent = Object.keys(schemas).some((k) => cleanSchemaName(toPascalCase(k)) === modelRef.name);
-      if (isComponent) return;
-      const parentSchema = findSchemaByName(parentModelName, schemas);
-      if (!parentSchema) return;
-      const fieldSchema = findNestedFieldSchema(fieldName, parentSchema, schemas);
-      if (!fieldSchema) return;
-      const extracted = extractNestedSchema(modelRef.name, fieldSchema);
-      for (const m of extracted) {
-        if (!modelNames.has(m.name)) {
-          models.push(m);
-          modelNames.add(m.name);
-          queue.push(m);
-        }
-      }
-    }
-  });
-}
-function findSchemaByName(pascalName, schemas) {
-  for (const [k, v] of Object.entries(schemas)) {
-    if (cleanSchemaName(toPascalCase(k)) === pascalName) return v;
-  }
-  return null;
-}
-function findNestedFieldSchema(fieldName, parentSchema, schemas) {
-  if (parentSchema.properties?.[fieldName]) {
-    return parentSchema.properties[fieldName];
-  }
-  if (parentSchema.allOf) {
-    for (const sub of parentSchema.allOf) {
-      let resolved = sub;
-      if (sub.$ref) {
-        const segments = sub.$ref.split("/");
-        const refName = segments[segments.length - 1];
-        if (refName && schemas[refName]) resolved = schemas[refName];
-      }
-      if (resolved.properties?.[fieldName]) {
-        return resolved.properties[fieldName];
-      }
-    }
-  }
-  return null;
-}
-function extractNestedSchema(name, schema) {
-  if (schema.oneOf) {
-    const models = [];
-    for (const variant of schema.oneOf) {
-      if (variant.$ref) continue;
-      if (variant.properties && (variant.type === "object" || !variant.type)) {
-        const requiredSet = new Set(variant.required ?? []);
-        const fields = [];
-        for (const [fn, fs] of Object.entries(variant.properties)) {
-          if (!fs) continue;
-          fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
-        }
-        const variantName = models.length === 0 ? name : `${name}${models.length + 1}`;
-        models.push({ name: variantName, description: variant.description, fields });
-      }
-    }
-    return models;
-  }
-  if (schema.properties && (schema.type === "object" || !schema.type)) {
-    const requiredSet = new Set(schema.required ?? []);
-    const fields = [];
-    for (const [fn, fs] of Object.entries(schema.properties)) {
-      if (!fs) continue;
-      fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
-    }
-    return [{ name, description: schema.description, fields }];
-  }
-  if (schema.type === "array" && schema.items?.properties) {
-    const requiredSet = new Set(schema.items.required ?? []);
-    const fields = [];
-    for (const [fn, fs] of Object.entries(schema.items.properties)) {
-      if (!fs) continue;
-      fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
-    }
-    return [{ name, description: schema.items.description, fields }];
-  }
-  return [];
-}
-function buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet) {
-  return {
-    name: fieldName,
-    type: schemaToTypeRef(fieldSchema, fieldName, contextName),
-    required: requiredSet.has(fieldName),
-    description: fieldSchema.description,
-    readOnly: fieldSchema.readOnly || void 0,
-    writeOnly: fieldSchema.writeOnly || void 0,
-    deprecated: fieldSchema.deprecated || void 0,
-    default: fieldSchema.default
-  };
-}
-function extractEnum(name, schema) {
-  const values = (schema.enum ?? []).map((v) => ({
-    name: toUpperSnakeCase(String(v)),
-    value: typeof v === "number" ? v : String(v),
-    description: void 0
-  }));
-  return { name, values };
-}
-function extractModel(name, schema, schemas) {
-  if (schema.allOf) {
-    return extractAllOfModel(name, schema, schemas);
-  }
-  const requiredSet = new Set(schema.required ?? []);
-  const fields = [];
-  for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
-    if (!fieldSchema) continue;
-    fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
-  }
-  if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schema.properties) {
-    const apKeys = Object.keys(schema.additionalProperties);
-    if (apKeys.length > 0) {
-      const valueType = schemaToTypeRef(schema.additionalProperties, "additionalProperties", name);
-      fields.push({
-        name: "additionalProperties",
-        type: { kind: "map", valueType },
-        required: false,
-        description: "Additional properties not captured by named fields"
-      });
-    }
-  }
-  return { name, description: schema.description, fields };
-}
-function extractAllOfModel(name, schema, schemas) {
-  const fields = [];
-  const requiredSet = /* @__PURE__ */ new Set();
-  for (const subSchema of schema.allOf ?? []) {
-    let resolved = subSchema;
-    if (subSchema.$ref && schemas) {
-      const segments = subSchema.$ref.split("/");
-      const refName = segments[segments.length - 1];
-      if (refName && schemas[refName]) {
-        resolved = schemas[refName];
-      }
-    }
-    if (resolved.allOf) {
-      const nested = extractAllOfModel(name, resolved, schemas);
-      for (const f of nested.fields) {
-        fields.push({ ...f, required: false });
-        if (f.required) requiredSet.add(f.name);
-      }
-    } else {
-      if (resolved.required) {
-        for (const r of resolved.required) requiredSet.add(r);
-      }
-      if (resolved.properties) {
-        const emptyRequired = /* @__PURE__ */ new Set();
-        for (const [fieldName, fieldSchema] of Object.entries(resolved.properties)) {
-          if (!fieldSchema) continue;
-          fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, emptyRequired));
-        }
-      }
-    }
-  }
-  if (schema.required) {
-    for (const r of schema.required) requiredSet.add(r);
-  }
-  for (const f of fields) {
-    f.required = requiredSet.has(f.name);
-  }
-  return { name, description: schema.description, fields };
-}
-function schemaToTypeRef(schema, contextName, parentModelName) {
-  if (schema.$ref) {
-    const segments = schema.$ref.split("/");
-    const rawName = segments[segments.length - 1];
-    return { kind: "model", name: cleanSchemaName(toPascalCase(rawName)) };
-  }
-  if (Array.isArray(schema.type)) {
-    const nonNullTypes = schema.type.filter((t) => t !== "null");
-    if (nonNullTypes.length === 0) {
-      return { kind: "nullable", inner: { kind: "primitive", type: "unknown" } };
-    }
-    if (schema.type.includes("null") && nonNullTypes.length === 1) {
-      return {
-        kind: "nullable",
-        inner: schemaToTypeRef({ ...schema, type: nonNullTypes[0], nullable: false }, contextName)
-      };
-    }
-    if (nonNullTypes.length > 1) {
-      const variants = nonNullTypes.map((t) => schemaToTypeRef({ ...schema, type: t }, contextName));
-      const ref = { kind: "union", variants };
-      if (schema.type.includes("null")) {
-        return { kind: "nullable", inner: ref };
-      }
-      return ref;
-    }
-  }
-  if (schema.nullable && schema.type) {
-    return {
-      kind: "nullable",
-      inner: schemaToTypeRef({ ...schema, nullable: false }, contextName)
-    };
-  }
-  if (schema.allOf) {
-    const refItem = schema.allOf.find((s) => s.$ref);
-    if (refItem) {
-      const hasAugmentation = schema.allOf.some((s) => !s.$ref && (s.properties || s.type === "object"));
-      if (hasAugmentation) {
-        const baseName = toPascalCase(contextName ?? "UnknownModel");
-        return { kind: "model", name: qualifyInlineModelName(baseName, parentModelName) };
-      }
-      return schemaToTypeRef(refItem, contextName, parentModelName);
-    }
-    if (schema.allOf.length === 1) {
-      return schemaToTypeRef(schema.allOf[0], contextName, parentModelName);
-    }
-    const hasProperties = schema.allOf.some((s) => s.properties);
-    if (hasProperties) {
-      const baseName = toPascalCase(contextName ?? "UnknownModel");
-      return {
-        kind: "model",
-        name: qualifyInlineModelName(baseName, parentModelName)
-      };
-    }
-  }
-  if (schema.oneOf || schema.anyOf) {
-    const compositionKind = schema.oneOf ? "oneOf" : "anyOf";
-    const rawVariants = schema.oneOf ?? schema.anyOf ?? [];
-    const nullVariant = rawVariants.find(
-      (v) => v.type === "null" || Array.isArray(v.type) && v.type.length === 1 && v.type[0] === "null"
-    );
-    const nonNullVariants = rawVariants.filter((v) => v !== nullVariant);
-    if (nullVariant && nonNullVariants.length === 1) {
-      return {
-        kind: "nullable",
-        inner: schemaToTypeRef(nonNullVariants[0], contextName, parentModelName)
-      };
-    }
-    const variants = rawVariants.filter((v) => v.type !== "null").map((v) => schemaToTypeRef(v, contextName, parentModelName));
-    const hasNull = !!nullVariant;
-    const union = {
-      kind: "union",
-      variants,
-      compositionKind,
-      ...schema.discriminator ? {
-        discriminator: {
-          property: schema.discriminator.propertyName,
-          mapping: Object.fromEntries(
-            Object.entries(schema.discriminator.mapping ?? {}).map(([k, v]) => [
-              k,
-              v.replace(/^#\/components\/schemas\//, "")
-            ])
-          )
-        }
-      } : {}
-    };
-    return hasNull ? { kind: "nullable", inner: union } : union;
-  }
-  if (schema.const !== void 0) {
-    if (typeof schema.const === "string" || typeof schema.const === "number" || typeof schema.const === "boolean") {
-      return { kind: "literal", value: schema.const };
-    }
-    if (schema.const === null) {
-      return { kind: "nullable", inner: { kind: "primitive", type: "unknown" } };
-    }
-    if (typeof schema.const === "object") {
-      if (Array.isArray(schema.const)) {
-        return { kind: "array", items: { kind: "primitive", type: "unknown" } };
-      }
-      return { kind: "map", valueType: { kind: "primitive", type: "unknown" } };
-    }
-  }
-  if (schema.enum && schema.enum.length === 1) {
-    const v = schema.enum[0];
-    return { kind: "literal", value: typeof v === "number" ? v : String(v) };
-  }
-  if (schema.enum) {
-    const baseName = toPascalCase(contextName ?? "UnknownEnum");
-    const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
-    const qualifiedName = cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName;
-    return {
-      kind: "enum",
-      name: qualifiedName,
-      values: schema.enum.map((v) => typeof v === "number" ? v : String(v))
-    };
-  }
-  if (schema.type === "array" && schema.items) {
-    return {
-      kind: "array",
-      items: schemaToTypeRef(schema.items, contextName, parentModelName)
-    };
-  }
-  if (!schema.type && schema.items) {
-    return {
-      kind: "array",
-      items: schemaToTypeRef(schema.items, contextName, parentModelName)
-    };
-  }
-  if (schema.type === "object" && schema.properties) {
-    const baseName = toPascalCase(contextName ?? "UnknownModel");
-    return {
-      kind: "model",
-      name: qualifyInlineModelName(baseName, parentModelName)
-    };
-  }
-  if (schema.type === "object" && !schema.properties) {
-    let valueType = { kind: "primitive", type: "unknown" };
-    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-      const apKeys = Object.keys(schema.additionalProperties);
-      if (apKeys.length > 0) {
-        valueType = schemaToTypeRef(schema.additionalProperties, contextName);
-      }
-    } else if (schema.patternProperties) {
-      const patterns = Object.values(schema.patternProperties);
-      if (patterns.length > 0) {
-        valueType = schemaToTypeRef(patterns[0], contextName);
-      }
-    }
-    return {
-      kind: "map",
-      valueType
-    };
-  }
-  const primitiveMap = {
-    string: "string",
-    integer: "integer",
-    number: "number",
-    boolean: "boolean"
-  };
-  const typeStr = Array.isArray(schema.type) ? schema.type[0] : schema.type;
-  if (typeStr && primitiveMap[typeStr]) {
-    return {
-      kind: "primitive",
-      type: primitiveMap[typeStr],
-      ...schema.format ? { format: schema.format } : {}
-    };
-  }
-  if (!schema.type && schema.properties) {
-    const baseName = toPascalCase(contextName ?? "UnknownModel");
-    return {
-      kind: "model",
-      name: qualifyInlineModelName(baseName, parentModelName)
-    };
-  }
-  if (!schema.type && !schema.$ref && !schema.oneOf && !schema.anyOf && !schema.allOf && !schema.enum && !schema.properties && !schema.items) {
-    return { kind: "primitive", type: "unknown" };
-  }
-  if (contextName) {
-    console.warn(`[oagen] Warning: Unknown schema shape treated as unknown (context: ${contextName})`);
-  }
-  return { kind: "primitive", type: "unknown" };
-}
-
-// src/parser/pagination.ts
-var CURSOR_PARAMS = ["cursor", "after", "before", "starting_after", "ending_before", "page_token", "next_token"];
-var OFFSET_PARAMS = ["offset", "page", "page_number", "skip"];
-var LIMIT_PARAMS = ["limit", "page_size", "per_page", "size", "count"];
-function detectPagination(response, queryParams, dataPath) {
-  const cursorParam = queryParams.find((p) => CURSOR_PARAMS.includes(p.name));
-  if (cursorParam) {
-    const itemType = response.kind === "array" ? response.items : response;
-    return {
-      strategy: "cursor",
-      param: cursorParam.name,
-      dataPath,
-      itemType
-    };
-  }
-  const offsetParam = queryParams.find((p) => OFFSET_PARAMS.includes(p.name));
-  const limitParam = queryParams.find((p) => LIMIT_PARAMS.includes(p.name));
-  if (offsetParam && limitParam) {
-    const itemType = response.kind === "array" ? response.items : response;
-    return {
-      strategy: "offset",
-      param: offsetParam.name,
-      limitParam: limitParam.name,
-      dataPath,
-      itemType
-    };
-  }
-  return null;
-}
-
-// src/parser/responses.ts
-function classifyAndExtractResponse(schema, contextName) {
-  if (schema.$ref) {
-    return { response: schemaToTypeRef(schema, contextName), inlineModels: [], isPaginated: false };
-  }
-  const envelope = detectListEnvelope(schema);
-  if (envelope.isEnvelope) {
-    return extractListResponse(schema, contextName, envelope.dataPath);
-  }
-  if (isSingleResourceWrapper(schema)) {
-    return extractWrappedResource(schema, contextName);
-  }
-  return extractDirectResource(schema, contextName);
-}
-var KNOWN_DATA_PATHS = /* @__PURE__ */ new Set(["data", "items", "results", "records", "entries", "values", "nodes", "edges"]);
-var PAGINATION_METADATA_PATTERNS = [
-  "metadata",
-  "pagination",
-  "cursor",
-  "has_more",
-  "page_info",
-  "total",
-  "next_page",
-  "previous_page",
-  "offset"
-];
-function detectListEnvelope(schema) {
-  const propSources = [];
-  if (schema.allOf) {
-    for (const sub of schema.allOf) {
-      if (sub.properties) propSources.push(sub.properties);
-    }
-  }
-  if (schema.properties) {
-    propSources.push(schema.properties);
-  }
-  if (propSources.length === 0) return { isEnvelope: false, dataPath: null };
-  const mergedProps = {};
-  for (const source of propSources) {
-    Object.assign(mergedProps, source);
-  }
-  const arrayProps = [];
-  const nonArrayKeys = [];
-  for (const [key, propSchema] of Object.entries(mergedProps)) {
-    if (!propSchema) continue;
-    if (propSchema.type === "array") {
-      arrayProps.push(key);
-    } else {
-      nonArrayKeys.push(key);
-    }
-  }
-  if (arrayProps.length === 1 && nonArrayKeys.length >= 1) {
-    const arrayPropName = arrayProps[0];
-    if (KNOWN_DATA_PATHS.has(arrayPropName)) {
-      return { isEnvelope: true, dataPath: arrayPropName };
-    }
-    const hasPaginationCompanion = nonArrayKeys.some(
-      (key) => PAGINATION_METADATA_PATTERNS.some((pattern) => key.toLowerCase().includes(pattern))
-    );
-    if (hasPaginationCompanion) {
-      return { isEnvelope: true, dataPath: arrayPropName };
-    }
-  }
-  return { isEnvelope: false, dataPath: null };
-}
-function extractListResponse(schema, contextName, dataPath) {
-  let itemTypeRef = { kind: "primitive", type: "string" };
-  const inlineModels = [];
-  const propSources = [];
-  if (schema.allOf) {
-    for (const sub of schema.allOf) {
-      if (sub.properties) propSources.push(sub.properties);
-    }
-  }
-  if (schema.properties) {
-    propSources.push(schema.properties);
-  }
-  for (const props of propSources) {
-    const dataProp = props[dataPath];
-    if (!dataProp) continue;
-    if (dataProp.type === "array" && dataProp.items) {
-      const items = dataProp.items;
-      if (items.$ref) {
-        itemTypeRef = schemaToTypeRef(items, contextName);
-      } else if (items.type === "object" && items.properties) {
-        const itemName = contextName.replace(/Response$/, "") + "Item";
-        itemTypeRef = { kind: "model", name: itemName };
-        inlineModels.push(...extractInlineModel(itemName, items));
-      }
-    }
-  }
-  return {
-    response: { kind: "array", items: itemTypeRef },
-    inlineModels,
-    isPaginated: true,
-    dataPath,
-    itemType: itemTypeRef
-  };
-}
-function hasDiscriminantConstField(schema) {
-  if (!schema.properties) return null;
-  const preferred = ["object", "type"];
-  for (const name of preferred) {
-    const field = schema.properties[name];
-    if (!field) continue;
-    if (field.const !== void 0 && typeof field.const === "string") {
-      return { property: name, value: field.const };
-    }
-    if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") {
-      return { property: name, value: field.enum[0] };
-    }
-  }
-  for (const [name, field] of Object.entries(schema.properties)) {
-    if (!field) continue;
-    if (field.const !== void 0 && typeof field.const === "string") {
-      return { property: name, value: field.const };
-    }
-    if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") {
-      return { property: name, value: field.enum[0] };
-    }
-  }
-  return null;
-}
-function isSingleResourceWrapper(schema) {
-  if (schema.type !== "object") return false;
-  if (!schema.properties) return false;
-  let wrapperKey;
-  if (schema.required && schema.required.length === 1) {
-    wrapperKey = schema.required[0];
-  } else {
-    const propKeys = Object.keys(schema.properties);
-    if (propKeys.length === 1) {
-      wrapperKey = propKeys[0];
-    }
-  }
-  if (!wrapperKey) return false;
-  const propSchema = schema.properties[wrapperKey];
-  if (!propSchema) return false;
-  if (propSchema.type === "object" && hasDiscriminantConstField(propSchema) !== null) return true;
-  if (propSchema.oneOf) {
-    return propSchema.oneOf.some((v) => v.type === "object" && hasDiscriminantConstField(v) !== null);
-  }
-  return false;
-}
-function extractWrappedResource(schema, contextName) {
-  const props = schema.properties;
-  const wrapperKey = schema.required && schema.required.length === 1 ? schema.required[0] : Object.keys(props)[0];
-  const propSchema = props[wrapperKey];
-  const inlineModels = [];
-  const resourceName = contextName.replace(/Response$/, "");
-  if (propSchema.oneOf) {
-    const objectVariant = propSchema.oneOf.find((v) => v.type === "object" && hasDiscriminantConstField(v) !== null);
-    if (objectVariant) {
-      const modelName2 = deriveModelName(objectVariant, resourceName);
-      inlineModels.push(...extractInlineModel(modelName2, objectVariant));
-      const hasNullVariant = propSchema.oneOf.some(
-        (v) => v.type === "null" || Array.isArray(v.type) && v.type.includes("null")
-      );
-      const modelRef = { kind: "model", name: modelName2 };
-      return {
-        response: hasNullVariant ? { kind: "nullable", inner: modelRef } : modelRef,
-        inlineModels,
-        isPaginated: false
-      };
-    }
-  }
-  const modelName = deriveModelName(propSchema, resourceName);
-  inlineModels.push(...extractInlineModel(modelName, propSchema));
-  return {
-    response: { kind: "model", name: modelName },
-    inlineModels,
-    isPaginated: false
-  };
-}
-function extractDirectResource(schema, contextName) {
-  const inlineModels = [];
-  if (schema.properties && (schema.type === "object" || !schema.type)) {
-    const modelName = deriveModelName(schema, contextName);
-    inlineModels.push(...extractInlineModel(modelName, schema));
-    return {
-      response: { kind: "model", name: modelName },
-      inlineModels,
-      isPaginated: false
-    };
-  }
-  if (schema.allOf) {
-    const mergedProperties = {};
-    const mergedRequired = [];
-    for (const sub of schema.allOf) {
-      if (sub.properties) {
-        Object.assign(mergedProperties, sub.properties);
-      }
-      if (sub.required) {
-        mergedRequired.push(...sub.required);
-      }
-    }
-    if (Object.keys(mergedProperties).length > 0) {
-      const merged = { type: "object", properties: mergedProperties, required: mergedRequired };
-      const modelName = deriveModelName(merged, contextName);
-      inlineModels.push(...extractInlineModel(modelName, merged));
-      return {
-        response: { kind: "model", name: modelName },
-        inlineModels,
-        isPaginated: false
-      };
-    }
-  }
-  if (schema.oneOf) {
-    for (const variant of schema.oneOf) {
-      if (variant.properties && (variant.type === "object" || !variant.type)) {
-        const modelName = deriveModelName(variant, contextName);
-        const existingNames = new Set(inlineModels.map((m) => m.name));
-        if (!existingNames.has(modelName)) {
-          inlineModels.push(...extractInlineModel(modelName, variant));
-        }
-      }
-    }
-  }
-  if (schema.type === "array" && schema.items) {
-    const items = schema.items;
-    if (items.$ref) {
-      return {
-        response: { kind: "array", items: schemaToTypeRef(items, contextName) },
-        inlineModels,
-        isPaginated: false
-      };
-    }
-    if (items.properties && (items.type === "object" || !items.type)) {
-      const itemName = contextName.replace(/Response$/, "") + "Item";
-      inlineModels.push(...extractInlineModel(itemName, items));
-      return {
-        response: { kind: "array", items: { kind: "model", name: itemName } },
-        inlineModels,
-        isPaginated: false
-      };
-    }
-  }
-  return {
-    response: schemaToTypeRef(schema, contextName),
-    inlineModels,
-    isPaginated: false
-  };
-}
-function deriveModelName(schema, fallback) {
-  if (!schema.properties) return toPascalCase(fallback);
-  const preferred = ["object", "type"];
-  for (const name of preferred) {
-    const field = schema.properties[name];
-    if (field && field.const && typeof field.const === "string") {
-      return toPascalCase(field.const);
-    }
-  }
-  for (const [, field] of Object.entries(schema.properties)) {
-    if (field && field.const && typeof field.const === "string") {
-      return toPascalCase(field.const);
-    }
-  }
-  return toPascalCase(fallback);
-}
-function qualifyNestedName(parentName, fieldName) {
-  const pascalField = toPascalCase(fieldName);
-  if (pascalField.startsWith(parentName)) return pascalField;
-  const cleanParent = stripListItemMarkers(parentName);
-  const qualified = `${cleanParent}${pascalField}`;
-  const match = qualified.match(/^(.+?)([A-Z][a-z]+s?)$/);
-  if (match && match[2]) {
-    const trailing = singularize(match[2]);
-    return match[1] + trailing;
-  }
-  return qualified;
-}
-function extractInlineModel(name, schema) {
-  const requiredSet = new Set(schema.required ?? []);
-  const fields = [];
-  const properties = schema.properties ?? {};
-  const nestedModels = [];
-  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
-    if (!fieldSchema) continue;
-    fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
-    if (fieldSchema.type === "object" && fieldSchema.properties) {
-      const nestedName = qualifyNestedName(name, fieldName);
-      nestedModels.push(...extractInlineModel(nestedName, fieldSchema));
-    }
-    if (fieldSchema.type === "array" && fieldSchema.items) {
-      const items = fieldSchema.items;
-      if (items.type === "object" && items.properties) {
-        const nestedName = qualifyNestedName(name, fieldName);
-        nestedModels.push(...extractInlineModel(nestedName, items));
-      }
-    }
-    if (fieldSchema.allOf) {
-      const mergedProperties = {};
-      const mergedRequired = [];
-      for (const sub of fieldSchema.allOf) {
-        if (sub.properties) Object.assign(mergedProperties, sub.properties);
-        if (sub.required) mergedRequired.push(...sub.required);
-      }
-      if (Object.keys(mergedProperties).length > 0) {
-        const nestedName = qualifyNestedName(name, fieldName);
-        const merged = { type: "object", properties: mergedProperties, required: mergedRequired };
-        const existingNames = new Set(nestedModels.map((m) => m.name));
-        if (!existingNames.has(nestedName)) {
-          nestedModels.push(...extractInlineModel(nestedName, merged));
-        }
-      }
-    }
-    if (fieldSchema.oneOf) {
-      const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
-      if (objectVariant) {
-        const nestedName = qualifyNestedName(name, fieldName);
-        const existingNames = new Set(nestedModels.map((m) => m.name));
-        if (!existingNames.has(nestedName)) {
-          nestedModels.push(...extractInlineModel(nestedName, objectVariant));
-        }
-      }
-    }
-  }
-  return [{ name, description: schema.description, fields }, ...nestedModels];
-}
-
-// src/parser/operations.ts
-var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
-function extractOperations(paths, operationIdTransform) {
-  if (!paths) return { services: [], inlineModels: [] };
-  const serviceMap = /* @__PURE__ */ new Map();
-  const inlineModels = [];
-  for (const [path, pathItem] of Object.entries(paths)) {
-    const pathLevelParams = pathItem.parameters ?? [];
-    for (const method of HTTP_METHODS) {
-      const op = pathItem[method];
-      if (!op) continue;
-      const serviceName = inferServiceName(path, op.tags?.[0]);
-      const { operation, inlineModels: opModels } = buildOperation(
-        method,
-        path,
-        op,
-        pathLevelParams,
-        operationIdTransform
-      );
-      inlineModels.push(...opModels);
-      const ops = serviceMap.get(serviceName) ?? [];
-      ops.push(operation);
-      serviceMap.set(serviceName, ops);
-    }
-  }
-  for (const [, operations] of serviceMap) {
-    disambiguateOperationNames(operations);
-  }
-  const services = Array.from(serviceMap.entries()).map(([name, operations]) => ({
-    name,
-    operations
-  }));
-  return { services, inlineModels };
-}
-function inferServiceName(path, tag) {
-  if (tag) {
-    return toPascalCase(tag);
-  }
-  const segments = path.split("/").filter(Boolean);
-  const first = segments[0] ?? "Default";
-  if (first.startsWith("{")) return "Default";
-  return toPascalCase(first);
-}
-function inferOperationName(method, path, operationId, operationIdTransform) {
-  if (operationId) {
-    if (operationIdTransform) {
-      return operationIdTransform(operationId);
-    }
-    return toCamelCase(operationId);
-  }
-  const verb = inferVerb(method, path);
-  const resource = inferResourceFromPath(path);
-  return resource ? toCamelCase(`${verb}_${resource}`) : verb;
-}
-function inferVerb(method, path) {
-  const segments = path.split("/").filter(Boolean);
-  const hasTrailingParam = segments.length > 0 && segments[segments.length - 1].startsWith("{");
-  switch (method) {
-    case "get":
-      return hasTrailingParam ? "get" : "list";
-    case "post":
-      return "create";
-    case "put":
-    case "patch":
-      return "update";
-    case "delete":
-      return "delete";
-    case "head":
-      return "check";
-    case "options":
-      return "options";
-    case "trace":
-      return "trace";
-    default:
-      return method;
-  }
-}
-function inferResourceFromPath(path) {
-  const segments = path.split("/").filter(Boolean);
-  if (segments.length <= 1) return null;
-  let resourceSegment = null;
-  for (let i = segments.length - 1; i >= 0; i--) {
-    if (!segments[i].startsWith("{")) {
-      resourceSegment = segments[i];
-      break;
-    }
-  }
-  if (!resourceSegment) return null;
-  if (resourceSegment === segments[0]) return null;
-  return toPascalCase(resourceSegment);
-}
-function disambiguateOperationNames(operations) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const op of operations) {
-    const group = byName.get(op.name) ?? [];
-    group.push(op);
-    byName.set(op.name, group);
-  }
-  for (const [name, group] of byName) {
-    if (group.length <= 1) continue;
-    const uniquePaths = new Set(group.map((op) => op.path));
-    if (uniquePaths.size <= 1) continue;
-    for (const op of group) {
-      const resource = inferResourceFromPath(op.path);
-      if (resource) {
-        const newName = toCamelCase(`${name}_${resource}`);
-        op.name = newName;
-      }
-    }
-    const renamed = /* @__PURE__ */ new Map();
-    for (const op of group) {
-      const rGroup = renamed.get(op.name) ?? [];
-      rGroup.push(op);
-      renamed.set(op.name, rGroup);
-    }
-    for (const [, rGroup] of renamed) {
-      if (rGroup.length <= 1) continue;
-      for (const op of rGroup) {
-        const deeper = inferDeeperContext(op.path);
-        if (deeper) {
-          op.name = toCamelCase(`${op.name}_${deeper}`);
-        }
-      }
-    }
-  }
-}
-function inferDeeperContext(path) {
-  const segments = path.split("/").filter(Boolean);
-  const nonParams = segments.filter((s) => !s.startsWith("{"));
-  if (nonParams.length >= 3) {
-    return toPascalCase(nonParams.slice(1, -1).join("_"));
-  }
-  return null;
-}
-function buildOperation(method, path, op, pathLevelParams, operationIdTransform) {
-  const allParams = [...pathLevelParams, ...op.parameters ?? []];
-  const hasIdempotencyHeader = allParams.some((p) => p.in === "header" && p.name.toLowerCase() === "idempotency-key");
-  const pathParams = extractParams(allParams, "path");
-  const queryParams = extractParams(allParams, "query");
-  const headerParams = extractParams(allParams, "header").filter((p) => p.name.toLowerCase() !== "idempotency-key");
-  const cookieParams = extractParams(allParams, "cookie");
-  const reqBodyModels = [];
-  const { body: requestBody, encoding: requestBodyEncoding } = extractRequestBody(op.requestBody, op, reqBodyModels);
-  const {
-    response,
-    successResponses,
-    errors,
-    inlineModels,
-    isPaginated,
-    dataPath: responseDataPath,
-    itemType: responseItemType
-  } = extractResponses(op.responses, op, path, method);
-  inlineModels.push(...reqBodyModels);
-  const paginationFromParams = detectPagination(response, queryParams, responseDataPath);
-  let pagination;
-  if (isPaginated) {
-    const itemType = responseItemType ?? (response.kind === "array" ? response.items : response);
-    pagination = {
-      strategy: paginationFromParams?.strategy ?? "cursor",
-      param: paginationFromParams?.param ?? "after",
-      limitParam: paginationFromParams?.limitParam,
-      dataPath: responseDataPath ?? paginationFromParams?.dataPath,
-      itemType
-    };
-  } else if (paginationFromParams) {
-    pagination = paginationFromParams;
-  }
-  return {
-    operation: {
-      name: inferOperationName(method, path, op.operationId, operationIdTransform),
-      description: buildDescription(op.summary, op.description),
-      httpMethod: method,
-      path,
-      pathParams,
-      queryParams,
-      headerParams,
-      cookieParams: cookieParams.length > 0 ? cookieParams : void 0,
-      requestBody,
-      requestBodyEncoding,
-      response,
-      successResponses,
-      errors,
-      pagination,
-      injectIdempotencyKey: hasIdempotencyHeader,
-      deprecated: op.deprecated || void 0,
-      async: op["x-oagen-async"]
-    },
-    inlineModels
-  };
-}
-function buildDescription(summary, description) {
-  if (summary && description && summary !== description) {
-    return `${summary}
-
-${description}`;
-  }
-  return description ?? summary;
-}
-function extractParams(params, location) {
-  return params.filter((p) => p.in === location).map((p) => ({
-    name: p.name,
-    type: p.schema ? schemaToTypeRef(p.schema, p.name) : { kind: "primitive", type: "string" },
-    required: p.required ?? false,
-    description: p.description,
-    deprecated: p.deprecated || p.schema?.deprecated || void 0,
-    default: p.schema?.default,
-    example: p.example ?? p.schema?.example
-  }));
-}
-function extractRequestBody(body, op, inlineModels) {
-  if (!body?.content) return {};
-  let encoding = "json";
-  let schema;
-  if (body.content["application/json"]?.schema) {
-    encoding = "json";
-    schema = body.content["application/json"].schema;
-  } else if (body.content["multipart/form-data"]?.schema) {
-    encoding = "form-data";
-    schema = body.content["multipart/form-data"].schema;
-  } else if (body.content["application/x-www-form-urlencoded"]?.schema) {
-    encoding = "form-urlencoded";
-    schema = body.content["application/x-www-form-urlencoded"].schema;
-  } else if (body.content["application/octet-stream"]) {
-    encoding = "binary";
-    schema = body.content["application/octet-stream"].schema;
-  } else if (body.content["text/plain"]) {
-    encoding = "text";
-    schema = body.content["text/plain"].schema;
-  }
-  if (!schema) {
-    if (encoding === "binary") {
-      return { body: { kind: "primitive", type: "string", format: "binary" }, encoding };
-    }
-    if (encoding === "text") {
-      return { body: { kind: "primitive", type: "string" }, encoding };
-    }
-    return {};
-  }
-  const rawName = op?.operationId ? toPascalCase(op.operationId) + "Request" : "RequestBody";
-  const contextName = cleanSchemaName(rawName);
-  if (schema.properties && (schema.type === "object" || !schema.type)) {
-    const requiredSet = new Set(schema.required ?? []);
-    const fields = [];
-    for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
-      if (!fieldSchema) continue;
-      fields.push(buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet));
-    }
-    inlineModels.push({ name: contextName, description: void 0, fields });
-    return { body: { kind: "model", name: contextName }, encoding };
-  }
-  if (schema.oneOf) {
-    const variants = [];
-    for (const variant of schema.oneOf) {
-      if (variant.$ref) {
-        const ref = schemaToTypeRef(variant, contextName);
-        variants.push(ref);
-      } else if (variant.type === "null") {
-      } else if (variant.properties && (variant.type === "object" || !variant.type)) {
-        const variantName = deriveOneOfVariantName(variant, contextName, inlineModels);
-        const requiredSet = new Set(variant.required ?? []);
-        const fields = [];
-        for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
-          if (!fieldSchema) continue;
-          fields.push(buildFieldFromSchema(fieldName, fieldSchema, variantName, requiredSet));
-        }
-        inlineModels.push({ name: variantName, description: variant.description, fields });
-        variants.push({ kind: "model", name: variantName });
-      } else {
-        variants.push(schemaToTypeRef(variant, contextName));
-      }
-    }
-    const hasNull = schema.oneOf.some(
-      (v) => v.type === "null" || Array.isArray(v.type) && v.type.includes("null")
-    );
-    const union = {
-      kind: "union",
-      variants,
-      ...schema.discriminator ? {
-        discriminator: { property: schema.discriminator.propertyName, mapping: schema.discriminator.mapping ?? {} }
-      } : {}
-    };
-    const body2 = hasNull ? { kind: "nullable", inner: union } : union;
-    return { body: body2, encoding };
-  }
-  return { body: schemaToTypeRef(schema, contextName), encoding };
-}
-function deriveOneOfVariantName(variant, baseName, existingModels) {
-  if (variant.properties) {
-    for (const [, propSchema] of Object.entries(variant.properties)) {
-      if (propSchema?.const && typeof propSchema.const === "string") {
-        return toPascalCase(propSchema.const) + baseName.replace(/Request$/, "") + "Request";
-      }
-    }
-  }
-  const existingNames = new Set(existingModels.map((m) => m.name));
-  let name = baseName;
-  let suffix = 2;
-  while (existingNames.has(name)) {
-    name = `${baseName}${suffix}`;
-    suffix++;
-  }
-  return name;
-}
-function deriveResponseName(op, path, method) {
-  if (op?.operationId) {
-    return cleanSchemaName(toPascalCase(op.operationId) + "Response");
-  }
-  const segments = path.split("/").filter(Boolean);
-  const resource = segments[0] ?? "Unknown";
-  return toPascalCase(resource) + toPascalCase(method) + "Response";
-}
-function extractResponses(responses, op, path, method) {
-  const errors = [];
-  let response = { kind: "primitive", type: "string" };
-  let inlineModels = [];
-  let isPaginated = false;
-  let dataPath;
-  let itemType;
-  if (!responses) return { response, errors, inlineModels, isPaginated };
-  const allSuccessResponses = [];
-  for (const [statusCode, resp] of Object.entries(responses)) {
-    const code = parseInt(statusCode, 10);
-    if (code >= 200 && code < 300) {
-      let extractedType = { kind: "primitive", type: "unknown" };
-      const jsonContent = resp.content?.["application/json"];
-      if (jsonContent?.schema) {
-        const contextName = deriveResponseName(op, path ?? "/", method ?? "get");
-        const result = classifyAndExtractResponse(jsonContent.schema, contextName);
-        extractedType = result.response;
-        inlineModels = result.inlineModels;
-        isPaginated = result.isPaginated;
-        dataPath = result.dataPath;
-        itemType = result.itemType;
-      } else if (resp.content) {
-        if (resp.content["application/octet-stream"] || resp.content["application/pdf"]) {
-          extractedType = { kind: "primitive", type: "string", format: "binary" };
-        } else if (resp.content["text/plain"] || resp.content["text/html"] || resp.content["text/xml"] || resp.content["application/xml"]) {
-          extractedType = { kind: "primitive", type: "string" };
-        } else {
-          const firstKey = Object.keys(resp.content)[0];
-          if (firstKey) {
-            const firstContent = resp.content[firstKey];
-            if (firstContent?.schema) {
-              extractedType = schemaToTypeRef(
-                firstContent.schema,
-                deriveResponseName(op, path ?? "/", method ?? "get")
-              );
-            }
-          }
-        }
-      }
-      allSuccessResponses.push({ statusCode: code, type: extractedType });
-    } else if (code >= 400) {
-      const jsonContent = resp.content?.["application/json"];
-      const type = jsonContent?.schema ? schemaToTypeRef(jsonContent.schema, `Error${code}`) : void 0;
-      errors.push({ statusCode: code, type });
-    }
-  }
-  if (allSuccessResponses.length > 0) {
-    const sorted = [...allSuccessResponses].sort((a, b) => a.statusCode - b.statusCode);
-    const primary = sorted.find((r) => r.type.kind !== "primitive" || r.type.type !== "unknown") ?? sorted[0];
-    response = primary.type;
-  }
-  const successResponses = allSuccessResponses.length > 1 ? allSuccessResponses : void 0;
-  return { response, successResponses, errors, inlineModels, isPaginated, dataPath, itemType };
-}
-
-// src/parser/normalize-inline-models.ts
-function keepLargestByName(models) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const model of models) {
-    const existing = byName.get(model.name);
-    if (!existing || model.fields.length > existing.fields.length) {
-      byName.set(model.name, model);
-    }
-  }
-  return [...byName.values()];
-}
-function rewriteModelRef(ref, oldName, newName) {
-  walkTypeRef(ref, {
-    model: (r) => {
-      if (r.name === oldName) r.name = newName;
-    }
-  });
-}
-function rewriteModelRefs(models, services, oldName, newName) {
-  for (const model of models) {
-    for (const field of model.fields) {
-      rewriteModelRef(field.type, oldName, newName);
-    }
-  }
-  for (const service of services) {
-    for (const op of service.operations) {
-      rewriteModelRef(op.response, oldName, newName);
-      if (op.requestBody) {
-        rewriteModelRef(op.requestBody, oldName, newName);
-      }
-    }
-  }
-}
-function mergeInlineResponseModels(schemaModels, inlineModels) {
-  const mergedSchemaModels = [...schemaModels];
-  const schemaModelNames = new Set(mergedSchemaModels.map((m) => m.name));
-  const schemaModelsByName = new Map(mergedSchemaModels.map((m) => [m.name, m]));
-  const deduplicatedInlineModels = inlineModels.filter((model) => {
-    if (!schemaModelNames.has(model.name)) return true;
-    const existing = schemaModelsByName.get(model.name);
-    const existingFieldNames = new Set(existing.fields.map((f) => f.name));
-    const inlineFieldNames = new Set(model.fields.map((f) => f.name));
-    const hasDifference = model.fields.some((f) => !existingFieldNames.has(f.name)) || existing.fields.some((f) => !inlineFieldNames.has(f.name));
-    if (hasDifference && model.fields.length > existing.fields.length) {
-      const idx = mergedSchemaModels.indexOf(existing);
-      if (idx !== -1) mergedSchemaModels[idx] = model;
-      schemaModelsByName.set(model.name, model);
-      console.warn(
-        `[oagen] Warning: Inline model "${model.name}" has more fields than component schema (${model.fields.length} vs ${existing.fields.length}) \u2014 using inline response model`
-      );
-    } else if (hasDifference) {
-      console.warn(
-        `[oagen] Warning: Inline model "${model.name}" has different fields than component schema \u2014 using component schema`
-      );
-    }
-    return false;
-  });
-  return [...mergedSchemaModels, ...keepLargestByName(deduplicatedInlineModels)];
-}
-function mergeFieldInlineModels(existingModels, fieldInlineModels) {
-  const modelNames = new Set(existingModels.map((m) => m.name));
-  const modelsByName = new Map(existingModels.map((m) => [m.name, m]));
-  const deduplicatedFieldModels = fieldInlineModels.filter((model) => {
-    if (!modelNames.has(model.name)) return true;
-    const existing = modelsByName.get(model.name);
-    const existingFieldNames = new Set(existing.fields.map((f) => f.name));
-    const inlineFieldNames = new Set(model.fields.map((f) => f.name));
-    const hasDifference = model.fields.some((f) => !existingFieldNames.has(f.name)) || existing.fields.some((f) => !inlineFieldNames.has(f.name));
-    if (hasDifference) {
-      console.warn(
-        `[oagen] Warning: Inline model "${model.name}" has different fields than component schema \u2014 using component schema`
-      );
-    }
-    return false;
-  });
-  return [...existingModels, ...keepLargestByName(deduplicatedFieldModels)];
-}
-function hasModelConstDiscriminant(model) {
-  return model.fields.some(
-    (f) => (f.name === "object" || f.name === "type") && f.type.kind === "literal" && typeof f.type.value === "string"
-  );
-}
-function isModelReferencedByOthers(name, models, excludeNames) {
-  for (const model of models) {
-    if (excludeNames.has(model.name)) continue;
-    for (const field of model.fields) {
-      let found = false;
-      walkTypeRef(field.type, {
-        model: (r) => {
-          if (r.name === name) found = true;
-        }
-      });
-      if (found) return true;
-    }
-  }
-  return false;
-}
-function collapseJsonSuffixModels(models, services) {
-  const normalizedModels = [...models];
-  const byName = new Map(normalizedModels.map((m) => [m.name, m]));
-  const mergeCandidates = [];
-  for (const model of normalizedModels) {
-    if (!model.name.endsWith("Json")) continue;
-    const baseName = model.name.slice(0, -4);
-    const baseModel = byName.get(baseName);
-    if (!baseModel || model.fields.length <= baseModel.fields.length) continue;
-    const isSuperset = baseModel.fields.every((f) => model.fields.some((mf) => mf.name === f.name));
-    if (!isSuperset) continue;
-    if (hasModelConstDiscriminant(model) && hasModelConstDiscriminant(baseModel)) continue;
-    if (isModelReferencedByOthers(model.name, normalizedModels, /* @__PURE__ */ new Set([model.name, baseName]))) continue;
-    mergeCandidates.push({ jsonModel: model, baseModel });
-  }
-  const toRemove = /* @__PURE__ */ new Set();
-  for (const { jsonModel, baseModel } of mergeCandidates) {
-    baseModel.fields = jsonModel.fields;
-    toRemove.add(jsonModel.name);
-    rewriteModelRefs(normalizedModels, services, jsonModel.name, baseModel.name);
-    console.warn(
-      `[oagen] Merged "${jsonModel.name}" into "${baseModel.name}" (${jsonModel.fields.length} fields, superset)`
-    );
-  }
-  return normalizedModels.filter((m) => !toRemove.has(m.name));
-}
-
-// src/parser/collect-inline-enums.ts
-function collectInlineEnumsFromModels(models, enums) {
-  const enumNames = new Set(enums.map((e) => e.name));
-  for (const model of models) {
-    for (const field of model.fields) {
-      collectInlineEnumFromRef(field.type, enums, enumNames);
-    }
-  }
-}
-
-// src/parser/normalize-model-refs.ts
-function validateModelRefs(spec) {
-  const knownNames = /* @__PURE__ */ new Set();
-  for (const m of spec.models) knownNames.add(m.name);
-  for (const e of spec.enums) knownNames.add(e.name);
-  function walkRef(ref, context) {
-    walkTypeRef(ref, {
-      model: (r) => {
-        if (!knownNames.has(r.name)) {
-          console.warn(`[oagen] Warning: Unresolved model reference "${r.name}" (context: ${context})`);
-        }
-      }
-    });
-  }
-  for (const model of spec.models) {
-    for (const field of model.fields) {
-      walkRef(field.type, `${model.name}.${field.name}`);
-    }
-  }
-  for (const service of spec.services) {
-    for (const op of service.operations) {
-      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
-        walkRef(p.type, `${service.name}.${op.name}.${p.name}`);
-      }
-      if (op.requestBody) walkRef(op.requestBody, `${service.name}.${op.name}.requestBody`);
-      walkRef(op.response, `${service.name}.${op.name}.response`);
-    }
-  }
-}
-
-// src/parser/parse.ts
-async function parseSpec(specPath, options) {
-  const { parsed } = await loadAndBundleSpec(specPath);
-  const spec = parsed;
-  const version = spec.openapi ?? "";
-  if (!version.startsWith("3.")) {
-    throw new SpecParseError(
-      `Unsupported OpenAPI version: ${version}. oagen requires OpenAPI 3.x`,
-      `Update the spec to OpenAPI 3.0 or 3.1. If you are using Swagger 2.x, convert it first with \`npx swagger2openapi ${specPath}\`.`
-    );
-  }
-  const { models, enums } = extractSchemas(
-    spec.components?.schemas
-  );
-  const { services, inlineModels } = extractOperations(
-    spec.paths,
-    options?.operationIdTransform
-  );
-  const responseNormalizedModels = mergeInlineResponseModels(models, inlineModels);
-  const fieldInlineModels = extractInlineModelsFromSchemas(
-    spec.components?.schemas
-  );
-  const fieldMergedModels = mergeFieldInlineModels(responseNormalizedModels, fieldInlineModels);
-  const finalModels = collapseJsonSuffixModels(fieldMergedModels, services);
-  collectInlineEnumsFromModels(finalModels, enums);
-  const auth = extractAuthSchemes(spec.components?.securitySchemes);
-  const serverEntries = (spec.servers ?? []).map((s) => ({ url: s.url ?? "", description: s.description })).filter((s) => s.url);
-  const result = {
-    name: spec.info?.title ?? "Unknown API",
-    version: spec.info?.version ?? "0.0.0",
-    description: spec.info?.description,
-    baseUrl: serverEntries[0]?.url ?? "",
-    servers: serverEntries.length > 0 ? serverEntries : void 0,
-    services,
-    models: finalModels,
-    enums,
-    auth
-  };
-  validateModelRefs(result);
-  return result;
-}
-function extractAuthSchemes(securitySchemes) {
-  if (!securitySchemes) return void 0;
-  const schemes = [];
-  for (const [, scheme] of Object.entries(securitySchemes)) {
-    if (scheme.type === "http" && scheme.scheme === "bearer") {
-      schemes.push({ kind: "bearer" });
-    } else if (scheme.type === "apiKey" && scheme.in && scheme.name) {
-      schemes.push({ kind: "apiKey", in: scheme.in, name: scheme.name });
-    } else if (scheme.type === "oauth2" && scheme.flows) {
-      schemes.push({ kind: "oauth2", flows: scheme.flows });
-    }
-  }
-  return schemes.length > 0 ? schemes : void 0;
-}
-
-// scripts/smoke/shared.ts
-import "dotenv/config";
-import { readFileSync } from "fs";
-var SKIP_OPERATIONS = /* @__PURE__ */ new Set();
-var SKIP_SERVICES = /* @__PURE__ */ new Set();
-var SERVICE_PRIORITY = {};
-var SERVICE_PROPERTY_MAP = {};
-function loadSmokeConfig(configPath) {
-  if (!configPath) return;
-  const raw = readFileSync(configPath, "utf-8");
-  const config = JSON.parse(raw);
-  if (config.skipOperations) SKIP_OPERATIONS = new Set(config.skipOperations);
-  if (config.skipServices) SKIP_SERVICES = new Set(config.skipServices);
-  if (config.servicePriority) SERVICE_PRIORITY = config.servicePriority;
-  if (config.servicePropertyMap) SERVICE_PROPERTY_MAP = config.servicePropertyMap;
-}
-function operationSortKey(op) {
-  const hasParams = op.pathParams.length > 0;
-  const method = op.httpMethod;
-  if (method === "post" && !hasParams) return 0;
-  if (method === "get" && !hasParams && op.pagination) return 1;
-  if (method === "get" && !hasParams) return 2;
-  if (method === "post" && hasParams) return 3;
-  if (method === "get" && hasParams && op.pagination) return 4;
-  if (method === "get" && hasParams) return 5;
-  if (method === "put" || method === "patch") return 6;
-  if (method === "delete") return 7;
-  return 99;
-}
-function planOperations(spec) {
-  const groups = [];
-  for (const service of spec.services) {
-    if (SKIP_SERVICES.has(service.name)) continue;
-    const ops = [];
-    for (const op of service.operations) {
-      if (SKIP_OPERATIONS.has(op.name)) continue;
-      ops.push({ service: service.name, operation: op });
-    }
-    if (ops.length === 0) continue;
-    ops.sort((a, b) => {
-      return operationSortKey(a.operation) - operationSortKey(b.operation);
-    });
-    groups.push({ service: service.name, operations: ops });
-  }
-  groups.sort((a, b) => {
-    const aPri = SERVICE_PRIORITY[a.service] ?? 50;
-    const bPri = SERVICE_PRIORITY[b.service] ?? 50;
-    return aPri - bPri;
-  });
-  return groups;
-}
-function generateFixtureValue(typeRef, fieldName, spec) {
-  switch (typeRef.kind) {
-    case "primitive":
-      return generatePrimitiveFixture(typeRef.type, typeRef.format, fieldName);
-    case "array":
-      return [generateFixtureValue(typeRef.items, fieldName, spec)];
-    case "model": {
-      const model = spec.models.find((m) => m.name === typeRef.name);
-      if (model) {
-        const obj = {};
-        for (const field of model.fields) {
-          if (field.required) {
-            obj[toSnakeCase(field.name)] = generateFixtureValue(field.type, field.name, spec);
-          }
-        }
-        return obj;
-      }
-      return {};
-    }
-    case "enum": {
-      const e = spec.enums.find((en) => en.name === typeRef.name);
-      return e?.values[0]?.value ?? "unknown";
-    }
-    case "nullable":
-      return generateFixtureValue(typeRef.inner, fieldName, spec);
-    case "union":
-      if (typeRef.variants.length > 0) {
-        return generateFixtureValue(typeRef.variants[0], fieldName, spec);
-      }
-      return null;
-  }
-}
-function generatePrimitiveFixture(type, format, fieldName) {
-  if (type === "string") {
-    if (format === "uuid") return "550e8400-e29b-41d4-a716-446655440000";
-    if (format === "date") return "2024-01-01";
-    if (format === "date-time") return "2024-01-01T00:00:00Z";
-    if (format === "email") return "test@example.com";
-    if (format === "uri" || format === "url") return "https://example.com";
-    return `test_${toSnakeCase(fieldName)}`;
-  }
-  if (type === "integer") return 1;
-  if (type === "number") return 1;
-  if (type === "boolean") return true;
-  return null;
-}
-function generatePayload(op, spec) {
-  if (!op.requestBody) return null;
-  const bodyType = op.requestBody;
-  if (bodyType.kind === "model") {
-    const model = spec.models.find((m) => m.name === bodyType.name);
-    if (!model) return {};
-    const payload = {};
-    for (const field of model.fields) {
-      if (!field.required) continue;
-      const key = toSnakeCase(field.name);
-      let value = generateFixtureValue(field.type, field.name, spec);
-      if ((key === "name" || key === "slug") && typeof value === "string") {
-        value = `smoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      }
-      payload[key] = value;
-    }
-    return payload;
-  }
-  return {};
-}
-function generateQueryParams(op, spec) {
-  const params = {};
-  if (op.pagination) {
-    params["limit"] = "1";
-  }
-  for (const p of op.queryParams) {
-    if (!p.required) continue;
-    const value = generateFixtureValue(p.type, p.name, spec);
-    params[toSnakeCase(p.name)] = String(value);
-  }
-  const sorted = {};
-  for (const key of Object.keys(params).sort()) {
-    sorted[key] = params[key];
-  }
-  return sorted;
-}
-function resolvePath(op, pathParams) {
-  let path = op.path;
-  for (const [name, value] of Object.entries(pathParams)) {
-    path = path.replace(`{${name}}`, value);
-  }
-  return path;
-}
-function parseCliArgs() {
-  const args = process.argv.slice(2);
-  const specIdx = args.indexOf("--spec");
-  const spec = specIdx !== -1 && args[specIdx + 1] ? args[specIdx + 1] : process.env.OPENAPI_SPEC_PATH;
-  if (!spec) {
-    console.error("OpenAPI spec path is required. Set OPENAPI_SPEC_PATH env var or pass --spec <path>.");
-    process.exit(1);
-  }
-  const sdkPathIdx = args.indexOf("--sdk-path");
-  const sdkPath = sdkPathIdx !== -1 && args[sdkPathIdx + 1] ? args[sdkPathIdx + 1] : void 0;
-  const configIdx = args.indexOf("--smoke-config");
-  const smokeConfig = configIdx !== -1 && args[configIdx + 1] ? args[configIdx + 1] : process.env.SMOKE_CONFIG;
-  return { spec, sdkPath, smokeConfig };
-}
-
-// scripts/smoke/baseline.ts
-async function main() {
-  const { spec: specPath, smokeConfig } = parseCliArgs();
-  loadSmokeConfig(smokeConfig);
-  console.log("Parsing spec...");
-  const spec = await parseSpec(specPath);
-  console.log(`Spec: ${spec.name} v${spec.version}`);
-  const groups = planOperations(spec);
-  const exchanges = [];
-  for (const group of groups) {
-    for (const planned of group.operations) {
-      const op = planned.operation;
-      const operationId = `${group.service}.${op.name}`;
-      const placeholderParams = {};
-      for (const p of op.pathParams) {
-        placeholderParams[p.name] = "<ID>";
-      }
-      const path = resolvePath(op, placeholderParams);
-      const queryParams = generateQueryParams(op, spec);
-      const body = generatePayload(op, spec);
-      const defaultSuccess = {
-        post: 201,
-        get: 200,
-        put: 200,
-        patch: 200,
-        delete: 204
-      };
-      const status = defaultSuccess[op.httpMethod] ?? 200;
-      exchanges.push({
-        operationId,
-        service: group.service,
-        operationName: op.name,
-        request: {
-          method: op.httpMethod.toUpperCase(),
-          path,
-          queryParams,
-          body
-        },
-        response: {
-          status,
-          body: null
-        },
-        outcome: "success",
-        durationMs: 0
-      });
-    }
-  }
-  const results = {
-    source: "spec-baseline",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    specVersion: spec.version,
-    exchanges
-  };
-  writeFileSync("smoke-results-spec-baseline.json", JSON.stringify(results, null, 2));
-  console.log(`
-Generated ${exchanges.length} operations from spec`);
-  console.log("Written to smoke-results-spec-baseline.json");
-}
-main().catch((err) => {
-  console.error("Baseline generation failed:", err);
-  process.exit(1);
-});