fhir-openapi-translator 0.1.0

package/dist/chunk-G3DCRADV.js

@@ -0,0 +1,1429 @@
+// src/types.ts
+var FHIR_VERSIONS = ["r4", "r4b", "r5"];
+var FHIR_VERSION_NUMBERS = {
+  r4: "4.0.1",
+  r4b: "4.3.0",
+  r5: "5.0.0"
+};
+
+// src/ig/package.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// src/ig/minimize.ts
+var MAX_ENUM_CODES = 150;
+var FHIR_TYPE_EXTENSION = "http://hl7.org/fhir/StructureDefinition/structuredefinition-fhir-type";
+function fixedValue(el) {
+  for (const key of Object.keys(el)) {
+    if (key.startsWith("fixed") && key.length > 5) return el[key];
+  }
+  return void 0;
+}
+function omittedConstraints(el) {
+  const notes = [];
+  if (el.slicing || el.sliceName) notes.push("slicing");
+  if (Object.keys(el).some((k) => k.startsWith("pattern") && k.length > 7)) {
+    notes.push("pattern");
+  }
+  return notes.length > 0 ? notes : void 0;
+}
+function minimizeElement(el, resolveValueSet) {
+  const out = { path: el.path, min: el.min ?? 0, max: el.max ?? "*" };
+  if (el.short) out.short = el.short;
+  if (el.definition) out.definition = el.definition;
+  if (el.contentReference) out.contentReference = el.contentReference;
+  if (el.type) {
+    out.types = el.type.map((t) => {
+      const type = { code: t.code };
+      if (t.targetProfile) type.targetProfile = t.targetProfile;
+      const fhirType = (t.extension ?? []).find((e) => e.url === FHIR_TYPE_EXTENSION);
+      if (fhirType?.valueUrl) type.fhirType = fhirType.valueUrl;
+      return type;
+    });
+  }
+  if (el.binding?.strength === "required" && el.binding.valueSet) {
+    out.binding = { strength: el.binding.strength, valueSet: el.binding.valueSet };
+    const codes = resolveValueSet?.(el.binding.valueSet);
+    if (codes) out.binding.codes = [...codes].sort();
+  }
+  const fixed = fixedValue(el);
+  if (fixed !== void 0) out.fixed = fixed;
+  if (el.mustSupport) out.mustSupport = true;
+  const omitted = omittedConstraints(el);
+  if (omitted) out.omittedConstraints = omitted;
+  return out;
+}
+function minimizeStructureDefinition(sd, resolveValueSet) {
+  return {
+    name: sd.name,
+    url: sd.url,
+    kind: sd.kind,
+    type: sd.type,
+    abstract: !!sd.abstract,
+    baseDefinition: sd.baseDefinition,
+    elements: (sd.snapshot?.element ?? []).map((el) => minimizeElement(el, resolveValueSet))
+  };
+}
+function buildValueSetResolver(resources, fallback) {
+  const codeSystems = /* @__PURE__ */ new Map();
+  const valueSets = /* @__PURE__ */ new Map();
+  for (const r of resources) {
+    if (r.resourceType === "CodeSystem" && r.url) codeSystems.set(r.url, r);
+    if (r.resourceType === "ValueSet" && r.url) valueSets.set(r.url, r);
+  }
+  function conceptCodes(concepts, out) {
+    for (const c of concepts ?? []) {
+      out.push(c.code);
+      if (c.concept) conceptCodes(c.concept, out);
+    }
+    return out;
+  }
+  function resolveGroup(group) {
+    if (group.filter?.length || group.valueSet?.length) return void 0;
+    if (group.concept?.length) return group.concept.map((c) => c.code);
+    if (!group.system) return void 0;
+    const cs = codeSystems.get(group.system);
+    if (!cs || cs.content === "not-present" || !cs.concept) return void 0;
+    return conceptCodes(cs.concept, []);
+  }
+  return function resolve(valueSetUrl) {
+    const versionless = valueSetUrl.split("|")[0];
+    const vs = valueSets.get(versionless);
+    if (!vs?.compose?.include?.length) return fallback?.(valueSetUrl);
+    const codes = /* @__PURE__ */ new Set();
+    for (const group of vs.compose.include) {
+      const groupCodes = resolveGroup(group);
+      if (!groupCodes) return fallback?.(valueSetUrl);
+      for (const code of groupCodes) codes.add(code);
+    }
+    for (const group of vs.compose.exclude ?? []) {
+      const groupCodes = resolveGroup(group);
+      if (!groupCodes) return fallback?.(valueSetUrl);
+      for (const code of groupCodes) codes.delete(code);
+    }
+    if (codes.size === 0 || codes.size > MAX_ENUM_CODES) return fallback?.(valueSetUrl);
+    return [...codes];
+  };
+}
+
+// src/ig/package.ts
+var FHIR_VERSION_BY_NUMBER = {
+  "4.0.1": "r4",
+  "4.0.0": "r4",
+  "4.3.0": "r4b",
+  "5.0.0": "r5"
+};
+var REGISTRY_BASE = "https://packages.fhir.org";
+async function loadIg(input, options = {}) {
+  if (isRegistryCoordinate(input)) {
+    const tarball = await fetchFromRegistry(input, options);
+    return buildContext(readFromTarball(tarball), options.coreValueSetFallback);
+  }
+  return loadIgSync(input, options);
+}
+function loadIgSync(input, options = {}) {
+  if (isRegistryCoordinate(input)) {
+    throw new Error(
+      `"${input}" looks like a registry package coordinate, which requires a network fetch. Use loadIg() (async) or the CLI, or download the package and pass a local path.`
+    );
+  }
+  const stat = fs.existsSync(input) ? fs.statSync(input) : void 0;
+  if (!stat) {
+    throw new Error(
+      `--ig "${input}" is not a file or directory. Pass a package .tgz, an unpacked package directory, or a registry coordinate like hl7.fhir.us.core@5.0.1.`
+    );
+  }
+  const files = stat.isDirectory() ? readFromDirectory(input) : readFromTarball(input);
+  return buildContext(files, options.coreValueSetFallback);
+}
+function isRegistryCoordinate(input) {
+  if (fs.existsSync(input)) return false;
+  if (input.includes("/") || input.includes("\\") || input.endsWith(".tgz")) return false;
+  return /^[a-z0-9][a-z0-9.\-]*(@[\w.\-]+)?$/i.test(input);
+}
+function packageDir(root) {
+  const nested = path.join(root, "package");
+  if (fs.existsSync(path.join(nested, "package.json"))) return nested;
+  if (fs.existsSync(path.join(root, "package.json"))) return root;
+  throw new Error(`No package.json found under "${root}" (looked in ./ and ./package)`);
+}
+function readFromDirectory(dir) {
+  const base = packageDir(dir);
+  const packageJson = JSON.parse(fs.readFileSync(path.join(base, "package.json"), "utf8"));
+  const resources = [];
+  for (const file of fs.readdirSync(base).sort()) {
+    if (!file.endsWith(".json") || file === "package.json" || file === ".index.json") continue;
+    try {
+      resources.push(JSON.parse(fs.readFileSync(path.join(base, file), "utf8")));
+    } catch {
+    }
+  }
+  return { packageJson, resources };
+}
+function readFromTarball(tarballPath) {
+  if (!fs.existsSync(tarballPath)) {
+    throw new Error(`Package tarball not found: ${tarballPath}`);
+  }
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "fhir-oas-ig-"));
+  try {
+    execFileSync("tar", ["-xzf", tarballPath, "-C", tmp], { stdio: "pipe" });
+    return readFromDirectory(tmp);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+async function fetchFromRegistry(coordinate, options) {
+  const [name, version] = coordinate.split("@");
+  const cacheDir = path.join(options.cacheDir ?? path.join(os.homedir(), ".fhir-oas"), "packages");
+  const resolvedVersion = version ?? "latest";
+  const cachePath = path.join(cacheDir, `${name}#${resolvedVersion}.tgz`);
+  if (fs.existsSync(cachePath)) return cachePath;
+  const url = `${REGISTRY_BASE}/${name}/${resolvedVersion}`;
+  const doFetch = options.fetchImpl ?? fetch;
+  let response;
+  try {
+    response = await doFetch(url);
+  } catch (cause) {
+    throw new Error(
+      `Failed to reach the FHIR package registry at ${url}: ${cause.message}. If you are offline or behind a restrictive proxy, download the package and pass --ig ./${name}.tgz instead.`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `FHIR package registry returned ${response.status} for ${url}. Check the package name and version, or download it and pass --ig ./${name}.tgz.`
+    );
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  fs.mkdirSync(cacheDir, { recursive: true });
+  fs.writeFileSync(cachePath, buffer);
+  return cachePath;
+}
+function detectFhirVersion(packageJson) {
+  const versions = packageJson["fhir-version-list"] ?? packageJson.fhirVersions ?? [];
+  for (const v of versions) {
+    const mapped = FHIR_VERSION_BY_NUMBER[v];
+    if (mapped) return mapped;
+  }
+  throw new Error(
+    `Could not determine a supported FHIR version for IG package "${packageJson.name}" (found: ${versions.join(", ") || "none"}). Supported: ${FHIR_VERSIONS.join(", ")}.`
+  );
+}
+function buildContext(files, coreFallback) {
+  const fhirVersion = detectFhirVersion(files.packageJson);
+  const terminology = files.resources.filter(
+    (r) => r.resourceType === "ValueSet" || r.resourceType === "CodeSystem"
+  );
+  const resolveValueSet = buildValueSetResolver(terminology, coreFallback);
+  const profiles = [];
+  const profilesMissingSnapshot = [];
+  for (const r of files.resources) {
+    if (r.resourceType === "StructureDefinition" && r.derivation === "constraint" && r.kind === "resource") {
+      if (!r.snapshot) {
+        profilesMissingSnapshot.push(r.name ?? r.url ?? "unknown");
+        continue;
+      }
+      const sd = r;
+      profiles.push({
+        url: sd.url.split("|")[0],
+        id: sd.id,
+        name: sd.name,
+        type: sd.type,
+        definition: minimizeStructureDefinition(sd, resolveValueSet)
+      });
+    }
+  }
+  profiles.sort((a, b) => a.url.localeCompare(b.url));
+  return {
+    name: files.packageJson.name ?? "unknown",
+    version: files.packageJson.version ?? "unknown",
+    fhirVersion,
+    profiles,
+    profilesMissingSnapshot,
+    resolveValueSet
+  };
+}
+
+// src/definitions.ts
+import { gunzipSync } from "zlib";
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function definitionsRoot() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = path2.join(dir, "definitions");
+    if (fs2.existsSync(candidate)) return candidate;
+    dir = path2.dirname(dir);
+  }
+  throw new Error("Could not locate the vendored FHIR definitions directory");
+}
+var cache = /* @__PURE__ */ new Map();
+function loadGzJson(fhirVersion, file) {
+  const key = `${fhirVersion}/${file}`;
+  let value = cache.get(key);
+  if (value === void 0) {
+    const fullPath = path2.join(definitionsRoot(), fhirVersion, `${file}.gz`);
+    value = JSON.parse(gunzipSync(fs2.readFileSync(fullPath)).toString("utf8"));
+    cache.set(key, value);
+  }
+  return value;
+}
+function loadFhirSchema(fhirVersion) {
+  return loadGzJson(fhirVersion, "fhir.schema.json");
+}
+function loadSearchParameters(fhirVersion) {
+  const bundle = loadGzJson(fhirVersion, "search-parameters.json");
+  return (bundle.entry ?? []).map((e) => e.resource).filter(
+    // R4B ships a few draft codesystem-extensions-* SearchParameters with no
+    // `base`; they can't be attached to any resource, so drop them here.
+    (r) => r?.resourceType === "SearchParameter" && Array.isArray(r.base)
+  );
+}
+function loadOperationDefinitions(fhirVersion) {
+  return loadGzJson(fhirVersion, "operation-definitions.json");
+}
+function loadStructureDefinitions(fhirVersion) {
+  return loadGzJson(fhirVersion, "structure-definitions.json");
+}
+
+// src/ir/structureWalker.ts
+function segmentToPascal(segment) {
+  return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+function isBackbone(el) {
+  return (el.types ?? []).some((t) => t.code === "BackboneElement" || t.code === "Element");
+}
+function systemTypeSchema(code) {
+  if (!code.startsWith("http://hl7.org/fhirpath/System.")) return void 0;
+  const kind = code.slice("http://hl7.org/fhirpath/System.".length);
+  switch (kind) {
+    case "Boolean":
+      return { type: "boolean" };
+    case "Integer":
+    case "Decimal":
+      return { type: "number" };
+    default:
+      return { type: "string" };
+  }
+}
+function buildElementTree(sd) {
+  const rootPath = sd.type ?? sd.name;
+  let root;
+  const nodes = /* @__PURE__ */ new Map();
+  for (const el of sd.elements) {
+    const node = { element: el, children: /* @__PURE__ */ new Map() };
+    nodes.set(el.path, node);
+    if (el.path === rootPath) {
+      root = node;
+      continue;
+    }
+    const parentPath = el.path.slice(0, el.path.lastIndexOf("."));
+    const segment = el.path.slice(el.path.lastIndexOf(".") + 1);
+    nodes.get(parentPath)?.children.set(segment, node);
+  }
+  return root;
+}
+function contentReferenceName(reference, sd, rootName) {
+  const path3 = reference.replace(/^#/, "");
+  const [root, ...rest] = path3.split(".");
+  if (rest.length === 0) return root ?? path3;
+  const prefix = root === (sd.type ?? sd.name) ? rootName : root ?? "";
+  return [prefix, ...rest.map(segmentToPascal)].join("_");
+}
+function emitStructureDefinitionSchemas(sd, definitions, opts) {
+  const root = buildElementTree(sd);
+  if (!root) return;
+  emitObjectDefinition(sd, opts.rootName, root, definitions, opts.isResourceRoot, opts);
+}
+function emitObjectDefinition(sd, name, node, definitions, isResourceRoot, opts) {
+  if (definitions.has(name)) return;
+  const properties = {};
+  const required = [];
+  const displayName = opts.resourceDisplayName ?? sd.type ?? sd.name;
+  if (isResourceRoot) {
+    properties.resourceType = {
+      description: `This is a ${displayName} resource`,
+      const: displayName
+    };
+    required.push("resourceType");
+  }
+  const definition = {
+    ...node.element.definition ? { description: node.element.definition } : {},
+    properties,
+    additionalProperties: false
+  };
+  definitions.set(name, definition);
+  for (const [segment, child] of node.children) {
+    emitProperty(sd, name, segment, child, properties, required, definitions, opts);
+  }
+  if (required.length > 0) definition.required = required.sort();
+}
+function emitProperty(sd, parentName, segment, node, properties, required, definitions, opts) {
+  const el = node.element;
+  if (opts.profile && el.max === "0") return;
+  const isArray = el.max === "*" || Number(el.max) > 1;
+  const isChoice = segment.endsWith("[x]");
+  let description = el.definition ?? el.short;
+  const omitted = [];
+  if (opts.profile) {
+    if (el.mustSupport) omitted.push("must-support");
+    if (el.omittedConstraints) omitted.push(...el.omittedConstraints);
+    if (omitted.length > 0) {
+      const note = `Profile constraints not enforced here: ${omitted.join(", ")}.`;
+      description = description ? `${description} ${note}` : note;
+    }
+  }
+  const addProperty = (fieldName, schema, primitive) => {
+    const annotated = omitted.length > 0 && !("$ref" in schema) ? { ...schema, "x-fhir-constraints-omitted": omitted } : schema;
+    properties[fieldName] = wrapCardinality(annotated, isArray, description);
+    if (primitive) {
+      properties[`_${fieldName}`] = wrapCardinality(
+        { $ref: "#/definitions/Element" },
+        isArray,
+        `Extensions for ${fieldName}`
+      );
+    }
+  };
+  if (isChoice) {
+    const base = segment.slice(0, -3);
+    for (const type of el.types ?? []) {
+      const fieldName = base + segmentToPascal(type.code);
+      const { schema, primitive } = schemaForTypeCode(type.code, el, opts);
+      addProperty(fieldName, schema, primitive);
+    }
+    return;
+  }
+  if (el.contentReference) {
+    const target = contentReferenceName(el.contentReference, sd, opts.rootName);
+    addProperty(segment, { $ref: `#/definitions/${target}` }, false);
+  } else if (isBackbone(el) && node.children.size > 0) {
+    const childName = `${parentName}_${segmentToPascal(segment)}`;
+    emitObjectDefinition(sd, childName, node, definitions, false, opts);
+    addProperty(segment, { $ref: `#/definitions/${childName}` }, false);
+  } else {
+    const type = (el.types ?? [])[0];
+    if (!type) return;
+    const { schema, primitive } = schemaForTypeCode(type.code, el, opts);
+    addProperty(segment, schema, primitive);
+  }
+  if (el.min >= 1) required.push(segment);
+}
+function schemaForTypeCode(code, el, opts) {
+  const primitive = code.charAt(0) === code.charAt(0).toLowerCase();
+  const system = systemTypeSchema(code);
+  if (system) return { schema: system, primitive: false };
+  if (code === "Resource" || code === "DomainResource") {
+    return { schema: { $ref: "#/definitions/ResourceList" }, primitive: false };
+  }
+  if (opts.profile && el.fixed !== void 0) {
+    return { schema: { const: el.fixed }, primitive };
+  }
+  if (code === "code" && el.binding?.codes?.length) {
+    return { schema: { enum: el.binding.codes }, primitive: true };
+  }
+  return { schema: { $ref: `#/definitions/${code}` }, primitive };
+}
+function wrapCardinality(schema, isArray, description) {
+  const withDescription = (s) => description && !("$ref" in s) ? { description, ...s } : s;
+  if (isArray) {
+    return {
+      ...description ? { description } : {},
+      type: "array",
+      items: schema
+    };
+  }
+  if ("$ref" in schema && description) {
+    return schema;
+  }
+  return withDescription(schema);
+}
+
+// src/ig/profile.ts
+function buildCoreValueSetFallback(fhirVersion) {
+  const map = /* @__PURE__ */ new Map();
+  for (const sd of loadStructureDefinitions(fhirVersion)) {
+    for (const el of sd.elements) {
+      if (el.binding?.codes?.length && el.binding.valueSet) {
+        const key = el.binding.valueSet.split("|")[0];
+        if (!map.has(key)) map.set(key, el.binding.codes);
+      }
+    }
+  }
+  return (valueSetUrl) => map.get(valueSetUrl.split("|")[0]);
+}
+function sanitizeSchemaName(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_]/g, "");
+  return /^[A-Za-z]/.test(cleaned) ? cleaned : `Profile${cleaned}`;
+}
+function findProfile(context, requested) {
+  const needle = requested.toLowerCase();
+  const matches = context.profiles.filter(
+    (p) => p.url.toLowerCase() === needle || p.id?.toLowerCase() === needle || p.name.toLowerCase() === needle
+  );
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    throw new Error(
+      `Profile "${requested}" is ambiguous in ${context.name}; match by canonical URL. Candidates: ${matches.map((p) => p.url).join(", ")}`
+    );
+  }
+  if (context.profilesMissingSnapshot.some((p) => p.toLowerCase() === needle)) {
+    throw new Error(
+      `Profile "${requested}" in ${context.name} has no snapshot. Snapshot generation is out of scope; use a snapshot-bearing release of the IG.`
+    );
+  }
+  const available = context.profiles.map((p) => p.id ?? p.name).sort();
+  throw new Error(
+    `Profile "${requested}" not found in ${context.name}@${context.version}. Available profiles: ${available.join(", ") || "none"}`
+  );
+}
+function applyProfile(context, requested, registry) {
+  const profile = findProfile(context, requested);
+  let schemaName = sanitizeSchemaName(profile.name);
+  if (registry.definitions.has(schemaName) && schemaName !== profile.type) {
+    schemaName = `${schemaName}Profile`;
+  }
+  emitStructureDefinitionSchemas(profile.definition, registry.definitions, {
+    rootName: schemaName,
+    isResourceRoot: true,
+    resourceDisplayName: profile.type,
+    profile: true
+  });
+  const schema = registry.definitions.get(schemaName);
+  if (schema) schema["x-fhir-profile"] = profile.url;
+  return { schemaName, resourceType: profile.type, url: profile.url };
+}
+
+// src/backends/schemaJson.ts
+function buildRegistryFromSchemaJson(fhirVersion) {
+  const schema = loadFhirSchema(fhirVersion);
+  const definitions = new Map(Object.entries(schema.definitions));
+  let resourceNames;
+  if (schema.discriminator?.mapping) {
+    resourceNames = Object.keys(schema.discriminator.mapping);
+  } else {
+    resourceNames = [...definitions.entries()].filter(([, def]) => {
+      const props = def.properties;
+      return props?.resourceType !== void 0 && "const" in (props.resourceType ?? {});
+    }).map(([name]) => name);
+  }
+  return { fhirVersion, definitions, resourceNames };
+}
+
+// src/backends/structureDefinition.ts
+function buildRegistryFromStructureDefinitions(fhirVersion) {
+  const sds = loadStructureDefinitions(fhirVersion);
+  const definitions = /* @__PURE__ */ new Map();
+  const resourceNames = [];
+  const byName = new Map(sds.map((sd) => [sd.name, sd]));
+  for (const sd of sds) {
+    if (sd.kind === "primitive-type") {
+      definitions.set(sd.name, primitiveSchema(sd));
+    }
+  }
+  if (!definitions.has("xhtml")) {
+    definitions.set("xhtml", {
+      type: "string",
+      description: "XHTML narrative content"
+    });
+  }
+  for (const sd of sds) {
+    if (sd.kind === "primitive-type" || sd.abstract) continue;
+    emitStructureDefinitionSchemas(sd, definitions, {
+      rootName: sd.name,
+      isResourceRoot: sd.kind === "resource"
+    });
+    if (sd.kind === "resource") resourceNames.push(sd.name);
+  }
+  for (const abstractName of ["Element", "BackboneElement"]) {
+    const sd = byName.get(abstractName);
+    if (sd && !definitions.has(abstractName)) {
+      emitStructureDefinitionSchemas(sd, definitions, {
+        rootName: sd.name,
+        isResourceRoot: false
+      });
+    }
+  }
+  resourceNames.sort();
+  definitions.set("ResourceList", {
+    oneOf: resourceNames.map((name) => ({ $ref: `#/definitions/${name}` }))
+  });
+  return { fhirVersion, definitions, resourceNames };
+}
+function primitiveJsonType(name) {
+  switch (name) {
+    case "boolean":
+      return { type: "boolean" };
+    case "decimal":
+      return { type: "number" };
+    case "integer":
+    case "positiveInt":
+    case "unsignedInt":
+      return { type: "number" };
+    // integer64 (R5) is represented as a JSON string per the spec.
+    default:
+      return { type: "string" };
+  }
+}
+function primitiveSchema(sd) {
+  const root = sd.elements[0];
+  return {
+    ...primitiveJsonType(sd.name),
+    ...root?.definition ? { description: root.definition } : {}
+  };
+}
+
+// src/emit/schema.ts
+var DEFINITIONS_REF = "#/definitions/";
+var COMPONENTS_REF = "#/components/schemas/";
+var NO_ENUMS_NOTE_MAX_CODES = 25;
+function convertSchema(node, target, options = {}) {
+  return convertNode(node, target, options);
+}
+function convertNode(node, target, options) {
+  if (Array.isArray(node)) {
+    return node.map((item) => convertNode(item, target, options));
+  }
+  if (!node || typeof node !== "object") return node;
+  const out = {};
+  const source = node;
+  let strippedEnum;
+  for (const [key, value] of Object.entries(source)) {
+    switch (key) {
+      case "$schema":
+      case "$comment":
+      case "id":
+      case "$id":
+        break;
+      case "$ref":
+        out.$ref = typeof value === "string" && value.startsWith(DEFINITIONS_REF) ? COMPONENTS_REF + value.slice(DEFINITIONS_REF.length) : value;
+        break;
+      case "const":
+        if (target === "3.1.0") out.const = value;
+        else out.enum = [value];
+        break;
+      case "enum":
+        if (options.noEnums && Array.isArray(value)) strippedEnum = value;
+        else out.enum = value;
+        break;
+      case "pattern":
+        if (source.type === void 0 || source.type === "string") out.pattern = value;
+        break;
+      default:
+        out[key] = convertNode(value, target, options);
+    }
+  }
+  if (strippedEnum) {
+    if (out.type === void 0 && out.$ref === void 0) out.type = "string";
+    const listed = strippedEnum.slice(0, NO_ENUMS_NOTE_MAX_CODES).join(" | ");
+    const ellipsis = strippedEnum.length > NO_ENUMS_NOTE_MAX_CODES ? " | ..." : "";
+    const note = `Codes (FHIR required binding, not enforced here): ${listed}${ellipsis}`;
+    out.description = out.description ? `${out.description} ${note}` : note;
+  }
+  return out;
+}
+
+// src/ir/registry.ts
+var REF_PREFIX = "#/definitions/";
+function refName(ref3) {
+  return ref3.startsWith(REF_PREFIX) ? ref3.slice(REF_PREFIX.length) : void 0;
+}
+function collectRefs(node, out = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    for (const item of node) collectRefs(item, out);
+  } else if (node && typeof node === "object") {
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "$ref" && typeof value === "string") {
+        const name = refName(value);
+        if (name) out.add(name);
+      } else {
+        collectRefs(value, out);
+      }
+    }
+  }
+  return out;
+}
+function stubSchema(reason) {
+  return {
+    type: "object",
+    additionalProperties: true,
+    description: reason
+  };
+}
+function narrowedResourceList(included) {
+  return {
+    oneOf: included.map((name) => ({ $ref: `${REF_PREFIX}${name}` })),
+    description: "A contained/bundled FHIR resource. Narrowed by fhir-openapi-translator to the resource types requested at generation time; servers may return other types."
+  };
+}
+function extractClosure(registry, roots, trim = {}, resourceListNarrowing = roots) {
+  const schemas = /* @__PURE__ */ new Map();
+  const stubbed = /* @__PURE__ */ new Set();
+  const maxDepth = trim.maxDepth;
+  let frontier = [...new Set(roots)];
+  let depth = 0;
+  while (frontier.length > 0) {
+    const next = [];
+    for (const name of frontier) {
+      if (schemas.has(name)) continue;
+      const original = registry.definitions.get(name);
+      if (!original) {
+        throw new Error(`Unknown FHIR definition: ${name}`);
+      }
+      let schema = original;
+      let followDeps = true;
+      if (trim.excludeNarrative && name === "Narrative") {
+        schema = stubSchema(
+          "Human-readable narrative. Excluded from this specification (--exclude-narrative)."
+        );
+        followDeps = false;
+        stubbed.add(name);
+      } else if (maxDepth !== void 0 && depth > maxDepth) {
+        schema = stubSchema(
+          `FHIR ${name}. Pruned from this specification by --max-depth ${maxDepth}.`
+        );
+        followDeps = false;
+        stubbed.add(name);
+      } else if (name === "ResourceList") {
+        schema = narrowedResourceList(
+          [...new Set(resourceListNarrowing)].filter((n) => registry.definitions.has(n))
+        );
+      }
+      schemas.set(name, schema);
+      if (followDeps) {
+        for (const dep of collectRefs(schema)) {
+          if (!schemas.has(dep)) next.push(dep);
+        }
+      }
+    }
+    frontier = next;
+    depth++;
+  }
+  return { schemas, stubbed };
+}
+
+// src/operations.ts
+var FHIR_JSON = "application/fhir+json";
+var SCHEMAS = "#/components/schemas/";
+function isPrimitive(type) {
+  return !!type && type.charAt(0) === type.charAt(0).toLowerCase();
+}
+function camelCode(code) {
+  return code.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function ref(schema) {
+  return { $ref: `${SCHEMAS}${schema}` };
+}
+function fhirContent(schema) {
+  return { [FHIR_JSON]: { schema: ref(schema) } };
+}
+function errorResponses() {
+  return {
+    default: {
+      description: "Error, with an OperationOutcome describing the problem",
+      content: fhirContent("OperationOutcome")
+    }
+  };
+}
+function buildOperationPaths(fhirVersion, resource, knownResources, options = {}) {
+  const schemaFor = options.schemaFor ?? ((r) => r);
+  const paths = {};
+  const extraSchemaRoots = /* @__PURE__ */ new Set();
+  const applicable = loadOperationDefinitions(fhirVersion).filter(
+    (op) => (op.type || op.instance) && (op.resource.includes(resource) || op.resource.includes("Resource")) && (!options.only || options.only.has(op.code) || options.only.has(op.url))
+  );
+  for (const op of applicable) {
+    const inParams = op.parameters.filter((p) => p.use === "in");
+    const useGet = inParams.every((p) => isPrimitive(p.type));
+    const responseSchema = schemaFor(responseSchemaName(op, knownResources));
+    extraSchemaRoots.add(responseSchema);
+    if (!useGet) extraSchemaRoots.add("Parameters");
+    const buildOperation = (level) => {
+      const operation = {
+        tags: [resource],
+        summary: `$${op.code} (${level.toLowerCase()} level)`,
+        ...op.description ? { description: op.description } : {},
+        operationId: `${camelCode(op.code)}${resource}${level}`,
+        externalDocs: { url: op.url },
+        responses: {
+          "200": {
+            description: `Result of the $${op.code} operation`,
+            content: fhirContent(responseSchema)
+          },
+          ...errorResponses()
+        }
+      };
+      if (useGet) {
+        if (inParams.length > 0) operation.parameters = inParams.map(queryParameter);
+      } else {
+        operation.requestBody = {
+          required: inParams.some((p) => p.min >= 1),
+          content: fhirContent("Parameters")
+        };
+      }
+      return operation;
+    };
+    const method = useGet ? "get" : "post";
+    if (op.type) {
+      paths[`/${resource}/$${op.code}`] = { [method]: buildOperation("Type") };
+    }
+    if (op.instance) {
+      paths[`/${resource}/{id}/$${op.code}`] = {
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            description: `Logical id of the ${resource}`,
+            schema: { type: "string", pattern: "^[A-Za-z0-9\\-\\.]{1,64}$" }
+          }
+        ],
+        [method]: buildOperation("Instance")
+      };
+    }
+  }
+  return { paths, extraSchemaRoots: [...extraSchemaRoots].sort() };
+}
+function responseSchemaName(op, knownResources) {
+  const outParams = op.parameters.filter((p) => p.use === "out");
+  if (outParams.length === 1) {
+    const only = outParams[0];
+    if (only.name === "return" && only.type && knownResources.has(only.type)) {
+      return only.type;
+    }
+  }
+  return "Parameters";
+}
+function queryParameter(param) {
+  const isArray = param.max === "*" || Number(param.max) > 1;
+  const base = { type: "string" };
+  return {
+    name: param.name,
+    in: "query",
+    required: param.min >= 1,
+    ...param.documentation ? { description: param.documentation } : {},
+    // FHIR primitives serialize as strings in URLs; the FHIR type is kept
+    // as an extension, consistent with search parameters.
+    schema: isArray ? { type: "array", items: base } : base,
+    ...isArray ? { explode: true } : {},
+    "x-fhir-type": param.type
+  };
+}
+
+// src/paths.ts
+var FHIR_JSON2 = "application/fhir+json";
+var SCHEMAS2 = "#/components/schemas/";
+var PARAMETERS = "#/components/parameters/";
+function ref2(schema) {
+  return { $ref: `${SCHEMAS2}${schema}` };
+}
+function fhirContent2(schema) {
+  return { [FHIR_JSON2]: { schema: ref2(schema) } };
+}
+function errorResponses2() {
+  return {
+    default: {
+      description: "Error, with an OperationOutcome describing the problem",
+      content: fhirContent2("OperationOutcome")
+    }
+  };
+}
+function idParameter(name, description) {
+  return {
+    name,
+    in: "path",
+    required: true,
+    description,
+    schema: { type: "string", pattern: "^[A-Za-z0-9\\-\\.]{1,64}$" }
+  };
+}
+var COMMON_SEARCH_PARAMETERS = {
+  _id: { description: "Logical id of this artifact", schema: { type: "string" } },
+  _lastUpdated: {
+    description: "When the resource version last changed (supports date prefixes, e.g. ge2021-01-01)",
+    schema: { type: "string" }
+  },
+  _tag: { description: "Tags applied to this resource", schema: { type: "string" } },
+  _profile: { description: "Profiles this resource claims to conform to", schema: { type: "string" } },
+  _security: { description: "Security labels applied to this resource", schema: { type: "string" } },
+  _text: { description: "Search on the narrative of the resource", schema: { type: "string" } },
+  _content: { description: "Search on the entire content of the resource", schema: { type: "string" } },
+  _sort: { description: "Sort order of the results (comma-separated parameter names, '-' prefix for descending)", schema: { type: "string" } },
+  _count: { description: "Maximum number of results per page", schema: { type: "integer", minimum: 0 } },
+  _include: { description: "Include referenced resources in the results", schema: { type: "string" } },
+  _revinclude: { description: "Include resources that reference the matches in the results", schema: { type: "string" } },
+  _summary: {
+    description: "Return only a portion of each resource",
+    schema: { type: "string", enum: ["true", "text", "data", "count", "false"] }
+  },
+  _total: {
+    description: "Requested precision of the Bundle.total",
+    schema: { type: "string", enum: ["none", "estimate", "accurate"] }
+  },
+  _elements: { description: "Restrict returned elements (comma-separated element names)", schema: { type: "string" } }
+};
+function commonSearchParameterComponents() {
+  const out = {};
+  for (const [name, { description, schema }] of Object.entries(COMMON_SEARCH_PARAMETERS)) {
+    out[name] = { name, in: "query", required: false, description, schema };
+  }
+  return out;
+}
+function resourceSearchParameters(fhirVersion, resource, only) {
+  return loadSearchParameters(fhirVersion).filter((sp) => sp.base.includes(resource) && (!only || only.has(sp.code))).sort((a, b) => a.code.localeCompare(b.code)).map((sp) => ({
+    name: sp.code,
+    in: "query",
+    required: false,
+    description: sp.description,
+    // FHIR search values carry prefixes and modifiers, so all are strings.
+    schema: { type: "string" },
+    "x-fhir-search-type": sp.type
+  }));
+}
+var historyParameters = () => [
+  { $ref: `${PARAMETERS}_count` },
+  {
+    name: "_since",
+    in: "query",
+    required: false,
+    description: "Only include versions created at or after this instant",
+    schema: { type: "string", format: "date-time" }
+  }
+];
+function buildResourcePaths(fhirVersion, resource, schemaName = resource, options = {}) {
+  const want = (interaction) => !options.interactions || options.interactions.has(interaction);
+  const body = () => fhirContent2(schemaName);
+  const idParam = () => idParameter("id", `Logical id of the ${resource}`);
+  const paths = {};
+  const typeItem = {};
+  if (want("search-type")) {
+    typeItem.get = {
+      tags: [resource],
+      summary: `Search for ${resource} resources`,
+      operationId: `search${resource}`,
+      parameters: [
+        ...Object.keys(COMMON_SEARCH_PARAMETERS).map((name) => ({ $ref: `${PARAMETERS}${name}` })),
+        ...resourceSearchParameters(fhirVersion, resource, options.searchParamCodes)
+      ],
+      responses: {
+        "200": {
+          description: `Bundle of matching ${resource} resources`,
+          content: fhirContent2("Bundle")
+        },
+        ...errorResponses2()
+      }
+    };
+  }
+  if (want("create")) {
+    typeItem.post = {
+      tags: [resource],
+      summary: `Create a ${resource} resource`,
+      operationId: `create${resource}`,
+      requestBody: { required: true, content: body() },
+      responses: {
+        "201": { description: `${resource} created`, content: body() },
+        ...errorResponses2()
+      }
+    };
+  }
+  if (Object.keys(typeItem).length > 0) paths[`/${resource}`] = typeItem;
+  const instanceItem = {};
+  if (want("read")) {
+    instanceItem.get = {
+      tags: [resource],
+      summary: `Read a ${resource} resource by id`,
+      operationId: `read${resource}`,
+      responses: {
+        "200": { description: `The ${resource} resource`, content: body() },
+        ...errorResponses2()
+      }
+    };
+  }
+  if (want("update")) {
+    instanceItem.put = {
+      tags: [resource],
+      summary: `Update (or create) a ${resource} resource by id`,
+      operationId: `update${resource}`,
+      parameters: [
+        {
+          name: "If-Match",
+          in: "header",
+          required: false,
+          description: "Version-aware update: weak ETag of the version being updated",
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: { required: true, content: body() },
+      responses: {
+        "200": { description: `${resource} updated`, content: body() },
+        "201": { description: `${resource} created`, content: body() },
+        ...errorResponses2()
+      }
+    };
+  }
+  if (want("patch")) {
+    instanceItem.patch = {
+      tags: [resource],
+      summary: `Patch a ${resource} resource by id`,
+      operationId: `patch${resource}`,
+      requestBody: {
+        required: true,
+        content: {
+          "application/json-patch+json": {
+            schema: {
+              type: "array",
+              items: { type: "object", additionalProperties: true },
+              description: "JSON Patch operations (RFC 6902)"
+            }
+          }
+        }
+      },
+      responses: {
+        "200": { description: `${resource} patched`, content: body() },
+        ...errorResponses2()
+      }
+    };
+  }
+  if (want("delete")) {
+    instanceItem.delete = {
+      tags: [resource],
+      summary: `Delete a ${resource} resource by id`,
+      operationId: `delete${resource}`,
+      responses: { "204": { description: `${resource} deleted` }, ...errorResponses2() }
+    };
+  }
+  if (Object.keys(instanceItem).length > 0) {
+    paths[`/${resource}/{id}`] = { parameters: [idParam()], ...instanceItem };
+  }
+  if (want("history-instance")) {
+    paths[`/${resource}/{id}/_history`] = {
+      parameters: [idParam()],
+      get: {
+        tags: [resource],
+        summary: `History of a ${resource} instance`,
+        operationId: `history${resource}Instance`,
+        parameters: historyParameters(),
+        responses: {
+          "200": { description: "History bundle", content: fhirContent2("Bundle") },
+          ...errorResponses2()
+        }
+      }
+    };
+  }
+  if (want("vread")) {
+    paths[`/${resource}/{id}/_history/{vid}`] = {
+      parameters: [idParam(), idParameter("vid", "Version id of the resource")],
+      get: {
+        tags: [resource],
+        summary: `Read a specific version of a ${resource} resource`,
+        operationId: `vread${resource}`,
+        responses: {
+          "200": { description: `The ${resource} resource version`, content: body() },
+          ...errorResponses2()
+        }
+      }
+    };
+  }
+  if (want("history-type")) {
+    paths[`/${resource}/_history`] = {
+      get: {
+        tags: [resource],
+        summary: `History across all ${resource} resources`,
+        operationId: `history${resource}Type`,
+        parameters: historyParameters(),
+        responses: {
+          "200": { description: "History bundle", content: fhirContent2("Bundle") },
+          ...errorResponses2()
+        }
+      }
+    };
+  }
+  return paths;
+}
+
+// src/generate.ts
+function buildRegistry(fhirVersion, source) {
+  return source === "structure-def" ? buildRegistryFromStructureDefinitions(fhirVersion) : buildRegistryFromSchemaJson(fhirVersion);
+}
+function resolveResourceName(registry, requested) {
+  const match = registry.resourceNames.find(
+    (name) => name.toLowerCase() === requested.toLowerCase()
+  );
+  if (!match) {
+    throw new Error(
+      `Unknown FHIR ${registry.fhirVersion.toUpperCase()} resource: "${requested}". Run "fhir-oas list --fhir-version ${registry.fhirVersion}" to see available resources.`
+    );
+  }
+  return match;
+}
+function listResources(fhirVersion, source = "schema-json") {
+  assertFhirVersion(fhirVersion);
+  return [...buildRegistry(fhirVersion, source).resourceNames].sort();
+}
+function assertFhirVersion(fhirVersion) {
+  if (!FHIR_VERSIONS.includes(fhirVersion)) {
+    throw new Error(
+      `Unsupported FHIR version "${fhirVersion}". Supported: ${FHIR_VERSIONS.join(", ")}`
+    );
+  }
+}
+function assertCapabilityFhirVersion(capability, fhirVersion) {
+  const declared = capability.fhirVersion;
+  if (!declared) return;
+  const expectedMajor = FHIR_VERSION_NUMBERS[fhirVersion].split(".").slice(0, 2).join(".");
+  const declaredPrefix = declared.split(".").slice(0, 2).join(".");
+  if (declaredPrefix && expectedMajor && declaredPrefix !== expectedMajor) {
+    throw new Error(
+      `CapabilityStatement targets FHIR ${declared}, but generation is for ${fhirVersion.toUpperCase()} (${FHIR_VERSION_NUMBERS[fhirVersion]}). Set --fhir-version to match the server.`
+    );
+  }
+}
+function resolveIg(options) {
+  const ig = options.ig;
+  if (!ig) throw new Error("--profile requires --ig: point at the IG package.");
+  if (typeof ig === "string") {
+    return loadIgSync(ig, { coreValueSetFallback: buildCoreValueSetFallback(options.fhirVersion) });
+  }
+  return ig;
+}
+function generateOpenApi(options) {
+  assertFhirVersion(options.fhirVersion);
+  const openApiVersion = options.openApiVersion ?? "3.0.3";
+  if (openApiVersion !== "3.0.3" && openApiVersion !== "3.1.0") {
+    throw new Error(`Unsupported OpenAPI version "${openApiVersion}". Supported: 3.0.3, 3.1.0`);
+  }
+  const registry = buildRegistry(options.fhirVersion, options.source ?? "schema-json");
+  const capability = options.capability;
+  const capabilityByResource = /* @__PURE__ */ new Map();
+  if (capability) {
+    assertCapabilityFhirVersion(capability, options.fhirVersion);
+    for (const cap of capability.resources) {
+      const match = registry.resourceNames.find(
+        (name) => name.toLowerCase() === cap.type.toLowerCase()
+      );
+      if (match) capabilityByResource.set(match, cap);
+    }
+  }
+  const requested = (options.resources ?? []).map((r) => resolveResourceName(registry, r));
+  if (requested.length === 0 && capabilityByResource.size === 0) {
+    throw new Error(
+      capability ? "The CapabilityStatement declares no resources this FHIR version supports." : "At least one FHIR resource name (or a --capability statement) is required"
+    );
+  }
+  const schemaByResource = /* @__PURE__ */ new Map();
+  const resourceSet = new Set(
+    capability ? requested.length > 0 ? requested.filter((r) => capabilityByResource.has(r)) : [...capabilityByResource.keys()] : requested
+  );
+  if (options.profiles?.length) {
+    const ig = resolveIg(options);
+    if (ig.fhirVersion !== options.fhirVersion) {
+      throw new Error(
+        `IG package "${ig.name}" targets FHIR ${ig.fhirVersion.toUpperCase()}, but generation is for ${options.fhirVersion.toUpperCase()}. Use --fhir-version ${ig.fhirVersion}.`
+      );
+    }
+    for (const profileId of options.profiles) {
+      const applied = applyProfile(ig, profileId, registry);
+      const base = resolveResourceName(registry, applied.resourceType);
+      if (schemaByResource.has(base)) {
+        throw new Error(
+          `Multiple profiles target ${base}; generate one profiled resource per run.`
+        );
+      }
+      schemaByResource.set(base, applied.schemaName);
+      resourceSet.add(base);
+    }
+  } else if (options.ig) {
+    throw new Error("--ig requires --profile: name the profile(s) to apply.");
+  }
+  const resources = [...resourceSet];
+  const schemaFor = (resource) => schemaByResource.get(resource) ?? resource;
+  const operationPaths = {};
+  const operationRoots = [];
+  if (capability || options.operations) {
+    const knownResources = new Set(registry.resourceNames);
+    for (const resource of resources) {
+      const cap = capabilityByResource.get(resource);
+      if (capability && (!cap || cap.operations.size === 0)) continue;
+      const result = buildOperationPaths(options.fhirVersion, resource, knownResources, {
+        schemaFor,
+        only: cap?.operations
+      });
+      Object.assign(operationPaths, result.paths);
+      operationRoots.push(...result.extraSchemaRoots);
+    }
+  }
+  const roots = [
+    .../* @__PURE__ */ new Set([...resources.map(schemaFor), "Bundle", "OperationOutcome", ...operationRoots])
+  ];
+  const { schemas } = extractClosure(registry, roots, options.trim ?? {}, roots);
+  const componentSchemas = {};
+  const convertOptions = { noEnums: options.trim?.noEnums };
+  for (const name of [...schemas.keys()].sort()) {
+    componentSchemas[name] = convertSchema(schemas.get(name), openApiVersion, convertOptions);
+  }
+  const paths = {};
+  for (const resource of resources) {
+    const cap = capabilityByResource.get(resource);
+    Object.assign(
+      paths,
+      buildResourcePaths(options.fhirVersion, resource, schemaFor(resource), {
+        interactions: cap?.interactions,
+        searchParamCodes: cap?.searchParamCodes
+      })
+    );
+  }
+  Object.assign(paths, operationPaths);
+  const fhirNumber = FHIR_VERSION_NUMBERS[options.fhirVersion];
+  const document = {
+    openapi: openApiVersion,
+    info: {
+      title: options.title ?? `FHIR ${options.fhirVersion.toUpperCase()} REST API: ${resources.join(", ")}`,
+      description: `OpenAPI definition of the FHIR ${options.fhirVersion.toUpperCase()} (${fhirNumber}) RESTful interactions and JSON schemas for: ${resources.join(", ")}. Generated by fhir-openapi-translator from the official HL7 FHIR definitions. Schema validity does not imply full FHIR conformance: profiles, terminology bindings, and FHIRPath invariants are not represented.`,
+      version: fhirNumber
+    },
+    ...options.baseUrl ? { servers: [{ url: options.baseUrl }] } : {},
+    tags: resources.map((resource) => ({
+      name: resource,
+      description: `Operations on the ${resource} resource`
+    })),
+    paths,
+    components: {
+      parameters: commonSearchParameterComponents(),
+      schemas: componentSchemas
+    }
+  };
+  return document;
+}
+
+// src/capability.ts
+import fs3 from "fs";
+var KNOWN_INTERACTIONS = /* @__PURE__ */ new Set([
+  "read",
+  "vread",
+  "update",
+  "patch",
+  "delete",
+  "history-instance",
+  "history-type",
+  "create",
+  "search-type"
+]);
+async function loadCapabilityStatement(input, options = {}) {
+  let json;
+  if (/^https?:\/\//i.test(input)) {
+    const url = /\/metadata\/?$/.test(input) ? input : `${input.replace(/\/$/, "")}/metadata`;
+    const doFetch = options.fetchImpl ?? fetch;
+    let response;
+    try {
+      response = await doFetch(url, { headers: { Accept: "application/fhir+json" } });
+    } catch (cause) {
+      throw new Error(
+        `Failed to fetch CapabilityStatement from ${url}: ${cause.message}. Save it locally (curl -H 'Accept: application/fhir+json' ${url} > metadata.json) and pass the file instead.`
+      );
+    }
+    if (!response.ok) {
+      throw new Error(`CapabilityStatement request to ${url} returned ${response.status}.`);
+    }
+    json = await response.json();
+  } else {
+    if (!fs3.existsSync(input)) throw new Error(`No such CapabilityStatement file: ${input}`);
+    json = JSON.parse(fs3.readFileSync(input, "utf8"));
+  }
+  return parseCapabilityStatement(json);
+}
+function parseCapabilityStatement(json) {
+  const statement = json;
+  if (statement?.resourceType !== "CapabilityStatement") {
+    throw new Error(
+      `Expected a CapabilityStatement resource, got "${statement?.resourceType ?? "unknown"}".`
+    );
+  }
+  const byType = /* @__PURE__ */ new Map();
+  for (const rest of statement.rest ?? []) {
+    if (rest.mode && rest.mode !== "server") continue;
+    for (const raw of rest.resource ?? []) {
+      if (!raw.type) continue;
+      let cap = byType.get(raw.type);
+      if (!cap) {
+        cap = {
+          type: raw.type,
+          interactions: /* @__PURE__ */ new Set(),
+          searchParamCodes: /* @__PURE__ */ new Set(),
+          operations: /* @__PURE__ */ new Set()
+        };
+        byType.set(raw.type, cap);
+      }
+      for (const i of raw.interaction ?? []) {
+        if (i.code && KNOWN_INTERACTIONS.has(i.code)) cap.interactions.add(i.code);
+      }
+      for (const sp of raw.searchParam ?? []) {
+        if (sp.name) cap.searchParamCodes.add(sp.name);
+      }
+      for (const op of raw.operation ?? []) {
+        if (op.name) cap.operations.add(op.name);
+        if (op.definition) cap.operations.add(op.definition);
+      }
+    }
+  }
+  if (byType.size === 0) {
+    throw new Error(
+      "CapabilityStatement declares no server resources (rest[].resource). Nothing to generate."
+    );
+  }
+  return {
+    fhirVersion: statement.fhirVersion,
+    resources: [...byType.values()].sort((a, b) => a.type.localeCompare(b.type))
+  };
+}
+
+// src/merge.ts
+import { Document, parseDocument, isMap } from "yaml";
+var MergeConflictError = class extends Error {
+  constructor(conflicts) {
+    super(
+      "Refusing to overwrite existing, differing entries (use --force to overwrite):\n" + conflicts.map((c) => `  - ${c.location}`).join("\n")
+    );
+    this.conflicts = conflicts;
+    this.name = "MergeConflictError";
+  }
+  conflicts;
+};
+var MERGED_SECTIONS = [
+  ["paths", ""],
+  ["components", "schemas"],
+  ["components", "parameters"]
+];
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function unionResourceList(existing, generated) {
+  const refsOf = (node) => {
+    if (!node || typeof node !== "object" || Array.isArray(node)) return void 0;
+    const oneOf = node.oneOf;
+    if (!Array.isArray(oneOf)) return void 0;
+    const refs = [];
+    for (const item of oneOf) {
+      if (!item || typeof item !== "object" || Object.keys(item).length !== 1) return void 0;
+      const ref3 = item.$ref;
+      if (typeof ref3 !== "string") return void 0;
+      refs.push(ref3);
+    }
+    return refs;
+  };
+  const existingRefs = refsOf(existing);
+  const generatedRefs = refsOf(generated);
+  if (!existingRefs || !generatedRefs) return void 0;
+  return {
+    ...generated,
+    oneOf: [.../* @__PURE__ */ new Set([...existingRefs, ...generatedRefs])].map(($ref) => ({ $ref }))
+  };
+}
+function computeMergePlan(generated, existingText, options) {
+  const doc = parseDocument(existingText);
+  if (doc.errors.length > 0) {
+    throw new Error(`Cannot parse existing YAML: ${doc.errors[0]?.message}`);
+  }
+  if (doc.contents !== null && !isMap(doc.contents)) {
+    throw new Error("Existing file is not a YAML mapping; refusing to merge");
+  }
+  const existingVersion = doc.getIn(["openapi"]);
+  const generatedVersion = generated.openapi;
+  if (existingVersion !== void 0 && String(existingVersion) !== String(generatedVersion)) {
+    throw new Error(
+      `OpenAPI version mismatch: existing file declares ${String(existingVersion)}, generating ${String(generatedVersion)}. Regenerate with a matching --openapi-version.`
+    );
+  }
+  const conflicts = [];
+  const additions = [];
+  for (const key of ["openapi", "info", "servers"]) {
+    if (generated[key] !== void 0 && doc.getIn([key]) === void 0) {
+      additions.push({ path: [key], value: generated[key] });
+    }
+  }
+  const generatedTags = generated.tags ?? [];
+  if (generatedTags.length > 0) {
+    const existingTags = doc.toJS()?.tags;
+    if (existingTags === void 0) {
+      additions.push({ path: ["tags"], value: generatedTags });
+    } else {
+      const existingNames = new Set(existingTags.map((t) => t?.name));
+      let index = existingTags.length;
+      for (const tag of generatedTags) {
+        if (!existingNames.has(tag.name)) {
+          additions.push({ path: ["tags", index++], value: tag });
+        }
+      }
+    }
+  }
+  for (const [section, subsection] of MERGED_SECTIONS) {
+    const generatedSection = subsection ? generated[section]?.[subsection] : generated[section];
+    if (!generatedSection) continue;
+    const basePath = subsection ? [section, subsection] : [section];
+    for (const [key, value] of Object.entries(generatedSection)) {
+      const existing = doc.getIn([...basePath, key], true);
+      if (existing === void 0) {
+        additions.push({ path: [...basePath, key], value });
+      } else {
+        const existingJs = typeof existing?.toJS === "function" ? existing.toJS(doc) : existing;
+        if (!deepEqual(existingJs, value)) {
+          if (section === "components" && subsection === "schemas" && key === "ResourceList") {
+            const union = unionResourceList(existingJs, value);
+            if (union !== void 0) {
+              if (!deepEqual(existingJs, union)) {
+                additions.push({ path: [...basePath, key], value: union });
+              }
+              continue;
+            }
+          }
+          conflicts.push({ location: [...basePath, key].join(".") });
+          if (options.force) additions.push({ path: [...basePath, key], value });
+        }
+      }
+    }
+  }
+  return { doc, conflicts, additions };
+}
+function mergeIntoYaml(generated, existingText, options = {}) {
+  const { doc, conflicts, additions } = computeMergePlan(generated, existingText, options);
+  if (doc.contents === null) {
+    return stringifyDocument(generated);
+  }
+  if (conflicts.length > 0 && !options.force) {
+    throw new MergeConflictError(conflicts);
+  }
+  for (const { path: path3, value } of additions) {
+    doc.setIn(path3, doc.createNode(value));
+  }
+  return doc.toString({ lineWidth: 0 });
+}
+function diffAgainstYaml(generated, existingText) {
+  const { doc, conflicts, additions } = computeMergePlan(generated, existingText, {});
+  if (doc.contents === null) {
+    return { missing: ["(entire document: file is empty)"], changed: [], inSync: false };
+  }
+  const missing = additions.map((a) => a.path.join("."));
+  const changed = conflicts.map((c) => c.location);
+  return { missing, changed, inSync: missing.length === 0 && changed.length === 0 };
+}
+function stringifyDocument(generated) {
+  const doc = new Document(generated);
+  return doc.toString({ lineWidth: 0 });
+}
+
+export {
+  FHIR_VERSIONS,
+  FHIR_VERSION_NUMBERS,
+  loadIg,
+  loadIgSync,
+  buildCoreValueSetFallback,
+  listResources,
+  generateOpenApi,
+  loadCapabilityStatement,
+  parseCapabilityStatement,
+  MergeConflictError,
+  mergeIntoYaml,
+  diffAgainstYaml,
+  stringifyDocument
+};
+//# sourceMappingURL=chunk-G3DCRADV.js.map