@contractkit/openapi-to-ck 0.7.1 → 0.7.2

package/dist/chunk-MQTKLXTN.js

@@ -1,1681 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// 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;
-}
-__name(normalize, "normalize");
-function detectVersion(doc) {
-  if (typeof doc.swagger === "string" && doc.swagger.startsWith("2")) return "2.0";
-  if (typeof doc.openapi === "string") {
-    if (doc.openapi.startsWith("3.0")) return "3.0";
-  }
-  return "3.1";
-}
-__name(detectVersion, "detectVersion");
-function normalizeSwagger2(doc, warnings) {
-  const info = doc.info ?? {
-    title: "Untitled",
-    version: "0.0.0"
-  };
-  const basePath = doc.basePath ?? "";
-  const schemes = doc.schemes ?? [
-    "https"
-  ];
-  const host = doc.host ?? "localhost";
-  const globalConsumes = doc.consumes ?? [
-    "application/json"
-  ];
-  const globalProduces = doc.produces ?? [
-    "application/json"
-  ];
-  const result = {
-    openapi: "3.1.0",
-    info: {
-      title: info.title ?? "Untitled",
-      version: info.version ?? "0.0.0",
-      description: info.description
-    },
-    servers: [
-      {
-        url: `${schemes[0]}://${host}${basePath}`
-      }
-    ],
-    paths: {},
-    components: {
-      schemas: {},
-      securitySchemes: {}
-    },
-    tags: doc.tags ?? []
-  };
-  const definitions = doc.definitions ?? {};
-  for (const [name, schema] of Object.entries(definitions)) {
-    result.components.schemas[name] = normalizeNullable30(schema);
-  }
-  const secDefs = doc.securityDefinitions ?? {};
-  for (const [name, scheme] of Object.entries(secDefs)) {
-    result.components.securitySchemes[name] = convertSecurityScheme2(scheme);
-  }
-  const paths = doc.paths ?? {};
-  for (const [path, pathItem] of Object.entries(paths)) {
-    result.paths[path] = normalizePathItem2(pathItem, globalConsumes, globalProduces, warnings);
-  }
-  if (doc.security) {
-    result.security = doc.security;
-  }
-  return result;
-}
-__name(normalizeSwagger2, "normalizeSwagger2");
-function normalizePathItem2(pathItem, globalConsumes, globalProduces, warnings) {
-  const methods = [
-    "get",
-    "post",
-    "put",
-    "patch",
-    "delete",
-    "head",
-    "options"
-  ];
-  const normalized = {};
-  const pathParams = pathItem.parameters ?? [];
-  for (const method of methods) {
-    const op = pathItem[method];
-    if (!op) continue;
-    const opConsumes = op.consumes ?? globalConsumes;
-    const opProduces = op.produces ?? globalProduces;
-    const params = [
-      ...pathParams,
-      ...op.parameters ?? []
-    ];
-    const nonBodyParams = [];
-    let requestBody;
-    for (const param of params) {
-      if (param.in === "body") {
-        const contentType = opConsumes[0] ?? "application/json";
-        requestBody = {
-          description: param.description,
-          required: param.required ?? true,
-          content: {
-            [contentType]: {
-              schema: normalizeNullable30(param.schema ?? {})
-            }
-          }
-        };
-      } else if (param.in === "formData") {
-        warnings.info(`#/paths/${encodePathSegment(method)}`, "formData parameters converted to multipart/form-data requestBody");
-        if (!requestBody) {
-          requestBody = {
-            content: {
-              "multipart/form-data": {
-                schema: {
-                  type: "object",
-                  properties: {},
-                  required: []
-                }
-              }
-            }
-          };
-        }
-        const formSchema = requestBody.content["multipart/form-data"].schema;
-        const props = formSchema.properties;
-        props[param.name] = normalizeNullable30(param);
-        if (param.required) {
-          formSchema.required.push(param.name);
-        }
-      } else {
-        const normalizedParam = {
-          ...param
-        };
-        if (param.type) {
-          normalizedParam.schema = normalizeNullable30({
-            type: param.type,
-            format: param.format,
-            enum: param.enum,
-            items: param.items,
-            default: param.default,
-            minimum: param.minimum,
-            maximum: param.maximum,
-            minLength: param.minLength,
-            maxLength: param.maxLength,
-            pattern: param.pattern
-          });
-          delete normalizedParam.type;
-          delete normalizedParam.format;
-          delete normalizedParam.enum;
-          delete normalizedParam.items;
-        }
-        nonBodyParams.push(normalizedParam);
-      }
-    }
-    const responses = {};
-    const opResponses = op.responses ?? {};
-    for (const [code, resp] of Object.entries(opResponses)) {
-      const contentType = opProduces[0] ?? "application/json";
-      if (resp.schema) {
-        responses[code] = {
-          description: resp.description ?? "",
-          content: {
-            [contentType]: {
-              schema: normalizeNullable30(resp.schema)
-            }
-          }
-        };
-      } else {
-        responses[code] = {
-          description: resp.description ?? ""
-        };
-      }
-    }
-    normalized[method] = {
-      operationId: op.operationId,
-      summary: op.summary,
-      description: op.description,
-      tags: op.tags,
-      parameters: nonBodyParams.length > 0 ? nonBodyParams : void 0,
-      requestBody,
-      responses,
-      security: op.security,
-      deprecated: op.deprecated
-    };
-  }
-  return normalized;
-}
-__name(normalizePathItem2, "normalizePathItem2");
-function convertSecurityScheme2(scheme) {
-  const type = scheme.type;
-  if (type === "basic") {
-    return {
-      type: "http",
-      scheme: "basic"
-    };
-  }
-  if (type === "apiKey") {
-    return {
-      type: "apiKey",
-      name: scheme.name,
-      in: scheme.in
-    };
-  }
-  if (type === "oauth2") {
-    const flow = scheme.flow;
-    const flows = {};
-    if (flow === "implicit") {
-      flows.implicit = {
-        authorizationUrl: scheme.authorizationUrl,
-        scopes: scheme.scopes ?? {}
-      };
-    } else if (flow === "password") {
-      flows.password = {
-        tokenUrl: scheme.tokenUrl,
-        scopes: scheme.scopes ?? {}
-      };
-    } else if (flow === "application") {
-      flows.clientCredentials = {
-        tokenUrl: scheme.tokenUrl,
-        scopes: scheme.scopes ?? {}
-      };
-    } else if (flow === "accessCode") {
-      flows.authorizationCode = {
-        authorizationUrl: scheme.authorizationUrl,
-        tokenUrl: scheme.tokenUrl,
-        scopes: scheme.scopes ?? {}
-      };
-    }
-    return {
-      type: "oauth2",
-      flows
-    };
-  }
-  return scheme;
-}
-__name(convertSecurityScheme2, "convertSecurityScheme2");
-function normalizeOas30(doc, _warnings) {
-  if (doc.components?.schemas) {
-    for (const [name, schema] of Object.entries(doc.components.schemas)) {
-      doc.components.schemas[name] = normalizeNullable30(schema);
-    }
-  }
-  if (doc.paths) {
-    for (const pathItem of Object.values(doc.paths)) {
-      normalizePathItemSchemas(pathItem);
-    }
-  }
-  doc.openapi = "3.1.0";
-  return doc;
-}
-__name(normalizeOas30, "normalizeOas30");
-function normalizePathItemSchemas(pathItem) {
-  const methods = [
-    "get",
-    "post",
-    "put",
-    "patch",
-    "delete",
-    "head",
-    "options"
-  ];
-  for (const method of methods) {
-    const op = pathItem[method];
-    if (!op) continue;
-    const params = op.parameters ?? [];
-    for (const param of params) {
-      if (param.schema) {
-        param.schema = normalizeNullable30(param.schema);
-      }
-    }
-    const reqBody = op.requestBody;
-    if (reqBody?.content) {
-      for (const mediaType of Object.values(reqBody.content)) {
-        if (mediaType.schema) {
-          mediaType.schema = normalizeNullable30(mediaType.schema);
-        }
-      }
-    }
-    const responses = op.responses ?? {};
-    for (const resp of Object.values(responses)) {
-      if (resp.content) {
-        for (const mediaType of Object.values(resp.content)) {
-          if (mediaType.schema) {
-            mediaType.schema = normalizeNullable30(mediaType.schema);
-          }
-        }
-      }
-    }
-  }
-}
-__name(normalizePathItemSchemas, "normalizePathItemSchemas");
-function normalizeNullable30(schema) {
-  if (!schema || typeof schema !== "object") return schema;
-  const result = {
-    ...schema
-  };
-  if (result.nullable === true && typeof result.type === "string") {
-    result.type = [
-      result.type,
-      "null"
-    ];
-    delete result.nullable;
-  }
-  if (result.properties && typeof result.properties === "object") {
-    const props = result.properties;
-    for (const [key, val] of Object.entries(props)) {
-      props[key] = normalizeNullable30(val);
-    }
-  }
-  if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) {
-    result.items = normalizeNullable30(result.items);
-  }
-  if (result.additionalProperties && typeof result.additionalProperties === "object") {
-    result.additionalProperties = normalizeNullable30(result.additionalProperties);
-  }
-  for (const combiner of [
-    "allOf",
-    "oneOf",
-    "anyOf"
-  ]) {
-    if (Array.isArray(result[combiner])) {
-      result[combiner] = result[combiner].map(normalizeNullable30);
-    }
-  }
-  return result;
-}
-__name(normalizeNullable30, "normalizeNullable30");
-function encodePathSegment(s) {
-  return s.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-__name(encodePathSegment, "encodePathSegment");
-
-// src/circular-refs.ts
-function detectCircularRefs(schemas) {
-  const circular = /* @__PURE__ */ new Set();
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  function visit(name) {
-    if (visited.has(name)) return;
-    if (visiting.has(name)) {
-      circular.add(name);
-      return;
-    }
-    visiting.add(name);
-    const schema = schemas[name];
-    if (schema && typeof schema === "object") {
-      for (const ref of collectRefs(schema)) {
-        const refName = extractRefName(ref);
-        if (refName && schemas[refName]) {
-          visit(refName);
-        }
-      }
-    }
-    visiting.delete(name);
-    visited.add(name);
-  }
-  __name(visit, "visit");
-  for (const name of Object.keys(schemas)) {
-    visit(name);
-  }
-  return circular;
-}
-__name(detectCircularRefs, "detectCircularRefs");
-function collectRefs(obj) {
-  const refs = [];
-  function walk(val) {
-    if (!val || typeof val !== "object") return;
-    if (Array.isArray(val)) {
-      for (const item of val) walk(item);
-      return;
-    }
-    const record = val;
-    if (typeof record.$ref === "string") {
-      refs.push(record.$ref);
-    }
-    for (const v of Object.values(record)) {
-      walk(v);
-    }
-  }
-  __name(walk, "walk");
-  walk(obj);
-  return refs;
-}
-__name(collectRefs, "collectRefs");
-function extractRefName(ref) {
-  const match = ref.match(/^#\/(?:components\/schemas|definitions)\/(.+)$/);
-  return match?.[1];
-}
-__name(extractRefName, "extractRefName");
-
-// src/schema-to-ast.ts
-var LOC = {
-  file: "",
-  line: 0
-};
-var FORMAT_TO_SCALAR = {
-  email: "email",
-  uri: "url",
-  url: "url",
-  uuid: "uuid",
-  date: "date",
-  "date-time": "datetime",
-  time: "time",
-  binary: "binary",
-  int64: "bigint"
-};
-function schemasToModels(schemas, ctx) {
-  const models = [];
-  for (const [name, schema] of Object.entries(schemas)) {
-    const modelCtx = {
-      ...ctx,
-      path: `#/components/schemas/${name}`
-    };
-    const model = schemaToModel(name, schema, modelCtx);
-    if (model) models.push(model);
-  }
-  models.push(...ctx.extractedModels);
-  return models;
-}
-__name(schemasToModels, "schemasToModels");
-function schemaToModel(name, schema, ctx) {
-  warnUnsupported(schema, ctx);
-  const description = ctx.includeComments ? schema.description : void 0;
-  if (schema.allOf && schema.allOf.length === 2) {
-    const [first, second] = schema.allOf;
-    const refMember = first?.$ref ? first : second?.$ref ? second : null;
-    const objectMember = first?.$ref ? second : first;
-    if (refMember?.$ref && objectMember?.properties) {
-      const baseName = extractRefName(refMember.$ref);
-      if (baseName) {
-        const fields = schemaPropertiesToFields(objectMember, ctx);
-        return {
-          kind: "model",
-          name,
-          base: baseName,
-          fields,
-          description,
-          loc: LOC
-        };
-      }
-    }
-  }
-  if (schema.properties || schema.type === "object" && !schema.additionalProperties) {
-    const fields = schemaPropertiesToFields(schema, ctx);
-    return {
-      kind: "model",
-      name,
-      fields,
-      description,
-      loc: LOC
-    };
-  }
-  const typeNode = schemaToTypeNode(schema, ctx);
-  return {
-    kind: "model",
-    name,
-    fields: [],
-    type: typeNode,
-    description,
-    loc: LOC
-  };
-}
-__name(schemaToModel, "schemaToModel");
-function schemaToTypeNode(schema, ctx) {
-  if (schema.$ref) {
-    const refName = extractRefName(schema.$ref);
-    if (refName) {
-      if (ctx.circularRefs.has(refName)) {
-        return {
-          kind: "lazy",
-          inner: {
-            kind: "ref",
-            name: refName
-          }
-        };
-      }
-      return {
-        kind: "ref",
-        name: refName
-      };
-    }
-    ctx.warnings.warn(ctx.path, `Unresolvable $ref: ${schema.$ref}`);
-    return {
-      kind: "scalar",
-      name: "unknown"
-    };
-  }
-  if (schema.const !== void 0) {
-    return {
-      kind: "literal",
-      value: schema.const
-    };
-  }
-  if (schema.enum) {
-    return {
-      kind: "enum",
-      values: schema.enum.map(String)
-    };
-  }
-  if (schema.oneOf && schema.oneOf.length > 0) {
-    return toUnion(schema.oneOf, ctx);
-  }
-  if (schema.anyOf && schema.anyOf.length > 0) {
-    return toUnion(schema.anyOf, ctx);
-  }
-  if (schema.allOf && schema.allOf.length > 0) {
-    if (schema.allOf.length === 1) {
-      return schemaToTypeNode(schema.allOf[0], ctx);
-    }
-    return {
-      kind: "intersection",
-      members: schema.allOf.map((s) => schemaToTypeNode(s, ctx))
-    };
-  }
-  const types = normalizeTypeField(schema);
-  if (types === null) {
-    if (schema.properties) {
-      return schemaToInlineObject(schema, ctx);
-    }
-    return {
-      kind: "scalar",
-      name: "unknown"
-    };
-  }
-  const { baseType, nullable } = types;
-  let typeNode;
-  switch (baseType) {
-    case "string":
-      typeNode = stringSchemaToType(schema);
-      break;
-    case "integer":
-      typeNode = integerSchemaToType(schema);
-      break;
-    case "number":
-      typeNode = numberSchemaToType(schema);
-      break;
-    case "boolean":
-      typeNode = {
-        kind: "scalar",
-        name: "boolean"
-      };
-      break;
-    case "null":
-      typeNode = {
-        kind: "scalar",
-        name: "null"
-      };
-      break;
-    case "array":
-      typeNode = arraySchemaToType(schema, ctx);
-      break;
-    case "object":
-      typeNode = objectSchemaToType(schema, ctx);
-      break;
-    default:
-      ctx.warnings.warn(ctx.path, `Unknown type: ${baseType}`);
-      typeNode = {
-        kind: "scalar",
-        name: "unknown"
-      };
-  }
-  if (nullable) {
-    return {
-      kind: "union",
-      members: [
-        typeNode,
-        {
-          kind: "scalar",
-          name: "null"
-        }
-      ]
-    };
-  }
-  return typeNode;
-}
-__name(schemaToTypeNode, "schemaToTypeNode");
-function stringSchemaToType(schema) {
-  if (schema.format) {
-    const scalarName = FORMAT_TO_SCALAR[schema.format];
-    if (scalarName) {
-      return {
-        kind: "scalar",
-        name: scalarName
-      };
-    }
-  }
-  const mods = {};
-  if (schema.minLength !== void 0 && schema.maxLength !== void 0 && schema.minLength === schema.maxLength) {
-    mods.len = schema.minLength;
-  } else {
-    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.format && !FORMAT_TO_SCALAR[schema.format]) mods.format = schema.format;
-  return {
-    kind: "scalar",
-    name: "string",
-    ...mods
-  };
-}
-__name(stringSchemaToType, "stringSchemaToType");
-function integerSchemaToType(schema) {
-  const name = schema.format === "int64" ? "bigint" : "int";
-  const mods = {};
-  if (schema.minimum !== void 0) mods.min = schema.minimum;
-  if (schema.maximum !== void 0) mods.max = schema.maximum;
-  return {
-    kind: "scalar",
-    name,
-    ...mods
-  };
-}
-__name(integerSchemaToType, "integerSchemaToType");
-function numberSchemaToType(schema) {
-  const mods = {};
-  if (schema.minimum !== void 0) mods.min = schema.minimum;
-  if (schema.maximum !== void 0) mods.max = schema.maximum;
-  return {
-    kind: "scalar",
-    name: "number",
-    ...mods
-  };
-}
-__name(numberSchemaToType, "numberSchemaToType");
-function arraySchemaToType(schema, ctx) {
-  if (schema.prefixItems && schema.prefixItems.length > 0) {
-    return {
-      kind: "tuple",
-      items: schema.prefixItems.map((s) => schemaToTypeNode(s, ctx))
-    };
-  }
-  const item = schema.items ? schemaToTypeNode(schema.items, ctx) : {
-    kind: "scalar",
-    name: "unknown"
-  };
-  const mods = {};
-  if (schema.minItems !== void 0) mods.min = schema.minItems;
-  if (schema.maxItems !== void 0) mods.max = schema.maxItems;
-  return {
-    kind: "array",
-    item,
-    ...mods
-  };
-}
-__name(arraySchemaToType, "arraySchemaToType");
-function objectSchemaToType(schema, ctx) {
-  if (schema.additionalProperties && typeof schema.additionalProperties === "object" && !schema.properties) {
-    return {
-      kind: "record",
-      key: {
-        kind: "scalar",
-        name: "string"
-      },
-      value: schemaToTypeNode(schema.additionalProperties, ctx)
-    };
-  }
-  if (schema.properties) {
-    return schemaToInlineObject(schema, ctx);
-  }
-  return {
-    kind: "scalar",
-    name: "object"
-  };
-}
-__name(objectSchemaToType, "objectSchemaToType");
-function schemaToInlineObject(schema, ctx) {
-  const fields = schemaPropertiesToFields(schema, ctx);
-  return {
-    kind: "inlineObject",
-    fields
-  };
-}
-__name(schemaToInlineObject, "schemaToInlineObject");
-function schemaPropertiesToFields(schema, ctx) {
-  const properties = schema.properties ?? {};
-  const required = new Set(schema.required ?? []);
-  const fields = [];
-  for (const [name, propSchema] of Object.entries(properties)) {
-    const propCtx = {
-      ...ctx,
-      path: `${ctx.path}/properties/${name}`
-    };
-    const fieldType = schemaToTypeNode(propSchema, propCtx);
-    let nullable = false;
-    let effectiveType = fieldType;
-    if (fieldType.kind === "union") {
-      const nonNull = fieldType.members.filter((m) => !(m.kind === "scalar" && m.name === "null"));
-      if (nonNull.length < fieldType.members.length) {
-        nullable = true;
-        effectiveType = nonNull.length === 1 ? nonNull[0] : {
-          kind: "union",
-          members: nonNull
-        };
-      }
-    }
-    const visibility = propSchema.readOnly ? "readonly" : propSchema.writeOnly ? "writeonly" : "normal";
-    fields.push({
-      name,
-      optional: !required.has(name),
-      nullable,
-      visibility,
-      type: effectiveType,
-      default: propSchema.default,
-      deprecated: propSchema.deprecated,
-      description: ctx.includeComments ? propSchema.description : void 0,
-      loc: LOC
-    });
-  }
-  return fields;
-}
-__name(schemaPropertiesToFields, "schemaPropertiesToFields");
-function normalizeTypeField(schema) {
-  if (!schema.type) return null;
-  if (typeof schema.type === "string") {
-    return {
-      baseType: schema.type,
-      nullable: false
-    };
-  }
-  if (Array.isArray(schema.type)) {
-    const types = schema.type;
-    const nonNull = types.filter((t) => t !== "null");
-    const nullable = types.includes("null");
-    if (nonNull.length === 1) {
-      return {
-        baseType: nonNull[0],
-        nullable
-      };
-    }
-    if (nonNull.length === 0) {
-      return {
-        baseType: "null",
-        nullable: false
-      };
-    }
-    return {
-      baseType: nonNull[0],
-      nullable
-    };
-  }
-  return null;
-}
-__name(normalizeTypeField, "normalizeTypeField");
-function toUnion(schemas, ctx) {
-  const members = schemas.map((s) => schemaToTypeNode(s, ctx));
-  if (members.length === 1) return members[0];
-  return {
-    kind: "union",
-    members
-  };
-}
-__name(toUnion, "toUnion");
-function warnUnsupported(schema, ctx) {
-  if (schema.discriminator) ctx.warnings.warn(ctx.path, "discriminator is not supported, skipping");
-  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 extractInlineModel(schema, suggestedName, ctx) {
-  if (schema.$ref) {
-    return {
-      typeNode: schemaToTypeNode(schema, ctx)
-    };
-  }
-  if (schema.properties || schema.type === "object" && schema.additionalProperties === void 0) {
-    const fields = schemaPropertiesToFields(schema, ctx);
-    const model = {
-      kind: "model",
-      name: suggestedName,
-      fields,
-      description: ctx.includeComments ? schema.description : void 0,
-      loc: LOC
-    };
-    return {
-      typeNode: {
-        kind: "ref",
-        name: suggestedName
-      },
-      model
-    };
-  }
-  return {
-    typeNode: schemaToTypeNode(schema, 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}"`);
-  }
-  return cleaned || "UnnamedSchema";
-}
-__name(sanitizeName, "sanitizeName");
-
-// src/paths-to-ast.ts
-var LOC2 = {
-  file: "",
-  line: 0
-};
-var HTTP_METHODS = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete"
-];
-function pathsToRoutes(doc, ctx) {
-  const routes = [];
-  const routeTags = /* @__PURE__ */ new Map();
-  const paths = doc.paths ?? {};
-  for (const [path, pathItem] of Object.entries(paths)) {
-    if (!pathItem) continue;
-    const result = pathItemToRoute(path, pathItem, ctx);
-    if (result) {
-      routes.push(result.route);
-      routeTags.set(result.route, result.tag);
-    }
-  }
-  return {
-    routes,
-    routeTags
-  };
-}
-__name(pathsToRoutes, "pathsToRoutes");
-function pathItemToRoute(path, pathItem, ctx) {
-  const operations = [];
-  let primaryTag = "default";
-  const pathParams = (pathItem.parameters ?? []).filter((p) => p.in === "path");
-  for (const method of HTTP_METHODS) {
-    const op = pathItem[method];
-    if (!op) continue;
-    const opNode = operationToNode(method, op, path, ctx);
-    operations.push(opNode);
-    if (op.tags && op.tags.length > 0 && primaryTag === "default") {
-      primaryTag = op.tags[0];
-    }
-  }
-  if (operations.length === 0) return null;
-  const params = buildPathParams(path, pathParams, pathItem, ctx);
-  const route = {
-    path,
-    operations,
-    loc: LOC2
-  };
-  if (params.length > 0) {
-    route.params = {
-      kind: "params",
-      nodes: params
-    };
-  }
-  if (pathItem.description && ctx.includeComments) {
-    route.description = pathItem.description;
-  }
-  return {
-    route,
-    tag: primaryTag
-  };
-}
-__name(pathItemToRoute, "pathItemToRoute");
-function operationToNode(method, op, path, ctx) {
-  const pathPrefix = `#/paths/${encodePathSegment2(path)}/${method}`;
-  const schemaCtx = makeSchemaCtx(ctx, pathPrefix);
-  const node = {
-    method,
-    responses: [],
-    loc: LOC2
-  };
-  if (op.operationId) {
-    node.sdk = op.operationId;
-  }
-  if (op.description && ctx.includeComments) {
-    node.description = op.description;
-  }
-  if (op.deprecated) {
-    node.modifiers = [
-      "deprecated"
-    ];
-  }
-  const queryParams = [];
-  const headerParams = [];
-  for (const param of op.parameters ?? []) {
-    if (param.in === "query") {
-      queryParams.push(parameterToNode(param, schemaCtx));
-    } else if (param.in === "header") {
-      headerParams.push(parameterToNode(param, schemaCtx));
-    }
-  }
-  if (queryParams.length > 0) {
-    node.query = {
-      kind: "params",
-      nodes: queryParams
-    };
-  }
-  if (headerParams.length > 0) {
-    node.headers = {
-      kind: "params",
-      nodes: headerParams
-    };
-  }
-  if (op.requestBody) {
-    node.request = requestBodyToNode(op.requestBody, op.operationId ?? `${method}${toPascalCase(path)}`, schemaCtx, ctx);
-  }
-  const responses = op.responses ?? {};
-  for (const [code, resp] of Object.entries(responses)) {
-    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);
-  }
-  return node;
-}
-__name(operationToNode, "operationToNode");
-function buildPathParams(path, pathLevelParams, pathItem, ctx) {
-  const schemaCtx = makeSchemaCtx(ctx, `#/paths/${encodePathSegment2(path)}`);
-  const paramMap = /* @__PURE__ */ new Map();
-  for (const p of pathLevelParams) {
-    paramMap.set(p.name, p);
-  }
-  for (const method of HTTP_METHODS) {
-    const op = pathItem[method];
-    if (!op?.parameters) continue;
-    for (const p of op.parameters) {
-      if (p.in === "path" && !paramMap.has(p.name)) {
-        paramMap.set(p.name, p);
-      }
-    }
-  }
-  const templateNames = [
-    ...path.matchAll(/\{([^}]+)\}/g)
-  ].map((m) => m[1]);
-  return templateNames.map((name) => {
-    const param = paramMap.get(name);
-    if (param) {
-      return parameterToNode(param, schemaCtx);
-    }
-    return {
-      name,
-      optional: false,
-      nullable: false,
-      type: {
-        kind: "scalar",
-        name: "string"
-      },
-      loc: LOC2
-    };
-  });
-}
-__name(buildPathParams, "buildPathParams");
-function parameterToNode(param, ctx) {
-  const type = param.schema ? schemaToTypeNode(param.schema, ctx) : {
-    kind: "scalar",
-    name: "string"
-  };
-  return {
-    name: param.name,
-    optional: param.in !== "path" && !param.required,
-    nullable: false,
-    type,
-    description: ctx.includeComments ? param.description : void 0,
-    loc: LOC2
-  };
-}
-__name(parameterToNode, "parameterToNode");
-function requestBodyToNode(reqBody, operationName, schemaCtx, ctx) {
-  const content = reqBody.content;
-  if (!content) return void 0;
-  const [contentType, mediaType] = Object.entries(content)[0] ?? [];
-  if (!contentType || !mediaType?.schema) return void 0;
-  const { typeNode, model } = extractInlineModel(mediaType.schema, `${toPascalCase(operationName)}Request`, schemaCtx);
-  if (model) {
-    ctx.extractedModels.push(model);
-  }
-  return {
-    contentType,
-    bodyType: typeNode
-  };
-}
-__name(requestBodyToNode, "requestBodyToNode");
-function responseToNode(statusCode, resp, operationName, schemaCtx, ctx) {
-  if (!resp.content) {
-    return {
-      statusCode
-    };
-  }
-  const [contentType, mediaType] = Object.entries(resp.content)[0] ?? [];
-  if (!contentType || !mediaType?.schema) {
-    return {
-      statusCode
-    };
-  }
-  const { typeNode, model } = extractInlineModel(mediaType.schema, `${toPascalCase(operationName)}Response${statusCode}`, schemaCtx);
-  if (model) {
-    ctx.extractedModels.push(model);
-  }
-  return {
-    statusCode,
-    contentType,
-    bodyType: typeNode
-  };
-}
-__name(responseToNode, "responseToNode");
-function convertSecurity(security) {
-  if (security.length === 0) {
-    return "none";
-  }
-  const allScopes = [];
-  for (const requirement of security) {
-    for (const scopes of Object.values(requirement)) {
-      allScopes.push(...scopes);
-    }
-  }
-  if (allScopes.length > 0) {
-    return {
-      roles: allScopes,
-      loc: LOC2
-    };
-  }
-  return {
-    roles: [],
-    loc: LOC2
-  };
-}
-__name(convertSecurity, "convertSecurity");
-function makeSchemaCtx(ctx, path) {
-  return {
-    circularRefs: ctx.circularRefs,
-    warnings: ctx.warnings,
-    path,
-    includeComments: ctx.includeComments,
-    namedSchemas: ctx.namedSchemas,
-    extractedModels: ctx.extractedModels,
-    inlineCounter: 0
-  };
-}
-__name(makeSchemaCtx, "makeSchemaCtx");
-function toPascalCase(input) {
-  return input.replace(/[^a-zA-Z0-9]/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-__name(toPascalCase, "toPascalCase");
-function encodePathSegment2(s) {
-  return s.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-__name(encodePathSegment2, "encodePathSegment");
-
-// src/tag-splitter.ts
-function splitByTag(models, routes, routeTags) {
-  const routesByTag = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    const tag = routeTags.get(route) ?? "default";
-    const group = routesByTag.get(tag) ?? [];
-    group.push(route);
-    routesByTag.set(tag, group);
-  }
-  const modelsByTag = /* @__PURE__ */ new Map();
-  for (const [tag, tagRoutes] of routesByTag) {
-    const refs = /* @__PURE__ */ new Set();
-    for (const route of tagRoutes) {
-      collectRouteRefs(route, refs);
-    }
-    modelsByTag.set(tag, refs);
-  }
-  const modelNameToModel = new Map(models.map((m) => [
-    m.name,
-    m
-  ]));
-  const modelAssignment = /* @__PURE__ */ new Map();
-  for (const model of models) {
-    const tags = [];
-    for (const [tag, refs] of modelsByTag) {
-      if (refs.has(model.name)) {
-        tags.push(tag);
-      }
-    }
-    if (tags.length === 0) {
-      modelAssignment.set(model.name, "shared");
-    } else if (tags.length === 1) {
-      modelAssignment.set(model.name, tags[0]);
-    } else {
-      modelAssignment.set(model.name, "shared");
-    }
-  }
-  for (const model of models) {
-    if (modelAssignment.get(model.name) === "shared") {
-      const refs = /* @__PURE__ */ new Set();
-      collectModelRefs(model, refs);
-      for (const ref of refs) {
-        if (modelNameToModel.has(ref)) {
-          const currentTag = modelAssignment.get(ref);
-          if (currentTag && currentTag !== "shared") {
-            const otherTags = [
-              ...modelsByTag.entries()
-            ].filter(([t, r]) => t !== currentTag && r.has(ref)).map(([t]) => t);
-            if (otherTags.length > 0) {
-              modelAssignment.set(ref, "shared");
-            }
-          }
-        }
-      }
-    }
-  }
-  const result = /* @__PURE__ */ new Map();
-  const allTags = /* @__PURE__ */ new Set([
-    ...routesByTag.keys(),
-    ...new Set(modelAssignment.values())
-  ]);
-  for (const tag of allTags) {
-    const tagModels = models.filter((m) => modelAssignment.get(m.name) === tag);
-    const tagRoutes = routesByTag.get(tag) ?? [];
-    if (tagModels.length === 0 && tagRoutes.length === 0) continue;
-    const filename = sanitizeFilename(tag);
-    result.set(`${filename}.ck`, {
-      kind: "ckRoot",
-      meta: tag !== "shared" ? {
-        area: tag
-      } : {},
-      services: {},
-      models: tagModels,
-      routes: tagRoutes,
-      file: `${filename}.ck`
-    });
-  }
-  return result;
-}
-__name(splitByTag, "splitByTag");
-function mergeIntoSingle(models, routes, filename = "api") {
-  return {
-    kind: "ckRoot",
-    meta: {},
-    services: {},
-    models,
-    routes,
-    file: `${filename}.ck`
-  };
-}
-__name(mergeIntoSingle, "mergeIntoSingle");
-function collectRouteRefs(route, refs) {
-  if (route.params) {
-    collectParamSourceRefs(route.params, refs);
-  }
-  for (const op of route.operations) {
-    if (op.query) collectParamSourceRefs(op.query, refs);
-    if (op.headers) collectParamSourceRefs(op.headers, refs);
-    if (op.request) collectTypeRefs(op.request.bodyType, refs);
-    for (const resp of op.responses) {
-      if (resp.bodyType) collectTypeRefs(resp.bodyType, 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);
-  }
-}
-__name(collectParamSourceRefs, "collectParamSourceRefs");
-function collectTypeRefs(type, refs) {
-  switch (type.kind) {
-    case "ref":
-      refs.add(type.name);
-      break;
-    case "array":
-      collectTypeRefs(type.item, refs);
-      break;
-    case "tuple":
-      for (const item of type.items) collectTypeRefs(item, refs);
-      break;
-    case "record":
-      collectTypeRefs(type.key, refs);
-      collectTypeRefs(type.value, refs);
-      break;
-    case "union":
-    case "intersection":
-      for (const member of type.members) collectTypeRefs(member, refs);
-      break;
-    case "inlineObject":
-      for (const field of type.fields) collectTypeRefs(field.type, refs);
-      break;
-    case "lazy":
-      collectTypeRefs(type.inner, refs);
-      break;
-  }
-}
-__name(collectTypeRefs, "collectTypeRefs");
-function collectModelRefs(model, refs) {
-  if (model.base) refs.add(model.base);
-  if (model.type) collectTypeRefs(model.type, refs);
-  for (const field of model.fields) {
-    collectTypeRefs(field.type, refs);
-  }
-}
-__name(collectModelRefs, "collectModelRefs");
-function sanitizeFilename(tag) {
-  return tag.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "default";
-}
-__name(sanitizeFilename, "sanitizeFilename");
-
-// src/ast-to-ck.ts
-var INDENT = "    ";
-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";
-}
-__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.roles && sec.roles.length > 0) {
-        lines.push(`${INDENT}${INDENT}roles: [${sec.roles.join(", ")}]`);
-      }
-    }
-    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 ? ` # ${model.description}` : "";
-  if (model.type) {
-    parts.push(`contract ${prefix}${model.name}: ${serializeType(model.type)}${comment}`);
-    return parts.join("");
-  }
-  if (model.base) {
-    parts.push(`contract ${prefix}${model.name}: ${model.base} & {${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 ? ` # ${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.join(", ")})`;
-    case "literal":
-      return serializeLiteral(type);
-    case "union":
-      return 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 ? ` # ${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 ? ` # ${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 ? ` # ${op.signatureDescription}` : "";
-    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 ? ` # ${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: {`);
-  lines.push(`${INDENT.repeat(depth + 1)}${request.contentType}: ${serializeType(request.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) {
-    if (resp.bodyType && resp.contentType) {
-      lines.push(`${INDENT.repeat(depth + 1)}${resp.statusCode}: {`);
-      lines.push(`${INDENT.repeat(depth + 2)}${resp.contentType}: ${serializeType(resp.bodyType)}`);
-      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.roles && sec.roles.length > 0) {
-    const rolesComment = ctx.includeComments && sec.rolesDescription ? ` # ${sec.rolesDescription}` : "";
-    lines.push(`${indent}security: {`);
-    lines.push(`${INDENT.repeat(depth + 1)}roles: [${sec.roles.join(", ")}]${rolesComment}`);
-    lines.push(`${indent}}`);
-  } else {
-    lines.push(`${indent}security: {}`);
-  }
-}
-__name(serializeSecurityBlock, "serializeSecurityBlock");
-
-// src/convert.ts
-import { readFileSync } from "fs";
-import { parse as parseYaml } from "yaml";
-
-// src/warnings.ts
-var WarningCollector = class {
-  static {
-    __name(this, "WarningCollector");
-  }
-  warnings = [];
-  onWarning;
-  constructor(onWarning) {
-    this.onWarning = onWarning;
-  }
-  warn(path, message) {
-    this.add({
-      path,
-      message,
-      severity: "warn"
-    });
-  }
-  info(path, message) {
-    this.add({
-      path,
-      message,
-      severity: "info"
-    });
-  }
-  add(warning) {
-    this.warnings.push(warning);
-    this.onWarning?.(warning);
-  }
-};
-
-// src/convert.ts
-async function convertOpenApiToCk(options) {
-  const { split = "by-tag", includeComments = true } = options;
-  const warnings = new WarningCollector(options.onWarning);
-  const rawDoc = await parseInput(options.input);
-  const doc = normalize(rawDoc, warnings);
-  const schemas = sanitizeSchemaNames(doc, warnings);
-  const circularRefs = detectCircularRefs(schemas);
-  const extractedModels = [];
-  const schemaCtx = {
-    circularRefs,
-    warnings,
-    path: "#/components/schemas",
-    includeComments,
-    namedSchemas: schemas,
-    extractedModels,
-    inlineCounter: 0
-  };
-  const models = schemasToModels(schemas, schemaCtx);
-  const { routes, routeTags } = pathsToRoutes(doc, {
-    circularRefs,
-    warnings,
-    includeComments,
-    namedSchemas: schemas,
-    extractedModels,
-    globalSecurity: doc.security
-  });
-  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
-      }));
-    }
-  } else {
-    const root = mergeIntoSingle(models, routes);
-    files.set("api.ck", astToCk(root, {
-      includeComments
-    }));
-  }
-  return {
-    files,
-    warnings: warnings.warnings
-  };
-}
-__name(convertOpenApiToCk, "convertOpenApiToCk");
-async function parseInput(input) {
-  if (typeof input === "object") {
-    return input;
-  }
-  try {
-    const content = readFileSync(input, "utf-8");
-    return parseJsonOrYaml(content);
-  } catch {
-    return parseJsonOrYaml(input);
-  }
-}
-__name(parseInput, "parseInput");
-function parseJsonOrYaml(content) {
-  try {
-    return JSON.parse(content);
-  } catch {
-    return parseYaml(content);
-  }
-}
-__name(parseJsonOrYaml, "parseJsonOrYaml");
-function sanitizeSchemaNames(doc, warnings) {
-  const original = doc.components?.schemas ?? {};
-  const sanitized = {};
-  const nameMap = /* @__PURE__ */ new Map();
-  for (const name of Object.keys(original)) {
-    const clean = sanitizeName(name, warnings);
-    if (sanitized[clean]) {
-      warnings.warn(`#/components/schemas/${name}`, `Name collision after sanitization: "${name}" and another schema both map to "${clean}"`);
-      let i = 2;
-      while (sanitized[`${clean}${i}`]) i++;
-      nameMap.set(name, `${clean}${i}`);
-      sanitized[`${clean}${i}`] = original[name];
-    } else {
-      nameMap.set(name, clean);
-      sanitized[clean] = original[name];
-    }
-  }
-  if (nameMap.size > 0) {
-    updateRefs(doc, nameMap);
-  }
-  return sanitized;
-}
-__name(sanitizeSchemaNames, "sanitizeSchemaNames");
-function updateRefs(obj, nameMap) {
-  if (!obj || typeof obj !== "object") return;
-  if (Array.isArray(obj)) {
-    for (const item of obj) updateRefs(item, nameMap);
-    return;
-  }
-  const record = obj;
-  if (typeof record.$ref === "string") {
-    const match = record.$ref.match(/^#\/components\/schemas\/(.+)$/);
-    if (match?.[1] && nameMap.has(match[1])) {
-      record.$ref = `#/components/schemas/${nameMap.get(match[1])}`;
-    }
-  }
-  for (const value of Object.values(record)) {
-    updateRefs(value, nameMap);
-  }
-}
-__name(updateRefs, "updateRefs");
-
-export {
-  __name,
-  normalize,
-  detectCircularRefs,
-  extractRefName,
-  schemasToModels,
-  schemaToTypeNode,
-  sanitizeName,
-  pathsToRoutes,
-  splitByTag,
-  mergeIntoSingle,
-  astToCk,
-  serializeType,
-  convertOpenApiToCk
-};
-//# sourceMappingURL=chunk-MQTKLXTN.js.map