@vertz/openapi 0.1.0 → 0.1.2

package/dist/shared/chunk-h8tb765a.js

@@ -0,0 +1,1481 @@
+// src/adapter/identifier.ts
+function splitWords(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9]+/g, " ").split(/\s+/).filter(Boolean);
+}
+function sanitizeIdentifier(name) {
+  const words = splitWords(name);
+  if (words.length === 0) {
+    return "_";
+  }
+  const [first, ...rest] = words.map((word) => word.toLowerCase());
+  const camelCase = first + rest.map((word) => word[0]?.toUpperCase() + word.slice(1)).join("");
+  return /^[0-9]/.test(camelCase) ? `_${camelCase}` : camelCase;
+}
+
+// src/adapter/resource-grouper.ts
+function getPathGroupKey(path) {
+  const meaningfulSegments = path.split("/").filter(Boolean).filter((segment) => segment !== "api").filter((segment) => !/^v\d+$/i.test(segment)).filter((segment) => !(segment.startsWith("{") && segment.endsWith("}")));
+  return meaningfulSegments[meaningfulSegments.length - 1] ?? "_ungrouped";
+}
+function toResourceName(identifier) {
+  return identifier === "_ungrouped" ? "Ungrouped" : identifier.charAt(0).toUpperCase() + identifier.slice(1);
+}
+function groupOperations(operations, strategy, options) {
+  const excludeSet = options?.excludeTags ? new Set(options.excludeTags) : undefined;
+  const resources = new Map;
+  for (const operation of operations) {
+    if (excludeSet && operation.tags.some((t) => excludeSet.has(t))) {
+      continue;
+    }
+    const groupKey = strategy === "tag" ? operation.tags[0] ?? "_ungrouped" : strategy === "none" ? operation.operationId : getPathGroupKey(operation.path);
+    const identifier = groupKey === "_ungrouped" ? "_ungrouped" : sanitizeIdentifier(groupKey);
+    const existing = resources.get(identifier) ?? [];
+    existing.push(operation);
+    resources.set(identifier, existing);
+  }
+  return [...resources.entries()].map(([identifier, resourceOperations]) => ({
+    name: toResourceName(identifier),
+    identifier,
+    operations: resourceOperations
+  }));
+}
+
+// src/generators/client-generator.ts
+function camelCase(name) {
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function generateAuthField(scheme) {
+  switch (scheme.type) {
+    case "bearer":
+      return `  ${camelCase(scheme.name)}?: string | (() => string | Promise<string>);`;
+    case "basic":
+      return `  ${camelCase(scheme.name)}?: { username: string; password: string };`;
+    case "apiKey":
+      return `  ${camelCase(scheme.name)}?: string | (() => string | Promise<string>);`;
+    case "oauth2":
+      return `  ${camelCase(scheme.name)}?: string | (() => string | Promise<string>);`;
+  }
+}
+function generateAuthStrategy(scheme) {
+  const fieldName = camelCase(scheme.name);
+  const lines = [];
+  switch (scheme.type) {
+    case "bearer":
+      lines.push(`    ...(options.auth?.${fieldName} ? [{`);
+      lines.push(`      type: 'bearer' as const,`);
+      lines.push(`      token: options.auth?.${fieldName},`);
+      lines.push("    }] : []),");
+      break;
+    case "basic":
+      lines.push(`    ...(options.auth?.${fieldName} ? [{`);
+      lines.push(`      type: 'basic' as const,`);
+      lines.push(`      ...options.auth?.${fieldName},`);
+      lines.push("    }] : []),");
+      break;
+    case "apiKey":
+      lines.push(`    ...(options.auth?.${fieldName} ? [{`);
+      lines.push(`      type: 'apiKey' as const,`);
+      lines.push(`      key: options.auth?.${fieldName},`);
+      lines.push(`      location: '${scheme.in}' as const,`);
+      lines.push(`      name: '${scheme.paramName}',`);
+      lines.push("    }] : []),");
+      break;
+    case "oauth2":
+      lines.push(`    ...(options.auth?.${fieldName} ? [{`);
+      lines.push(`      type: 'bearer' as const,`);
+      lines.push(`      token: options.auth?.${fieldName},`);
+      lines.push("    }] : []),");
+      break;
+  }
+  return lines;
+}
+function generateClient(resources, config) {
+  const defaultBaseURL = config.baseURL ? `'${config.baseURL.replace(/'/g, "\\'")}'` : "''";
+  const schemes = config.securitySchemes ?? [];
+  const hasAuth = schemes.length > 0;
+  const lines = [];
+  lines.push("// Generated by @vertz/openapi — do not edit");
+  lines.push("");
+  lines.push("import { FetchClient } from '@vertz/fetch';");
+  lines.push("import type { FetchClientConfig } from '@vertz/fetch';");
+  for (const r of resources) {
+    lines.push(`import { create${r.name}Resource } from './resources/${r.identifier}';`);
+  }
+  lines.push("");
+  if (hasAuth) {
+    lines.push("export interface ClientAuth {");
+    for (const scheme of schemes) {
+      lines.push(generateAuthField(scheme));
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  if (hasAuth) {
+    lines.push("export type ClientOptions = FetchClientConfig & { auth?: ClientAuth };");
+  } else {
+    lines.push("export type ClientOptions = FetchClientConfig;");
+  }
+  lines.push("");
+  lines.push("export function createClient(options: ClientOptions = {}) {");
+  lines.push(`  const client = new FetchClient({`);
+  lines.push(`    baseURL: ${defaultBaseURL},`);
+  if (hasAuth) {
+    lines.push("    authStrategies: [");
+    for (const scheme of schemes) {
+      lines.push(...generateAuthStrategy(scheme));
+    }
+    lines.push("    ],");
+  }
+  lines.push("    ...options,");
+  lines.push("  });");
+  lines.push("");
+  lines.push("  return {");
+  for (const r of resources) {
+    lines.push(`    ${r.identifier}: create${r.name}Resource(client),`);
+  }
+  lines.push("  };");
+  lines.push("}");
+  lines.push("");
+  lines.push("export type Client = ReturnType<typeof createClient>;");
+  lines.push("");
+  return { path: "client.ts", content: lines.join(`
+`) };
+}
+
+// src/generators/json-schema-to-ts.ts
+function jsonSchemaToTS(schema, namedSchemas) {
+  if (typeof schema.$circular === "string") {
+    return schema.$circular;
+  }
+  if (Array.isArray(schema.enum)) {
+    return schema.enum.map((v) => typeof v === "number" ? String(v) : `'${String(v).replace(/'/g, "\\'")}'`).join(" | ");
+  }
+  if (Array.isArray(schema.anyOf)) {
+    const members = schema.anyOf.map((s) => jsonSchemaToTS(s, namedSchemas));
+    return [...new Set(members)].join(" | ");
+  }
+  if (Array.isArray(schema.oneOf)) {
+    const members = schema.oneOf.map((s) => jsonSchemaToTS(s, namedSchemas));
+    return [...new Set(members)].join(" | ");
+  }
+  const type = schema.type;
+  if (type === "null")
+    return "null";
+  if (Array.isArray(type)) {
+    const nonNull = type.filter((t) => t !== "null");
+    const baseType = nonNull.length === 1 ? mapPrimitive(nonNull[0]) : "unknown";
+    return type.includes("null") ? `${baseType} | null` : baseType;
+  }
+  if (type === "string")
+    return "string";
+  if (type === "number" || type === "integer")
+    return "number";
+  if (type === "boolean")
+    return "boolean";
+  if (type === "array") {
+    const items = schema.items;
+    if (!items)
+      return "unknown[]";
+    const itemType = jsonSchemaToTS(items, namedSchemas);
+    const needsParens = itemType.includes("|") && !itemType.includes("{");
+    return needsParens ? `(${itemType})[]` : `${itemType}[]`;
+  }
+  if (type === "object") {
+    if (schema.additionalProperties === true && !schema.properties) {
+      return "Record<string, unknown>";
+    }
+    const properties = schema.properties;
+    if (!properties)
+      return "Record<string, unknown>";
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const entries = Object.entries(properties).map(([key, propSchema]) => {
+      const tsType = jsonSchemaToTS(propSchema, namedSchemas);
+      const optional = required.has(key) ? "" : "?";
+      const safeKey = isValidIdentifier(key) ? key : `'${key.replace(/'/g, "\\'")}'`;
+      return `${safeKey}${optional}: ${tsType}`;
+    });
+    return `{ ${entries.join("; ")} }`;
+  }
+  return "unknown";
+}
+function sanitizeTypeName(name) {
+  if (isValidIdentifier(name))
+    return name;
+  const cleaned = name.replace(/[^A-Za-z0-9_$]+/g, " ").trim();
+  if (!cleaned)
+    return "_";
+  const segments = cleaned.split(/\s+/).filter(Boolean);
+  const result = segments.map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+  return /^[0-9]/.test(result) ? `_${result}` : result;
+}
+function generateInterface(name, schema, namedSchemas) {
+  const safeName = sanitizeTypeName(name);
+  const properties = schema.properties;
+  if (!properties) {
+    return `export interface ${safeName} {}
+`;
+  }
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const lines = Object.entries(properties).map(([key, propSchema]) => {
+    const tsType = jsonSchemaToTS(propSchema, namedSchemas);
+    const optional = required.has(key) ? "" : "?";
+    const safeKey = isValidIdentifier(key) ? key : `'${key.replace(/'/g, "\\'")}'`;
+    return `  ${safeKey}${optional}: ${tsType};`;
+  });
+  return `export interface ${safeName} {
+${lines.join(`
+`)}
+}
+`;
+}
+function mapPrimitive(type) {
+  if (type === "string")
+    return "string";
+  if (type === "number" || type === "integer")
+    return "number";
+  if (type === "boolean")
+    return "boolean";
+  return "unknown";
+}
+var VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function isValidIdentifier(name) {
+  return VALID_IDENTIFIER.test(name);
+}
+
+// src/generators/resource-generator.ts
+function generateResources(resources) {
+  const files = [];
+  for (const resource of resources) {
+    files.push({
+      path: `resources/${resource.identifier}.ts`,
+      content: generateResourceFile(resource)
+    });
+  }
+  const exports = resources.map((r) => `export { create${r.name}Resource } from './${r.identifier}';`).join(`
+`);
+  files.push({ path: "resources/index.ts", content: exports + `
+` });
+  return files;
+}
+function generateResourceFile(resource) {
+  const lines = [];
+  const typeImports = collectTypeImports(resource);
+  lines.push("import type { FetchClient, FetchResponse } from '@vertz/fetch';");
+  if (typeImports.size > 0) {
+    const sorted = [...typeImports].sort();
+    lines.push(`import type { ${sorted.join(", ")} } from '../types/${resource.identifier}';`);
+  }
+  lines.push("");
+  lines.push(`export function create${resource.name}Resource(client: FetchClient) {`);
+  lines.push("  return {");
+  validateUniqueMethodNames(resource);
+  for (const op of resource.operations) {
+    lines.push(`    ${generateMethod(op)},`);
+  }
+  lines.push("  };");
+  lines.push("}");
+  lines.push("");
+  return lines.join(`
+`);
+}
+function generateMethod(op) {
+  const params = buildParams(op);
+  const returnType = buildReturnType(op);
+  const call = buildCall(op);
+  return `${op.methodName}: (${params}): ${returnType} =>
+      ${call}`;
+}
+function validateUniqueMethodNames(resource) {
+  const seen = new Map;
+  for (const op of resource.operations) {
+    const existing = seen.get(op.methodName);
+    if (existing) {
+      existing.push(op.operationId);
+    } else {
+      seen.set(op.methodName, [op.operationId]);
+    }
+  }
+  const duplicates = [...seen.entries()].filter(([, ids]) => ids.length > 1);
+  if (duplicates.length === 0)
+    return;
+  const details = duplicates.map(([name, ids]) => `  - "${name}" used by: ${ids.join(", ")}`).join(`
+`);
+  throw new Error(`Duplicate method name${duplicates.length > 1 ? "s" : ""} ${duplicates.map(([n]) => `"${n}"`).join(", ")} in resource "${resource.name}". ` + `Each operation within a resource must have a unique method name.
+${details}
+
+` + `Fix: use excludeTags to skip this tag, use a different groupBy strategy, ` + `or provide operationIds.overrides to rename conflicting operations.`);
+}
+function buildParams(op) {
+  const parts = [];
+  for (const p of op.pathParams) {
+    parts.push(`${p.name}: string`);
+  }
+  if (op.requestBody) {
+    const inputName = deriveInputName(op);
+    parts.push(`body: ${inputName}`);
+  }
+  if (op.queryParams.length > 0) {
+    const queryName = deriveQueryName(op);
+    parts.push(`query?: ${queryName}`);
+  }
+  return parts.join(", ");
+}
+function buildReturnType(op) {
+  if (op.responseStatus === 204)
+    return "Promise<FetchResponse<void>>";
+  if (op.response?.name) {
+    const safeName = sanitizeTypeName(op.response.name);
+    if (op.response.jsonSchema.type === "array") {
+      return `Promise<FetchResponse<${safeName}[]>>`;
+    }
+    return `Promise<FetchResponse<${safeName}>>`;
+  }
+  if (op.response?.jsonSchema.type === "array") {
+    return "Promise<FetchResponse<unknown[]>>";
+  }
+  if (op.response) {
+    const name = capitalize(op.operationId) + "Response";
+    return `Promise<FetchResponse<${name}>>`;
+  }
+  return "Promise<FetchResponse<void>>";
+}
+function buildCall(op) {
+  const method = op.method.toLowerCase();
+  const path = buildPath(op);
+  const args = [path];
+  if (op.requestBody) {
+    args.push("body");
+  }
+  if (op.queryParams.length > 0) {
+    args.push("{ query }");
+  }
+  return `client.${method}(${args.join(", ")})`;
+}
+function buildPath(op) {
+  if (op.pathParams.length === 0) {
+    return `'${op.path}'`;
+  }
+  let path = op.path;
+  for (const p of op.pathParams) {
+    path = path.replace(`{${p.name}}`, `\${encodeURIComponent(${p.name})}`);
+  }
+  return `\`${path}\``;
+}
+function collectTypeImports(resource) {
+  const types = new Set;
+  for (const op of resource.operations) {
+    if (op.responseStatus !== 204 && op.response) {
+      if (op.response.name) {
+        types.add(sanitizeTypeName(op.response.name));
+      } else {
+        types.add(capitalize(op.operationId) + "Response");
+      }
+    }
+    if (op.requestBody) {
+      types.add(deriveInputName(op));
+    }
+    if (op.queryParams.length > 0) {
+      types.add(deriveQueryName(op));
+    }
+  }
+  return types;
+}
+function deriveInputName(op) {
+  if (op.requestBody?.name)
+    return sanitizeTypeName(op.requestBody.name);
+  return capitalize(op.operationId) + "Input";
+}
+function deriveQueryName(op) {
+  return capitalize(op.operationId) + "Query";
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/generators/json-schema-to-zod.ts
+function jsonSchemaToZod(schema, namedSchemas) {
+  if (typeof schema.$circular === "string") {
+    const ref = namedSchemas.get(schema.$circular) ?? schema.$circular;
+    return `z.lazy(() => ${ref})`;
+  }
+  if (Array.isArray(schema.enum)) {
+    const values = schema.enum;
+    const allStrings = values.every((v) => typeof v === "string");
+    if (allStrings) {
+      const items = values.map((v) => `'${String(v).replace(/'/g, "\\'")}'`).join(", ");
+      return `z.enum([${items}])`;
+    }
+    const literals = values.map((v) => typeof v === "string" ? `z.literal('${String(v).replace(/'/g, "\\'")}')` : `z.literal(${String(v)})`).join(", ");
+    return `z.union([${literals}])`;
+  }
+  if (Array.isArray(schema.anyOf)) {
+    const members = schema.anyOf;
+    const nullMember = members.find((m) => m.type === "null");
+    const nonNull = members.filter((m) => m.type !== "null");
+    const isNullable = nullMember !== undefined;
+    if (nonNull.length === 1) {
+      const base = jsonSchemaToZod(nonNull[0], namedSchemas);
+      return isNullable ? `${base}.nullable()` : base;
+    }
+    const union = `z.union([${nonNull.map((m) => jsonSchemaToZod(m, namedSchemas)).join(", ")}])`;
+    return isNullable ? `${union}.nullable()` : union;
+  }
+  if (Array.isArray(schema.oneOf)) {
+    const members = schema.oneOf.map((m) => jsonSchemaToZod(m, namedSchemas));
+    return `z.union([${members.join(", ")}])`;
+  }
+  const type = schema.type;
+  if (type === "null")
+    return "z.null()";
+  if (Array.isArray(type)) {
+    const nonNull = type.filter((t) => t !== "null");
+    const isNullable = type.includes("null");
+    const base = nonNull.length === 1 ? zodPrimitive(nonNull[0], schema) : "z.unknown()";
+    return isNullable ? `${base}.nullable()` : base;
+  }
+  if (type === "string")
+    return zodString(schema);
+  if (type === "number")
+    return zodNumber(schema);
+  if (type === "integer")
+    return zodInteger(schema);
+  if (type === "boolean")
+    return zodBoolean(schema);
+  if (type === "array") {
+    const items = schema.items;
+    const itemZod = items ? jsonSchemaToZod(items, namedSchemas) : "z.unknown()";
+    return `z.array(${itemZod})`;
+  }
+  if (type === "object") {
+    return zodObject(schema, namedSchemas);
+  }
+  return "z.unknown()";
+}
+function zodString(schema) {
+  let result = "z.string()";
+  const format = schema.format;
+  if (format === "email")
+    result += ".email()";
+  else if (format === "uuid")
+    result += ".uuid()";
+  else if (format === "date-time")
+    result += ".datetime()";
+  else if (format === "uri")
+    result += ".url()";
+  if (typeof schema.minLength === "number")
+    result += `.min(${schema.minLength})`;
+  if (typeof schema.maxLength === "number")
+    result += `.max(${schema.maxLength})`;
+  if (typeof schema.pattern === "string") {
+    const escaped = schema.pattern.replace(/\//g, "\\/");
+    result += `.regex(/${escaped}/)`;
+  }
+  if (schema.default !== undefined) {
+    result += `.default('${String(schema.default).replace(/'/g, "\\'")}')`;
+  }
+  return result;
+}
+function zodNumber(schema) {
+  let result = "z.number()";
+  if (typeof schema.minimum === "number")
+    result += `.min(${schema.minimum})`;
+  if (typeof schema.maximum === "number")
+    result += `.max(${schema.maximum})`;
+  if (schema.default !== undefined)
+    result += `.default(${schema.default})`;
+  return result;
+}
+function zodInteger(schema) {
+  let result = "z.number().int()";
+  if (typeof schema.minimum === "number")
+    result += `.min(${schema.minimum})`;
+  if (typeof schema.maximum === "number")
+    result += `.max(${schema.maximum})`;
+  if (schema.default !== undefined)
+    result += `.default(${schema.default})`;
+  return result;
+}
+function zodBoolean(schema) {
+  let result = "z.boolean()";
+  if (schema.default !== undefined)
+    result += `.default(${schema.default})`;
+  return result;
+}
+function zodObject(schema, namedSchemas) {
+  const properties = schema.properties;
+  if (!properties)
+    return "z.object({})";
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const entries = Object.entries(properties).map(([key, propSchema]) => {
+    let zod = jsonSchemaToZod(propSchema, namedSchemas);
+    if (!required.has(key))
+      zod += ".optional()";
+    const safeKey = isValidIdentifier(key) ? key : `'${key.replace(/'/g, "\\'")}'`;
+    return `  ${safeKey}: ${zod}`;
+  });
+  return `z.object({
+${entries.join(`,
+`)},
+})`;
+}
+function zodPrimitive(type, schema) {
+  if (type === "string")
+    return zodString(schema);
+  if (type === "number")
+    return zodNumber(schema);
+  if (type === "integer")
+    return zodInteger(schema);
+  if (type === "boolean")
+    return zodBoolean(schema);
+  return "z.unknown()";
+}
+
+// src/generators/schema-generator.ts
+function generateSchemas(resources, schemas) {
+  const files = [];
+  const namedSchemas = buildNamedSchemaMap(schemas);
+  for (const resource of resources) {
+    const content = generateResourceSchemas(resource, namedSchemas);
+    files.push({ path: `schemas/${resource.identifier}.ts`, content });
+  }
+  const exports = resources.map((r) => `export * from './${r.identifier}';`).join(`
+`);
+  files.push({ path: "schemas/index.ts", content: exports + `
+` });
+  return files;
+}
+function buildNamedSchemaMap(schemas) {
+  const map = new Map;
+  for (const s of schemas) {
+    if (s.name) {
+      map.set(s.name, toSchemaVarName(s.name));
+    }
+  }
+  return map;
+}
+function generateResourceSchemas(resource, namedSchemas) {
+  const lines = [];
+  lines.push("import { z } from 'zod';");
+  lines.push("");
+  const emitted = new Set;
+  for (const op of resource.operations) {
+    if (op.response) {
+      const varName = deriveResponseSchemaName(op);
+      if (!emitted.has(varName)) {
+        emitted.add(varName);
+        const schema = op.response.jsonSchema;
+        const effectiveSchema = schema.type === "array" && schema.items && typeof schema.items === "object" ? schema.items : schema;
+        const zod = jsonSchemaToZod(effectiveSchema, namedSchemas);
+        lines.push(`export const ${varName} = ${zod};`);
+        lines.push("");
+      }
+    }
+    if (op.requestBody) {
+      const varName = deriveInputSchemaName(op);
+      if (!emitted.has(varName)) {
+        emitted.add(varName);
+        const zod = jsonSchemaToZod(op.requestBody.jsonSchema, namedSchemas);
+        lines.push(`export const ${varName} = ${zod};`);
+        lines.push("");
+      }
+    }
+    if (op.queryParams.length > 0) {
+      const varName = deriveQuerySchemaName(op);
+      if (!emitted.has(varName)) {
+        emitted.add(varName);
+        lines.push(`export const ${varName} = ${buildQueryZodSchema(op, namedSchemas)};`);
+        lines.push("");
+      }
+    }
+  }
+  return lines.join(`
+`);
+}
+function buildQueryZodSchema(op, namedSchemas) {
+  const entries = op.queryParams.map((param) => {
+    let zod = jsonSchemaToZod(param.schema, namedSchemas);
+    if (!param.required)
+      zod += ".optional()";
+    const safeKey = isValidIdentifier(param.name) ? param.name : `'${param.name.replace(/'/g, "\\'")}'`;
+    return `  ${safeKey}: ${zod}`;
+  });
+  return `z.object({
+${entries.join(`,
+`)},
+})`;
+}
+function deriveResponseSchemaName(op) {
+  if (op.response?.name)
+    return toSchemaVarName(op.response.name);
+  return toSchemaVarName(op.operationId + "Response");
+}
+function deriveInputSchemaName(op) {
+  if (op.requestBody?.name)
+    return toSchemaVarName(op.requestBody.name);
+  return toSchemaVarName(op.operationId + "Input");
+}
+function deriveQuerySchemaName(op) {
+  return toSchemaVarName(op.operationId + "Query");
+}
+function toSchemaVarName(name) {
+  const camel = name.charAt(0).toLowerCase() + name.slice(1);
+  return camel + "Schema";
+}
+
+// src/generators/types-generator.ts
+function generateTypes(resources, schemas) {
+  const files = [];
+  const namedSchemas = buildNamedSchemaMap2(schemas);
+  for (const resource of resources) {
+    const content = generateResourceTypes(resource, namedSchemas);
+    files.push({ path: `types/${resource.identifier}.ts`, content: content || "" });
+  }
+  const exports = resources.map((r) => `export * from './${r.identifier}';`).join(`
+`);
+  files.push({ path: "types/index.ts", content: exports + `
+` });
+  return files;
+}
+function buildNamedSchemaMap2(schemas) {
+  const map = new Map;
+  for (const s of schemas) {
+    if (s.name) {
+      map.set(s.name, s.name);
+    }
+  }
+  return map;
+}
+function generateResourceTypes(resource, namedSchemas) {
+  const interfaces = [];
+  const emitted = new Set;
+  for (const op of resource.operations) {
+    if (op.response) {
+      const name = deriveResponseName(op);
+      if (!emitted.has(name)) {
+        emitted.add(name);
+        const schema = op.response.jsonSchema;
+        const effectiveSchema = schema.type === "array" && schema.items && typeof schema.items === "object" ? schema.items : schema;
+        interfaces.push(generateInterface(name, effectiveSchema, namedSchemas));
+      }
+    }
+    if (op.requestBody) {
+      const name = deriveInputName2(op);
+      if (!emitted.has(name)) {
+        emitted.add(name);
+        interfaces.push(generateInterface(name, op.requestBody.jsonSchema, namedSchemas));
+      }
+    }
+    if (op.queryParams.length > 0) {
+      const name = deriveQueryName2(op);
+      if (!emitted.has(name)) {
+        emitted.add(name);
+        interfaces.push(generateQueryInterface(name, op, namedSchemas));
+      }
+    }
+  }
+  return interfaces.join(`
+`);
+}
+function deriveResponseName(op) {
+  if (op.response?.name)
+    return sanitizeTypeName(op.response.name);
+  return capitalize2(op.operationId) + "Response";
+}
+function deriveInputName2(op) {
+  if (op.requestBody?.name)
+    return sanitizeTypeName(op.requestBody.name);
+  return capitalize2(op.operationId) + "Input";
+}
+function deriveQueryName2(op) {
+  return capitalize2(op.operationId) + "Query";
+}
+function generateQueryInterface(name, op, namedSchemas) {
+  const lines = op.queryParams.map((param) => {
+    const tsType = jsonSchemaToTS(param.schema, namedSchemas);
+    const optional = param.required ? "" : "?";
+    const safeKey = isValidIdentifier(param.name) ? param.name : `'${param.name.replace(/'/g, "\\'")}'`;
+    return `  ${safeKey}${optional}: ${tsType};`;
+  });
+  return `export interface ${sanitizeTypeName(name)} {
+${lines.join(`
+`)}
+}
+`;
+}
+function capitalize2(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/generators/index.ts
+function generateAll(spec, options) {
+  const { resources, schemas } = spec;
+  const opts = { schemas: false, baseURL: "", ...options };
+  const files = [];
+  files.push(...generateTypes(resources, schemas));
+  files.push(...generateResources(resources));
+  files.push(generateClient(resources, {
+    baseURL: opts.baseURL,
+    securitySchemes: spec.securitySchemes
+  }));
+  if (opts.schemas) {
+    files.push(...generateSchemas(resources, schemas));
+  }
+  files.push(generateReadme(spec, opts));
+  return files;
+}
+function generateReadme(spec, options) {
+  const lines = [];
+  lines.push(`# ${spec.info.title} SDK`);
+  lines.push("");
+  lines.push(`> Auto-generated from OpenAPI ${spec.version} spec (v${spec.info.version})`);
+  lines.push("");
+  lines.push("## Prerequisites");
+  lines.push("");
+  lines.push("This SDK requires `@vertz/fetch` as a peer dependency:");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("bun add @vertz/fetch");
+  lines.push("```");
+  lines.push("");
+  lines.push("## Usage");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("import { createClient } from './client';");
+  lines.push("import { isOk } from '@vertz/fetch';");
+  lines.push("");
+  lines.push(`const api = createClient(${options.baseURL ? `{ baseURL: '${options.baseURL}' }` : ""});`);
+  lines.push("```");
+  lines.push("");
+  lines.push("## Resources");
+  lines.push("");
+  for (const r of spec.resources) {
+    lines.push(`### ${r.name}`);
+    lines.push("");
+    for (const op of r.operations) {
+      lines.push(`- \`api.${r.identifier}.${op.methodName}()\` — ${op.method} ${op.path}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Committing");
+  lines.push("");
+  lines.push("We recommend committing generated code to source control.");
+  lines.push("This ensures your CI builds work without running the generator.");
+  lines.push("");
+  lines.push("## Regenerating");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("npx @vertz/openapi generate");
+  lines.push("```");
+  lines.push("");
+  return { path: "README.md", content: lines.join(`
+`) };
+}
+
+// src/loader.ts
+import { existsSync, readFileSync } from "node:fs";
+import { extname } from "node:path";
+import { parse as parseYAML } from "yaml";
+
+class LoaderError extends Error {
+  name = "LoaderError";
+}
+async function loadSpec(source) {
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    return loadFromURL(source);
+  }
+  return loadFromFile(source);
+}
+function loadFromFile(filePath) {
+  if (!existsSync(filePath)) {
+    throw new LoaderError(`Spec file not found: ${filePath}`);
+  }
+  const content = readFileSync(filePath, "utf-8");
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".yaml" || ext === ".yml") {
+    return parseAsYAML(content, filePath);
+  }
+  if (ext === ".json") {
+    return parseAsJSON(content, filePath);
+  }
+  const trimmed = content.trimStart();
+  if (trimmed.startsWith("{")) {
+    return parseAsJSON(content, filePath);
+  }
+  return parseAsYAML(content, filePath);
+}
+async function loadFromURL(url) {
+  let response;
+  try {
+    response = await globalThis.fetch(url);
+  } catch (err) {
+    throw new LoaderError(`Failed to fetch spec from ${url}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!response.ok) {
+    throw new LoaderError(`Failed to fetch spec from ${url}: HTTP ${response.status}`);
+  }
+  const content = await response.text();
+  const urlPath = new URL(url).pathname;
+  const ext = extname(urlPath).toLowerCase();
+  if (ext === ".yaml" || ext === ".yml") {
+    return parseAsYAML(content, url);
+  }
+  if (ext === ".json") {
+    return parseAsJSON(content, url);
+  }
+  const trimmed = content.trimStart();
+  if (trimmed.startsWith("{")) {
+    return parseAsJSON(content, url);
+  }
+  return parseAsYAML(content, url);
+}
+function parseAsJSON(content, source) {
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new LoaderError(`Failed to parse ${source}: expected an object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof LoaderError)
+      throw err;
+    throw new LoaderError(`Failed to parse JSON from ${source}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function parseAsYAML(content, source) {
+  try {
+    const parsed = parseYAML(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new LoaderError(`Failed to parse ${source}: expected an object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof LoaderError)
+      throw err;
+    throw new LoaderError(`Failed to parse YAML from ${source}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+// src/parser/operation-id-normalizer.ts
+var HTTP_METHOD_WORDS = new Set(["get", "post", "put", "delete", "patch"]);
+function isPathParam(segment) {
+  return segment.startsWith("{") && segment.endsWith("}");
+}
+function getPathSegments(path) {
+  return path.split("/").filter(Boolean);
+}
+function splitWords2(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9]+/g, " ").split(/\s+/).filter(Boolean);
+}
+function toCamelCase(words) {
+  if (words.length === 0) {
+    return "";
+  }
+  const [first = "", ...rest] = words.map((word) => word.toLowerCase());
+  return first + rest.map((word) => word[0]?.toUpperCase() + word.slice(1)).join("");
+}
+function singularize(word) {
+  if (word.endsWith("ies") && word.length > 3) {
+    return `${word.slice(0, -3)}y`;
+  }
+  if (word.endsWith("s") && word.length > 1) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function getPrimaryResourceWords(path) {
+  const segments = getPathSegments(path).filter((segment) => !isPathParam(segment));
+  const firstSegment = segments[0];
+  if (!firstSegment) {
+    return [];
+  }
+  return splitWords2(firstSegment).map((word) => word.toLowerCase());
+}
+function autoCleanOperationId(operationId, path) {
+  const withoutControllerPrefix = operationId.replace(/^[A-Za-z0-9]+Controller[_.-]+/, "");
+  const words = splitWords2(withoutControllerPrefix).map((word) => word.toLowerCase());
+  const lastWord = words.at(-1);
+  if (words.length > 1 && lastWord && HTTP_METHOD_WORDS.has(lastWord)) {
+    words.pop();
+  }
+  const resourcePhrase = getPrimaryResourceWords(path);
+  const resourceWords = new Set([...resourcePhrase, ...resourcePhrase.map(singularize)]);
+  if (resourcePhrase.length === 1) {
+    while (words.length > 1 && words[0] && resourceWords.has(words[0])) {
+      words.shift();
+    }
+    while (words.length > 1 && words.at(-1) && resourceWords.has(words.at(-1))) {
+      words.pop();
+    }
+  }
+  return toCamelCase(words);
+}
+function detectCrudMethod(method, path) {
+  const segments = getPathSegments(path);
+  if (segments.length === 1 && method === "GET") {
+    return "list";
+  }
+  if (segments.length === 2 && segments[1] && isPathParam(segments[1])) {
+    if (method === "GET") {
+      return "get";
+    }
+    if (method === "PUT" || method === "PATCH") {
+      return "update";
+    }
+    if (method === "DELETE") {
+      return "delete";
+    }
+  }
+  if (segments.length === 1 && method === "POST") {
+    return "create";
+  }
+  return;
+}
+function normalizeOperationId(operationId, method, path, config, context) {
+  if (config?.overrides?.[operationId]) {
+    return config.overrides[operationId];
+  }
+  const cleaned = autoCleanOperationId(operationId, path);
+  if (config?.transform) {
+    const ctx = context ?? {
+      operationId,
+      method,
+      path,
+      tags: [],
+      hasBody: false
+    };
+    return config.transform(cleaned, ctx);
+  }
+  return detectCrudMethod(method, path) ?? cleaned;
+}
+
+// src/parser/ref-resolver.ts
+class OpenAPIParserError extends Error {
+  name = "OpenAPIParserError";
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function getRefSegments(ref) {
+  if (!ref.startsWith("#/")) {
+    throw new OpenAPIParserError(`External $ref values are not supported: ${ref}`);
+  }
+  return ref.slice(2).split("/");
+}
+function getRefName(ref) {
+  const segments = getRefSegments(ref);
+  return segments[segments.length - 1] ?? ref;
+}
+function getRawRefTarget(ref, document) {
+  let current = document;
+  for (const segment of getRefSegments(ref)) {
+    if (!isRecord(current) || !(segment in current)) {
+      throw new OpenAPIParserError(`Could not resolve $ref: ${ref}`);
+    }
+    current = current[segment];
+  }
+  if (!isRecord(current)) {
+    throw new OpenAPIParserError(`Resolved $ref is not an object schema: ${ref}`);
+  }
+  return current;
+}
+function resolveNestedValue(value, document, options, resolving) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => isRecord(entry) ? resolveSchema(entry, document, options, resolving) : entry);
+  }
+  if (isRecord(value)) {
+    return resolveSchema(value, document, options, resolving);
+  }
+  return value;
+}
+function mergeSchemas(left, right) {
+  const merged = { ...left };
+  for (const [key, value] of Object.entries(right)) {
+    if (key === "properties" && isRecord(merged.properties) && isRecord(value)) {
+      merged.properties = { ...merged.properties, ...value };
+      continue;
+    }
+    if (key === "required" && Array.isArray(merged.required) && Array.isArray(value)) {
+      merged.required = [...new Set([...merged.required, ...value])];
+      continue;
+    }
+    if (isRecord(merged[key]) && isRecord(value)) {
+      merged[key] = mergeSchemas(merged[key], value);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function resolveRef(ref, document, options) {
+  const target = getRawRefTarget(ref, document);
+  if (typeof target.$ref === "string") {
+    return resolveRef(target.$ref, document, options);
+  }
+  return resolveSchema(target, document, options);
+}
+function resolveSchema(schema, document, options, resolving = new Set) {
+  let workingSchema = { ...schema };
+  if (typeof workingSchema.$ref === "string") {
+    const ref = workingSchema.$ref;
+    if (resolving.has(ref)) {
+      return { $circular: getRefName(ref) };
+    }
+    const nextResolving = new Set(resolving);
+    nextResolving.add(ref);
+    const resolvedTarget = resolveSchema(getRawRefTarget(ref, document), document, options, nextResolving);
+    const siblingEntries = Object.entries(workingSchema).filter(([key]) => key !== "$ref");
+    if (options.specVersion === "3.0" || siblingEntries.length === 0) {
+      workingSchema = resolvedTarget;
+    } else {
+      const siblings = Object.fromEntries(siblingEntries);
+      workingSchema = mergeSchemas(resolvedTarget, resolveSchema(siblings, document, options, nextResolving));
+    }
+  }
+  if (Array.isArray(workingSchema.allOf)) {
+    const flattened = workingSchema.allOf.reduce((accumulator, member) => {
+      if (!isRecord(member)) {
+        return accumulator;
+      }
+      return mergeSchemas(accumulator, resolveSchema(member, document, options, new Set(resolving)));
+    }, {});
+    const { allOf: _allOf, ...rest } = workingSchema;
+    return mergeSchemas(flattened, resolveSchema(rest, document, options, resolving));
+  }
+  const resolved = {};
+  for (const [key, value] of Object.entries(workingSchema)) {
+    if (key === "properties" && isRecord(value)) {
+      resolved.properties = Object.fromEntries(Object.entries(value).map(([propertyName, propertySchema]) => [
+        propertyName,
+        isRecord(propertySchema) ? resolveSchema(propertySchema, document, options, new Set(resolving)) : propertySchema
+      ]));
+      continue;
+    }
+    resolved[key] = resolveNestedValue(value, document, options, new Set(resolving));
+  }
+  return resolved;
+}
+
+// src/parser/openapi-parser.ts
+class OpenAPIParserError2 extends Error {
+  name = "OpenAPIParserError";
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function getVersion(spec) {
+  const version = spec.openapi;
+  if (typeof version !== "string") {
+    throw new OpenAPIParserError2("OpenAPI spec is missing required field: openapi");
+  }
+  if (version.startsWith("3.0")) {
+    return "3.0";
+  }
+  if (version.startsWith("3.1")) {
+    return "3.1";
+  }
+  throw new OpenAPIParserError2(`Unsupported OpenAPI version: ${version}`);
+}
+function getRefTarget(ref, spec) {
+  if (!ref.startsWith("#/")) {
+    throw new OpenAPIParserError2(`External $ref values are not supported: ${ref}`);
+  }
+  let current = spec;
+  for (const segment of ref.slice(2).split("/")) {
+    if (!isRecord2(current) || !(segment in current)) {
+      throw new OpenAPIParserError2(`Could not resolve $ref: ${ref}`);
+    }
+    current = current[segment];
+  }
+  if (!isRecord2(current)) {
+    throw new OpenAPIParserError2(`Resolved $ref is not an object: ${ref}`);
+  }
+  return current;
+}
+function resolveOpenAPIObject(value, spec) {
+  if (!isRecord2(value)) {
+    return;
+  }
+  if (typeof value.$ref === "string") {
+    return resolveOpenAPIObject(getRefTarget(value.$ref, spec), spec);
+  }
+  return value;
+}
+function normalizeNullableSchema(schema, version) {
+  if (Array.isArray(schema)) {
+    return schema.map((entry) => normalizeNullableSchema(entry, version));
+  }
+  if (!isRecord2(schema)) {
+    return schema;
+  }
+  const normalized = Object.fromEntries(Object.entries(schema).map(([key, value]) => [key, normalizeNullableSchema(value, version)]));
+  if (version !== "3.0" || normalized.nullable !== true) {
+    return normalized;
+  }
+  const type = normalized.type;
+  if (typeof type === "string") {
+    normalized.type = [type, "null"];
+  } else if (Array.isArray(type) && !type.includes("null")) {
+    normalized.type = [...type, "null"];
+  }
+  delete normalized.nullable;
+  return normalized;
+}
+function getJsonContentSchema(value) {
+  if (!isRecord2(value) || !isRecord2(value.content)) {
+    return;
+  }
+  const mediaType = value.content["application/json"];
+  if (!isRecord2(mediaType) || !isRecord2(mediaType.schema)) {
+    return;
+  }
+  return mediaType.schema;
+}
+function extractRefName(schema) {
+  if (typeof schema.$ref === "string") {
+    const segments = schema.$ref.split("/");
+    return segments[segments.length - 1];
+  }
+  if (schema.type === "array" && isRecord2(schema.items) && typeof schema.items.$ref === "string") {
+    const segments = schema.items.$ref.split("/");
+    return segments[segments.length - 1];
+  }
+  return;
+}
+function resolveSchemaForOutput(schema, spec, version) {
+  const name = extractRefName(schema);
+  const result = {
+    jsonSchema: normalizeNullableSchema(resolveSchema(schema, spec, { specVersion: version }), version)
+  };
+  if (name)
+    result.name = name;
+  return result;
+}
+function getOperationResponses(operation) {
+  if (!isRecord2(operation.responses)) {
+    return {};
+  }
+  return operation.responses;
+}
+function pickSuccessResponse(operation, spec) {
+  const entries = Object.entries(getOperationResponses(operation)).map(([status, response]) => ({ status: Number(status), response })).filter(({ status }) => Number.isInteger(status) && status >= 200 && status < 300).sort((left, right) => left.status - right.status);
+  const first = entries[0];
+  if (!first) {
+    return { status: 200 };
+  }
+  const resolvedResponse = resolveOpenAPIObject(first.response, spec);
+  return {
+    status: first.status,
+    schema: getJsonContentSchema(resolvedResponse)
+  };
+}
+function getCombinedParameters(pathItem, operation, spec) {
+  const collect = (value) => Array.isArray(value) ? value.map((entry) => resolveOpenAPIObject(entry, spec)).filter((entry) => Boolean(entry)) : [];
+  return [...collect(pathItem.parameters), ...collect(operation.parameters)];
+}
+function getPathParameterNames(path) {
+  return [...path.matchAll(/\{([^}]+)\}/g)].map((match) => match[1]).filter((name) => Boolean(name));
+}
+function toParsedParameter(parameter, name, spec, version, requiredFallback) {
+  const resolvedSchema = isRecord2(parameter?.schema) ? normalizeNullableSchema(resolveSchema(parameter.schema, spec, { specVersion: version }), version) : {};
+  return {
+    name,
+    required: typeof parameter?.required === "boolean" ? parameter.required : requiredFallback,
+    schema: resolvedSchema
+  };
+}
+function extractParameters(path, pathItem, operation, spec, version) {
+  const combined = getCombinedParameters(pathItem, operation, spec);
+  const pathParameters = new Map;
+  const queryParameters = [];
+  for (const parameter of combined) {
+    if (parameter.in === "path" && typeof parameter.name === "string") {
+      pathParameters.set(parameter.name, parameter);
+    }
+    if (parameter.in === "query" && typeof parameter.name === "string") {
+      queryParameters.push(toParsedParameter(parameter, parameter.name, spec, version, false));
+    }
+  }
+  const pathNames = [...new Set([...getPathParameterNames(path), ...pathParameters.keys()])];
+  return {
+    pathParams: pathNames.map((name) => toParsedParameter(pathParameters.get(name), name, spec, version, true)),
+    queryParams: queryParameters
+  };
+}
+function extractRequestBody(operation, spec, version) {
+  const requestBody = resolveOpenAPIObject(operation.requestBody, spec);
+  const schema = getJsonContentSchema(requestBody);
+  return schema ? resolveSchemaForOutput(schema, spec, version) : undefined;
+}
+function collectComponentSchemas(spec, version) {
+  const schemas = isRecord2(spec.components) && isRecord2(spec.components.schemas) ? spec.components.schemas : undefined;
+  if (!schemas) {
+    return [];
+  }
+  return Object.entries(schemas).filter((entry) => isRecord2(entry[1])).map(([name, schema]) => ({
+    ...resolveSchemaForOutput(schema, spec, version),
+    name
+  }));
+}
+function extractSecuritySchemes(spec) {
+  const components = isRecord2(spec.components) ? spec.components : undefined;
+  const schemes = components && isRecord2(components.securitySchemes) ? components.securitySchemes : undefined;
+  if (!schemes)
+    return [];
+  const result = [];
+  for (const [name, scheme] of Object.entries(schemes)) {
+    if (!isRecord2(scheme))
+      continue;
+    const description = typeof scheme.description === "string" ? scheme.description : undefined;
+    if (scheme.type === "http") {
+      if (scheme.scheme === "bearer") {
+        result.push({ type: "bearer", name, description });
+      } else if (scheme.scheme === "basic") {
+        result.push({ type: "basic", name, description });
+      }
+    } else if (scheme.type === "apiKey") {
+      const location = scheme.in;
+      const paramName = typeof scheme.name === "string" ? scheme.name : name;
+      result.push({ type: "apiKey", name, in: location, paramName, description });
+    } else if (scheme.type === "oauth2" && isRecord2(scheme.flows)) {
+      const flows = {};
+      const rawFlows = scheme.flows;
+      if (isRecord2(rawFlows.authorizationCode)) {
+        const ac = rawFlows.authorizationCode;
+        flows.authorizationCode = {
+          authorizationUrl: String(ac.authorizationUrl ?? ""),
+          tokenUrl: String(ac.tokenUrl ?? ""),
+          scopes: isRecord2(ac.scopes) ? ac.scopes : {}
+        };
+      }
+      if (isRecord2(rawFlows.clientCredentials)) {
+        const cc = rawFlows.clientCredentials;
+        flows.clientCredentials = {
+          tokenUrl: String(cc.tokenUrl ?? ""),
+          scopes: isRecord2(cc.scopes) ? cc.scopes : {}
+        };
+      }
+      result.push({ type: "oauth2", name, flows, description });
+    }
+  }
+  return result;
+}
+function extractOperationSecurity(operation, globalSecurity) {
+  const security = Array.isArray(operation.security) ? operation.security : globalSecurity;
+  if (security.length === 0 && !Array.isArray(operation.security))
+    return;
+  const schemes = [];
+  for (const requirement of security) {
+    if (isRecord2(requirement)) {
+      schemes.push(...Object.keys(requirement));
+    }
+  }
+  return {
+    required: schemes.length > 0,
+    schemes
+  };
+}
+function parseOpenAPI(spec) {
+  const version = getVersion(spec);
+  if (!isRecord2(spec.info)) {
+    throw new OpenAPIParserError2("OpenAPI spec is missing required field: info");
+  }
+  if (!isRecord2(spec.paths)) {
+    throw new OpenAPIParserError2("OpenAPI spec is missing required field: paths");
+  }
+  const globalSecurity = Array.isArray(spec.security) ? spec.security : [];
+  const operations = [];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    if (!isRecord2(pathItem)) {
+      continue;
+    }
+    for (const method of ["get", "post", "put", "delete", "patch"]) {
+      const operation = pathItem[method];
+      if (!isRecord2(operation)) {
+        continue;
+      }
+      const operationId = typeof operation.operationId === "string" ? operation.operationId : `${method}_${path}`;
+      const { pathParams, queryParams } = extractParameters(path, pathItem, operation, spec, version);
+      const successResponse = pickSuccessResponse(operation, spec);
+      const security = extractOperationSecurity(operation, globalSecurity);
+      const parsed = {
+        operationId,
+        methodName: normalizeOperationId(operationId, method.toUpperCase(), path),
+        method: method.toUpperCase(),
+        path,
+        pathParams,
+        queryParams,
+        requestBody: extractRequestBody(operation, spec, version),
+        response: successResponse.schema ? resolveSchemaForOutput(successResponse.schema, spec, version) : undefined,
+        responseStatus: successResponse.status,
+        tags: Array.isArray(operation.tags) ? operation.tags.filter((tag) => typeof tag === "string") : []
+      };
+      if (security)
+        parsed.security = security;
+      operations.push(parsed);
+    }
+  }
+  return {
+    operations,
+    schemas: collectComponentSchemas(spec, version),
+    securitySchemes: extractSecuritySchemes(spec),
+    version
+  };
+}
+
+// src/writer/incremental.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join, relative } from "node:path";
+async function writeIncremental(files, outputDir, options) {
+  const clean = options?.clean ?? false;
+  const dryRun = options?.dryRun ?? false;
+  const result = { written: 0, skipped: 0, removed: 0, filesWritten: [] };
+  const generatedPaths = new Set(files.map((f) => f.path));
+  for (const file of files) {
+    const fullPath = join(outputDir, file.path);
+    const newHash = sha256(file.content);
+    if (existsSync2(fullPath)) {
+      const existingContent = readFileSync2(fullPath, "utf-8");
+      const existingHash = sha256(existingContent);
+      if (newHash === existingHash) {
+        result.skipped++;
+        continue;
+      }
+    }
+    result.written++;
+    result.filesWritten.push(file.path);
+    if (!dryRun) {
+      mkdirSync(dirname(fullPath), { recursive: true });
+      writeFileSync(fullPath, file.content);
+    }
+  }
+  if (clean && existsSync2(outputDir)) {
+    const existingFiles = collectFiles(outputDir, outputDir);
+    for (const existing of existingFiles) {
+      if (!generatedPaths.has(existing)) {
+        result.removed++;
+        if (!dryRun) {
+          rmSync(join(outputDir, existing));
+        }
+      }
+    }
+    if (!dryRun) {
+      removeEmptyDirs(outputDir);
+    }
+  }
+  return result;
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function removeEmptyDirs(dir) {
+  if (!existsSync2(dir))
+    return;
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry);
+    if (statSync(fullPath).isDirectory()) {
+      removeEmptyDirs(fullPath);
+      if (readdirSync(fullPath).length === 0) {
+        rmSync(fullPath, { recursive: true });
+      }
+    }
+  }
+}
+function collectFiles(dir, baseDir) {
+  const files = [];
+  if (!existsSync2(dir))
+    return files;
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry);
+    if (statSync(fullPath).isDirectory()) {
+      files.push(...collectFiles(fullPath, baseDir));
+    } else {
+      files.push(relative(baseDir, fullPath));
+    }
+  }
+  return files;
+}
+
+// src/generate.ts
+async function generateFromOpenAPI(config) {
+  const raw = await loadSpec(config.source);
+  const parsed = parseOpenAPI(raw);
+  if (config.operationIds) {
+    for (const op of parsed.operations) {
+      op.methodName = normalizeOperationId(op.operationId, op.method, op.path, config.operationIds, {
+        operationId: op.operationId,
+        method: op.method,
+        path: op.path,
+        tags: op.tags,
+        hasBody: op.requestBody !== undefined
+      });
+    }
+  }
+  const resources = groupOperations(parsed.operations, config.groupBy, {
+    excludeTags: config.excludeTags
+  });
+  const info = raw.info;
+  const spec = {
+    version: parsed.version,
+    info: {
+      title: typeof info?.title === "string" ? info.title : "Unknown",
+      version: typeof info?.version === "string" ? info.version : "0.0.0"
+    },
+    resources,
+    schemas: parsed.schemas,
+    securitySchemes: parsed.securitySchemes
+  };
+  const files = generateAll(spec, {
+    schemas: config.schemas,
+    baseURL: config.baseURL
+  });
+  return writeIncremental(files, config.output, {
+    clean: true,
+    dryRun: config.dryRun
+  });
+}
+
+// src/config.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+var DEFAULTS = {
+  output: "./src/generated",
+  baseURL: "",
+  groupBy: "tag",
+  schemas: false
+};
+function resolveConfig(cliFlags, configFile) {
+  const source = cliFlags.from ?? cliFlags.source ?? configFile?.source;
+  if (!source) {
+    throw new Error('Missing required "source" — provide --from <path> or set source in openapi.config.ts');
+  }
+  return {
+    source,
+    output: cliFlags.output ?? configFile?.output ?? DEFAULTS.output,
+    baseURL: cliFlags.baseURL ?? configFile?.baseURL ?? DEFAULTS.baseURL,
+    groupBy: cliFlags.groupBy ?? configFile?.groupBy ?? DEFAULTS.groupBy,
+    schemas: cliFlags.schemas ?? configFile?.schemas ?? DEFAULTS.schemas,
+    excludeTags: cliFlags.excludeTags ?? configFile?.excludeTags,
+    operationIds: cliFlags.operationIds ?? configFile?.operationIds
+  };
+}
+async function loadConfigFile(cwd) {
+  const configPath = join2(cwd, "openapi.config.ts");
+  if (!existsSync3(configPath))
+    return;
+  const mod = await import(configPath);
+  return mod.default ?? mod;
+}
+function defineConfig(config) {
+  return config;
+}
+
+export { sanitizeIdentifier, groupOperations, generateClient, jsonSchemaToTS, sanitizeTypeName, generateInterface, isValidIdentifier, generateResources, jsonSchemaToZod, generateSchemas, generateTypes, generateAll, loadSpec, normalizeOperationId, resolveRef, resolveSchema, parseOpenAPI, writeIncremental, generateFromOpenAPI, resolveConfig, loadConfigFile, defineConfig };