@contractkit/openapi-to-ck 0.10.1 → 0.11.0

package/dist/{chunk-JPI3AQ7V.js → chunk-Z53MK4FM.js}

@@ -4,15 +4,65 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/normalize.ts
 function normalize(doc, warnings) {
   const version = detectVersion(doc);
-  if (version === "2.0") {
-    return normalizeSwagger2(doc, warnings);
-  }
-  if (version === "3.0") {
-    return normalizeOas30(doc, warnings);
-  }
-  return doc;
+  const normalized = version === "2.0" ? normalizeSwagger2(doc, warnings) : version === "3.0" ? normalizeOas30(doc, warnings) : doc;
+  dereferenceComponents(normalized, warnings);
+  return normalized;
 }
 __name(normalize, "normalize");
+var DEREF_SECTIONS = [
+  "parameters",
+  "requestBodies",
+  "responses",
+  "headers"
+];
+var MAX_REF_DEPTH = 10;
+function dereferenceComponents(doc, warnings) {
+  const components = doc.components;
+  const resolve = /* @__PURE__ */ __name((node, path, depth = 0) => {
+    if (!node || typeof node !== "object") return node;
+    if (Array.isArray(node)) return node.map((item) => resolve(item, path, depth));
+    const obj = node;
+    const ref = obj.$ref;
+    if (typeof ref === "string") {
+      const match = /^#\/components\/([^/]+)\/(.+)$/.exec(ref);
+      const section = match?.[1];
+      if (section && section !== "schemas" && DEREF_SECTIONS.includes(section)) {
+        if (depth >= MAX_REF_DEPTH) {
+          warnings.warn(path, `$ref chain too deep to resolve: ${ref}`);
+          return obj;
+        }
+        const target = components?.[section]?.[decodeRefToken(match[2])];
+        if (target === void 0) {
+          warnings.warn(path, `unresolved $ref '${ref}' \u2014 the component is not defined`);
+          return obj;
+        }
+        const siblings = {
+          ...obj
+        };
+        delete siblings.$ref;
+        const resolved = resolve(target, path, depth + 1);
+        return {
+          ...resolved,
+          ...siblings
+        };
+      }
+      return obj;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(obj)) {
+      out[key] = key === "schema" || key === "schemas" ? value : resolve(value, `${path}/${key}`, depth);
+    }
+    return out;
+  }, "resolve");
+  for (const [path, pathItem] of Object.entries(doc.paths ?? {})) {
+    doc.paths[path] = resolve(pathItem, `#/paths/${path}`);
+  }
+}
+__name(dereferenceComponents, "dereferenceComponents");
+function decodeRefToken(token) {
+  return decodeURIComponent(token).replace(/~1/g, "/").replace(/~0/g, "~");
+}
+__name(decodeRefToken, "decodeRefToken");
 function detectVersion(doc) {
   if (typeof doc.swagger === "string" && doc.swagger.startsWith("2")) return "2.0";
   if (typeof doc.openapi === "string") {
@@ -82,7 +132,8 @@ function normalizePathItem2(pathItem, globalConsumes, globalProduces, warnings)
     "patch",
     "delete",
     "head",
-    "options"
+    "options",
+    "trace"
   ];
   const normalized = {};
   const pathParams = pathItem.parameters ?? [];
@@ -281,7 +332,8 @@ function normalizePathItemSchemas(pathItem) {
     "patch",
     "delete",
     "head",
-    "options"
+    "options",
+    "trace"
   ];
   for (const method of methods) {
     const op = pathItem[method];
@@ -419,12 +471,17 @@ var LOC = {
 };
 var FORMAT_TO_SCALAR = {
   email: "email",
+  "idn-email": "email",
   uri: "url",
+  "uri-reference": "url",
+  iri: "url",
+  "iri-reference": "url",
   url: "url",
   uuid: "uuid",
   date: "date",
   "date-time": "datetime",
   time: "time",
+  duration: "duration",
   binary: "binary",
   int64: "bigint"
 };
@@ -472,6 +529,11 @@ function schemaToModel(name, schema, ctx) {
       kind: "model",
       name,
       fields,
+      // `additionalProperties: true` says unknown keys are allowed, which is `mode(loose)`.
+      // `false` and absent both match `.ck`'s `strict` default, so neither needs a mode.
+      ...schema.additionalProperties === true ? {
+        mode: "loose"
+      } : {},
       description,
       loc: LOC
     };
@@ -488,10 +550,11 @@ function schemaToModel(name, schema, ctx) {
 }
 __name(schemaToModel, "schemaToModel");
 function schemaToTypeNode(schema, ctx) {
+  warnUnrepresentableConstraints(schema, ctx);
   if (schema.$ref) {
     const refName = extractRefName(schema.$ref);
     if (refName) {
-      if (ctx.circularRefs.has(refName)) {
+      if (ctx.insideModel && ctx.circularRefs.has(refName)) {
         return {
           kind: "lazy",
           inner: {
@@ -623,7 +686,7 @@ function stringSchemaToType(schema) {
     if (schema.minLength !== void 0) mods.min = schema.minLength;
     if (schema.maxLength !== void 0) mods.max = schema.maxLength;
   }
-  if (schema.pattern) mods.regex = `/${schema.pattern}/`;
+  if (schema.pattern) mods.regex = schema.pattern;
   if (schema.format && !FORMAT_TO_SCALAR[schema.format]) mods.format = schema.format;
   return {
     kind: "scalar",
@@ -793,12 +856,24 @@ function toDiscriminatedUnion(schemas, discriminator, ctx) {
   };
 }
 __name(toDiscriminatedUnion, "toDiscriminatedUnion");
+var UNREPRESENTABLE_KEYWORDS = [
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "uniqueItems"
+];
 function warnUnsupported(schema, ctx) {
   if (schema.xml) ctx.warnings.warn(ctx.path, "xml metadata is not supported, skipping");
   if (schema.externalDocs) ctx.warnings.info(ctx.path, "externalDocs is not supported, skipping");
   if (schema.not) ctx.warnings.warn(ctx.path, "not keyword is not supported, skipping");
 }
 __name(warnUnsupported, "warnUnsupported");
+function warnUnrepresentableConstraints(schema, ctx) {
+  for (const keyword of UNREPRESENTABLE_KEYWORDS) {
+    if (schema[keyword] !== void 0) ctx.warnings.warn(ctx.path, `${keyword} has no .ck equivalent, dropping the constraint`);
+  }
+}
+__name(warnUnrepresentableConstraints, "warnUnrepresentableConstraints");
 function extractInlineModel(schema, suggestedName, ctx) {
   if (schema.$ref) {
     return {
@@ -806,7 +881,10 @@ function extractInlineModel(schema, suggestedName, ctx) {
     };
   }
   if (schema.properties || schema.type === "object" && schema.additionalProperties === void 0) {
-    const fields = schemaPropertiesToFields(schema, ctx);
+    const fields = schemaPropertiesToFields(schema, {
+      ...ctx,
+      insideModel: true
+    });
     const model = {
       kind: "model",
       name: suggestedName,
@@ -829,10 +907,11 @@ function extractInlineModel(schema, suggestedName, ctx) {
 __name(extractInlineModel, "extractInlineModel");
 function sanitizeName(name, warnings) {
   const cleaned = name.replace(/[^a-zA-Z0-9_$]/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-  if (cleaned !== name) {
-    warnings.info(`#/components/schemas/${name}`, `Schema name sanitized: "${name}" \u2192 "${cleaned}"`);
+  const safe = /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
+  if (safe !== name) {
+    warnings.info(`#/components/schemas/${name}`, `Schema name sanitized: "${name}" \u2192 "${safe}"`);
   }
-  return cleaned || "UnnamedSchema";
+  return safe || "UnnamedSchema";
 }
 __name(sanitizeName, "sanitizeName");
 
@@ -841,6 +920,11 @@ var LOC2 = {
   file: "",
   line: 0
 };
+var MIME_RE = /^[a-z0-9][a-z0-9.+_-]*\/[a-z0-9][a-z0-9.+_-]*$/i;
+function toNameText(summary) {
+  return summary.replace(/[}#]/g, " ").replace(/\s+/g, " ").trim();
+}
+__name(toNameText, "toNameText");
 var HTTP_METHODS = [
   "get",
   "post",
@@ -848,6 +932,11 @@ var HTTP_METHODS = [
   "patch",
   "delete"
 ];
+var UNSUPPORTED_METHODS = [
+  "head",
+  "options",
+  "trace"
+];
 function pathsToRoutes(doc, ctx) {
   const routes = [];
   const routeTags = /* @__PURE__ */ new Map();
@@ -870,6 +959,11 @@ function pathItemToRoute(path, pathItem, ctx) {
   const operations = [];
   let primaryTag = "default";
   const pathParams = (pathItem.parameters ?? []).filter((p) => p.in === "path");
+  for (const method of UNSUPPORTED_METHODS) {
+    if (pathItem[method]) {
+      ctx.warnings.warn(`#/paths/${encodePathSegment2(path)}/${method}`, `\`${method}\` operations have no .ck equivalent; dropped`);
+    }
+  }
   for (const method of HTTP_METHODS) {
     const op = pathItem[method];
     if (!op) continue;
@@ -912,6 +1006,11 @@ function operationToNode(method, op, path, ctx) {
   if (op.operationId) {
     node.sdk = op.operationId;
   }
+  if (op.summary) {
+    const name = toNameText(op.summary);
+    if (name) node.name = name;
+    else ctx.warnings.warn(`${pathPrefix}/summary`, "summary has no content `.ck` can carry as a name; dropped");
+  }
   if (op.description && ctx.includeComments) {
     node.description = op.description;
   }
@@ -923,10 +1022,16 @@ function operationToNode(method, op, path, ctx) {
   const queryParams = [];
   const headerParams = [];
   for (const param of op.parameters ?? []) {
+    if (!param?.name) {
+      ctx.warnings.warn(`${pathPrefix}/parameters`, "skipped a parameter with no name (an unresolved $ref?)");
+      continue;
+    }
     if (param.in === "query") {
       queryParams.push(parameterToNode(param, schemaCtx));
     } else if (param.in === "header") {
       headerParams.push(parameterToNode(param, schemaCtx));
+    } else if (param.in === "cookie") {
+      ctx.warnings.warn(`${pathPrefix}/parameters/${param.name}`, "cookie parameters have no `.ck` equivalent; dropped");
     }
   }
   if (queryParams.length > 0) {
@@ -946,13 +1051,17 @@ function operationToNode(method, op, path, ctx) {
   }
   const responses = op.responses ?? {};
   for (const [code, resp] of Object.entries(responses)) {
+    if (!/^\d{3}$/.test(code)) {
+      ctx.warnings.warn(`${pathPrefix}/responses/${code}`, `response key '${code}' is not a numeric status code; dropped`);
+      continue;
+    }
     const statusCode = parseInt(code, 10);
-    if (isNaN(statusCode)) continue;
     const respNode = responseToNode(statusCode, resp, op.operationId ?? `${method}${toPascalCase(path)}`, schemaCtx, ctx);
     node.responses.push(respNode);
   }
-  if (op.security !== void 0) {
-    node.security = convertSecurity(op.security);
+  const security = op.security ?? ctx.globalSecurity;
+  if (security !== void 0) {
+    node.security = convertSecurity(security);
   }
   return node;
 }
@@ -1011,14 +1120,13 @@ __name(parameterToNode, "parameterToNode");
 function requestBodyToNode(reqBody, operationName, schemaCtx, ctx) {
   const content = reqBody.content;
   if (!content) return void 0;
-  const supported = /* @__PURE__ */ new Set([
-    "application/json",
-    "application/x-www-form-urlencoded",
-    "multipart/form-data"
-  ]);
   const bodies = [];
   for (const [contentType, mediaType] of Object.entries(content)) {
-    if (!supported.has(contentType) || !mediaType?.schema) continue;
+    if (!MIME_RE.test(contentType)) {
+      ctx.warnings.warn(`${schemaCtx.path}/requestBody/content`, `content type '${contentType}' is not a plain type/subtype; skipped`);
+      continue;
+    }
+    if (!mediaType?.schema) continue;
     const { typeNode, model } = extractInlineModel(mediaType.schema, `${toPascalCase(operationName)}Request`, schemaCtx);
     if (model) {
       ctx.extractedModels.push(model);
@@ -1034,14 +1142,24 @@ function requestBodyToNode(reqBody, operationName, schemaCtx, ctx) {
   };
 }
 __name(requestBodyToNode, "requestBodyToNode");
+function shouldDocument(statusCode, braced, resp, ctx) {
+  if (!braced) return false;
+  if (resp["x-contractkit-emit"] === "documented") return true;
+  return statusCode >= 400 && ctx.errorResponses === "documented";
+}
+__name(shouldDocument, "shouldDocument");
 function responseToNode(statusCode, resp, operationName, schemaCtx, ctx) {
   const headers = convertResponseHeaders(resp.headers, schemaCtx);
+  const documented = /* @__PURE__ */ __name((braced) => shouldDocument(statusCode, braced, resp, ctx) ? {
+    emit: "documented"
+  } : {}, "documented");
   const empty = /* @__PURE__ */ __name(() => ({
     statusCode,
     bodies: [],
     ...headers ? {
       headers,
-      hasBlock: true
+      hasBlock: true,
+      ...documented(true)
     } : {}
   }), "empty");
   if (!resp.content) return empty();
@@ -1063,7 +1181,8 @@ function responseToNode(statusCode, resp, operationName, schemaCtx, ctx) {
     hasBlock: true,
     ...headers ? {
       headers
-    } : {}
+    } : {},
+    ...documented(true)
   };
 }
 __name(responseToNode, "responseToNode");
@@ -1103,7 +1222,9 @@ function makeSchemaCtx(ctx, path) {
     includeComments: ctx.includeComments,
     namedSchemas: ctx.namedSchemas,
     extractedModels: ctx.extractedModels,
-    inlineCounter: 0
+    inlineCounter: 0,
+    // A response body, request body, param or header names an already-imported model.
+    insideModel: false
   };
 }
 __name(makeSchemaCtx, "makeSchemaCtx");
@@ -1224,20 +1345,16 @@ function collectRouteRefs(route, refs) {
 }
 __name(collectRouteRefs, "collectRouteRefs");
 function collectParamSourceRefs(source, refs) {
-  if (typeof source === "string") {
-    refs.add(source);
-    return;
-  }
-  if (Array.isArray(source)) {
-    for (const param of source) {
-      if (param && typeof param === "object" && "type" in param) {
-        collectTypeRefs(param.type, refs);
-      }
-    }
-    return;
-  }
-  if (source && typeof source === "object" && "kind" in source) {
-    collectTypeRefs(source, refs);
+  switch (source.kind) {
+    case "ref":
+      refs.add(source.name);
+      return;
+    case "params":
+      for (const param of source.nodes) collectTypeRefs(param.type, refs);
+      return;
+    case "type":
+      collectTypeRefs(source.node, refs);
+      return;
   }
 }
 __name(collectParamSourceRefs, "collectParamSourceRefs");
@@ -1284,347 +1401,12 @@ function sanitizeFilename(tag) {
 __name(sanitizeFilename, "sanitizeFilename");
 
 // src/ast-to-ck.ts
-var INDENT = "    ";
-var IDENT_RE = /^[a-zA-Z_$][a-zA-Z0-9_$\-.]*$/;
-function singleLineComment(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-__name(singleLineComment, "singleLineComment");
-function quoteEnumValue(value) {
-  if (IDENT_RE.test(value)) return value;
-  if (!value.includes('"')) return `"${value}"`;
-  if (!value.includes("'")) return `'${value}'`;
-  return `"${value}"`;
-}
-__name(quoteEnumValue, "quoteEnumValue");
-function astToCk(root, options = {}) {
-  const { includeComments = true } = options;
-  const ctx = {
-    includeComments
-  };
-  const parts = [];
-  const optionsBlock = serializeOptions(root);
-  if (optionsBlock) parts.push(optionsBlock);
-  for (const model of root.models) {
-    parts.push(serializeModel(model, ctx));
-  }
-  for (const route of root.routes) {
-    parts.push(serializeRoute(route, ctx));
-  }
-  return parts.join("\n\n") + "\n";
+import { printCk, printType } from "@contractkit/core";
+function astToCk(root, _options = {}) {
+  return printCk(root);
 }
 __name(astToCk, "astToCk");
-function serializeOptions(root) {
-  const hasKeys = Object.keys(root.meta).length > 0;
-  const hasServices = root.services && Object.keys(root.services).length > 0;
-  const hasSecurity = root.security !== void 0;
-  if (!hasKeys && !hasServices && !hasSecurity) return null;
-  const lines = [
-    "options {"
-  ];
-  if (hasKeys) {
-    lines.push(`${INDENT}keys: {`);
-    for (const [key, value] of Object.entries(root.meta)) {
-      lines.push(`${INDENT}${INDENT}${key}: ${value}`);
-    }
-    lines.push(`${INDENT}}`);
-  }
-  if (hasServices) {
-    lines.push(`${INDENT}services: {`);
-    for (const [name, path] of Object.entries(root.services)) {
-      lines.push(`${INDENT}${INDENT}${name}: "${path}"`);
-    }
-    lines.push(`${INDENT}}`);
-  }
-  if (hasSecurity) {
-    lines.push(`${INDENT}security: {`);
-    if (root.security === "none") {
-      lines.push(`${INDENT}${INDENT}none`);
-    } else {
-      const sec = root.security;
-      if (sec.policy !== void 0) {
-        const value = sec.policy === false ? "none" : sec.policy;
-        lines.push(`${INDENT}${INDENT}policy: ${value}`);
-      }
-    }
-    lines.push(`${INDENT}}`);
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-__name(serializeOptions, "serializeOptions");
-function serializeModel(model, ctx) {
-  const parts = [];
-  const prefixes = [];
-  if (model.inputCase && model.inputCase !== "camel") {
-    prefixes.push(`format(input=${model.inputCase})`);
-  }
-  if (model.mode && model.mode !== "strict") {
-    prefixes.push(`mode(${model.mode})`);
-  }
-  if (model.deprecated) {
-    prefixes.push("deprecated");
-  }
-  const prefix = prefixes.length > 0 ? prefixes.join(" ") + " " : "";
-  const comment = ctx.includeComments && model.description ? ` # ${singleLineComment(model.description)}` : "";
-  if (model.type) {
-    parts.push(`contract ${prefix}${model.name}: ${serializeType(model.type)}${comment}`);
-    return parts.join("");
-  }
-  if (model.bases && model.bases.length > 0) {
-    parts.push(`contract ${prefix}${model.name}: ${model.bases.join(" & ")} & {${comment}`);
-  } else {
-    parts.push(`contract ${prefix}${model.name}: {${comment}`);
-  }
-  for (const field of model.fields) {
-    parts.push(serializeField(field, 1, ctx));
-  }
-  parts.push("}");
-  return parts.join("\n");
-}
-__name(serializeModel, "serializeModel");
-function serializeField(field, depth, ctx) {
-  const indent = INDENT.repeat(depth);
-  const optional = field.optional ? "?" : "";
-  const visibility = field.visibility !== "normal" ? `${field.visibility} ` : "";
-  const deprecated = field.deprecated ? "deprecated " : "";
-  let typeStr = serializeType(field.type);
-  if (field.nullable && !typeContainsNull(field.type)) {
-    typeStr = `${typeStr} | null`;
-  }
-  const defaultVal = field.default !== void 0 ? ` = ${serializeDefault(field.default)}` : "";
-  const comment = ctx.includeComments && field.description ? ` # ${singleLineComment(field.description)}` : "";
-  return `${indent}${field.name}${optional}: ${deprecated}${visibility}${typeStr}${defaultVal}${comment}`;
-}
-__name(serializeField, "serializeField");
-function typeContainsNull(type) {
-  if (type.kind === "scalar" && type.name === "null") return true;
-  if (type.kind === "union") return type.members.some(typeContainsNull);
-  return false;
-}
-__name(typeContainsNull, "typeContainsNull");
-function serializeDefault(value) {
-  if (typeof value === "string") {
-    if (/^[a-zA-Z_$][a-zA-Z0-9_$\-.]*$/.test(value)) return value;
-    return `"${value}"`;
-  }
-  return String(value);
-}
-__name(serializeDefault, "serializeDefault");
-function serializeType(type) {
-  switch (type.kind) {
-    case "scalar":
-      return serializeScalar(type);
-    case "array":
-      return serializeArray(type);
-    case "tuple":
-      return `tuple(${type.items.map(serializeType).join(", ")})`;
-    case "record":
-      return `record(${serializeType(type.key)}, ${serializeType(type.value)})`;
-    case "enum":
-      return `enum(${type.values.map(quoteEnumValue).join(", ")})`;
-    case "literal":
-      return serializeLiteral(type);
-    case "union":
-      return type.members.map(serializeType).join(" | ");
-    case "discriminatedUnion":
-      return `discriminated(by=${type.discriminator}, ${type.members.map(serializeType).join(" | ")})`;
-    case "intersection":
-      return type.members.map(serializeType).join(" & ");
-    case "ref":
-      return type.name;
-    case "inlineObject":
-      return serializeInlineObject(type);
-    case "lazy":
-      return `lazy(${serializeType(type.inner)})`;
-  }
-}
-__name(serializeType, "serializeType");
-function serializeScalar(type) {
-  const args = [];
-  if (type.len !== void 0) args.push(`length=${type.len}`);
-  if (type.min !== void 0) args.push(typeof type.min === "string" ? `min="${type.min}"` : `min=${type.min}`);
-  if (type.max !== void 0) args.push(typeof type.max === "string" ? `max="${type.max}"` : `max=${type.max}`);
-  if (type.regex !== void 0) args.push(`regex=${type.regex}`);
-  if (type.format !== void 0) args.push(`format=${type.format}`);
-  if (args.length === 0) return type.name;
-  return `${type.name}(${args.join(", ")})`;
-}
-__name(serializeScalar, "serializeScalar");
-function serializeArray(type) {
-  const args = [
-    serializeType(type.item)
-  ];
-  if (type.min !== void 0) args.push(`min=${type.min}`);
-  if (type.max !== void 0) args.push(`max=${type.max}`);
-  return `array(${args.join(", ")})`;
-}
-__name(serializeArray, "serializeArray");
-function serializeLiteral(type) {
-  if (typeof type.value === "string") return `literal("${type.value}")`;
-  return `literal(${type.value})`;
-}
-__name(serializeLiteral, "serializeLiteral");
-function serializeInlineObject(type) {
-  const modePrefix = type.mode ? `mode(${type.mode}) ` : "";
-  if (type.fields.length === 0) return `${modePrefix}{}`;
-  const lines = [
-    `${modePrefix}{`
-  ];
-  for (const field of type.fields) {
-    lines.push(serializeField(field, 2, {
-      includeComments: true
-    }));
-  }
-  lines.push(`${INDENT}}`);
-  return lines.join("\n");
-}
-__name(serializeInlineObject, "serializeInlineObject");
-function serializeRoute(route, ctx) {
-  const lines = [];
-  const modStr = serializeModifiers(route.modifiers);
-  const comment = ctx.includeComments && route.description ? ` # ${singleLineComment(route.description)}` : "";
-  lines.push(`operation${modStr} ${route.path}: {${comment}`);
-  if (route.params) {
-    serializeParamSource(lines, "params", route.params, route.paramsMode, 1, ctx);
-  }
-  if (route.security !== void 0) {
-    serializeSecurityBlock(lines, route.security, 1, ctx);
-  }
-  for (const op of route.operations) {
-    serializeOperation(lines, op, 1, ctx);
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-__name(serializeRoute, "serializeRoute");
-function serializeOperation(lines, op, depth, ctx) {
-  const indent = INDENT.repeat(depth);
-  const modStr = serializeModifiers(op.modifiers);
-  const comment = ctx.includeComments && op.description ? ` # ${singleLineComment(op.description)}` : "";
-  lines.push(`${indent}${op.method}${modStr}: {${comment}`);
-  const inner = INDENT.repeat(depth + 1);
-  if (op.service) {
-    lines.push(`${inner}service: ${op.service}`);
-  }
-  if (op.sdk) {
-    lines.push(`${inner}sdk: ${op.sdk}`);
-  }
-  if (op.signature) {
-    const sigComment = ctx.includeComments && op.signatureDescription ? ` # ${singleLineComment(op.signatureDescription)}` : "";
-    if (op.signaturePolicy) {
-      lines.push(`${inner}signature: {`);
-      lines.push(`${inner}    options: ${op.signature}${sigComment}`);
-      lines.push(`${inner}    policy: ${op.signaturePolicy}`);
-      lines.push(`${inner}}`);
-    } else {
-      lines.push(`${inner}signature: ${op.signature}${sigComment}`);
-    }
-  }
-  if (op.security !== void 0) {
-    serializeSecurityBlock(lines, op.security, depth + 1, ctx);
-  }
-  if (op.query) {
-    serializeParamSource(lines, "query", op.query, op.queryMode, depth + 1, ctx);
-  }
-  if (op.headers) {
-    serializeParamSource(lines, "headers", op.headers, op.headersMode, depth + 1, ctx);
-  }
-  if (op.request) {
-    serializeRequest(lines, op.request, depth + 1);
-  }
-  if (op.responses.length > 0) {
-    serializeResponses(lines, op.responses, depth + 1);
-  }
-  lines.push(`${indent}}`);
-  return lines;
-}
-__name(serializeOperation, "serializeOperation");
-function serializeModifiers(modifiers) {
-  if (!modifiers || modifiers.length === 0) return "";
-  return `(${modifiers.join(", ")})`;
-}
-__name(serializeModifiers, "serializeModifiers");
-function serializeParamSource(lines, keyword, source, mode, depth, ctx) {
-  const indent = INDENT.repeat(depth);
-  if (source.kind === "ref") {
-    lines.push(`${indent}${keyword}: ${source.name}`);
-    return;
-  }
-  if (source.kind === "type") {
-    lines.push(`${indent}${keyword}: ${serializeType(source.node)}`);
-    return;
-  }
-  const modeStr = mode ? `mode(${mode}) ` : "";
-  lines.push(`${indent}${keyword}: ${modeStr}{`);
-  for (const param of source.nodes) {
-    const optional = param.optional ? "?" : "";
-    let typeStr = serializeType(param.type);
-    if (param.nullable && !typeContainsNull(param.type)) {
-      typeStr = `${typeStr} | null`;
-    }
-    const defaultVal = param.default !== void 0 ? ` = ${serializeDefault(param.default)}` : "";
-    const comment = ctx.includeComments && param.description ? ` # ${singleLineComment(param.description)}` : "";
-    lines.push(`${INDENT.repeat(depth + 1)}${param.name}${optional}: ${typeStr}${defaultVal}${comment}`);
-  }
-  lines.push(`${indent}}`);
-}
-__name(serializeParamSource, "serializeParamSource");
-function serializeRequest(lines, request, depth) {
-  const indent = INDENT.repeat(depth);
-  lines.push(`${indent}request: {`);
-  for (const body of request.bodies) {
-    lines.push(`${INDENT.repeat(depth + 1)}${body.contentType}: ${serializeType(body.bodyType)}`);
-  }
-  lines.push(`${indent}}`);
-}
-__name(serializeRequest, "serializeRequest");
-function serializeResponses(lines, responses, depth) {
-  const indent = INDENT.repeat(depth);
-  lines.push(`${indent}response: {`);
-  for (const resp of responses) {
-    const bodies = resp.bodies;
-    const hasHeaders = resp.headers && resp.headers.length > 0;
-    if (bodies.length > 0 || hasHeaders) {
-      lines.push(`${INDENT.repeat(depth + 1)}${resp.statusCode}: {`);
-      for (const body of bodies) {
-        lines.push(`${INDENT.repeat(depth + 2)}${body.contentType}: ${serializeType(body.bodyType)}`);
-      }
-      if (hasHeaders) {
-        lines.push(`${INDENT.repeat(depth + 2)}headers: {`);
-        for (const h of resp.headers) {
-          const opt = h.optional ? "?" : "";
-          const trail = h.description ? ` # ${singleLineComment(h.description)}` : "";
-          lines.push(`${INDENT.repeat(depth + 3)}${h.name}${opt}: ${serializeType(h.type)}${trail}`);
-        }
-        lines.push(`${INDENT.repeat(depth + 2)}}`);
-      }
-      lines.push(`${INDENT.repeat(depth + 1)}}`);
-    } else {
-      lines.push(`${INDENT.repeat(depth + 1)}${resp.statusCode}:`);
-    }
-  }
-  lines.push(`${indent}}`);
-}
-__name(serializeResponses, "serializeResponses");
-function serializeSecurityBlock(lines, security, depth, ctx) {
-  const indent = INDENT.repeat(depth);
-  if (security === "none") {
-    lines.push(`${indent}security: none`);
-    return;
-  }
-  const sec = security;
-  if (sec.policy !== void 0) {
-    const comment = ctx.includeComments && sec.policyDescription ? ` # ${singleLineComment(sec.policyDescription)}` : "";
-    const value = sec.policy === false ? "none" : sec.policy;
-    lines.push(`${indent}security: {`);
-    lines.push(`${INDENT.repeat(depth + 1)}policy: ${value}${comment}`);
-    lines.push(`${indent}}`);
-  } else {
-    lines.push(`${indent}security: {}`);
-  }
-}
-__name(serializeSecurityBlock, "serializeSecurityBlock");
+var serializeType = printType;
 
 // src/convert.ts
 import { readFileSync } from "fs";
@@ -1661,8 +1443,9 @@ var WarningCollector = class {
 };
 
 // src/convert.ts
+import { parseCk, decomposeCk, validateRefs, DiagnosticCollector } from "@contractkit/core";
 async function convertOpenApiToCk(options) {
-  const { split = "by-tag", includeComments = true } = options;
+  const { split = "by-tag", includeComments = true, errorResponses = "documented" } = options;
   const warnings = new WarningCollector(options.onWarning);
   const rawDoc = await parseInput(options.input);
   const doc = normalize(rawDoc, warnings);
@@ -1676,7 +1459,8 @@ async function convertOpenApiToCk(options) {
     includeComments,
     namedSchemas: schemas,
     extractedModels,
-    inlineCounter: 0
+    inlineCounter: 0,
+    insideModel: true
   };
   const models = schemasToModels(schemas, schemaCtx);
   const { routes, routeTags } = pathsToRoutes(doc, {
@@ -1685,28 +1469,50 @@ async function convertOpenApiToCk(options) {
     includeComments,
     namedSchemas: schemas,
     extractedModels,
-    globalSecurity: doc.security
+    globalSecurity: doc.security,
+    errorResponses
   });
+  const known = new Set(models.map((m) => m.name));
+  for (const extracted of extractedModels) {
+    if (known.has(extracted.name)) continue;
+    known.add(extracted.name);
+    models.push(extracted);
+  }
   const files = /* @__PURE__ */ new Map();
   if (split === "by-tag") {
     const ckRoots = splitByTag(models, routes, routeTags);
     for (const [filename, root] of ckRoots) {
-      files.set(filename, astToCk(root, {
-        includeComments
-      }));
+      files.set(filename, astToCk(root));
     }
   } else {
     const root = mergeIntoSingle(models, routes);
-    files.set("api.ck", astToCk(root, {
-      includeComments
-    }));
+    files.set("api.ck", astToCk(root));
   }
+  checkGeneratedFiles(files, warnings);
   return {
     files,
     warnings: warnings.warnings
   };
 }
 __name(convertOpenApiToCk, "convertOpenApiToCk");
+function checkGeneratedFiles(files, warnings) {
+  const diag = new DiagnosticCollector();
+  const roots = [];
+  for (const [filename, text] of files) {
+    const before = diag.getAll().length;
+    const root = parseCk(text, filename, diag);
+    if (diag.getAll().length === before) roots.push(root);
+  }
+  if (roots.length === files.size) {
+    const decomposed = roots.map(decomposeCk);
+    validateRefs(decomposed.map((d) => d.contract), decomposed.map((d) => d.op), diag);
+  }
+  for (const d of diag.getAll()) {
+    if (d.severity !== "error") continue;
+    warnings.warn(d.file, `generated .ck is not valid (line ${d.line}): ${d.message}`);
+  }
+}
+__name(checkGeneratedFiles, "checkGeneratedFiles");
 async function parseInput(input) {
   if (typeof input === "object") {
     return input;
@@ -1784,4 +1590,4 @@ export {
   serializeType,
   convertOpenApiToCk
 };
-//# sourceMappingURL=chunk-JPI3AQ7V.js.map
+//# sourceMappingURL=chunk-Z53MK4FM.js.map