fhir-test-data 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,850 @@
+#!/usr/bin/env node
+import {
+  COMMON_ALLERGY_CODES,
+  COMMON_LOINC_CODES,
+  COMMON_MEDICATION_CODES,
+  COMMON_SNOMED_CONDITIONS,
+  SUPPORTED_FHIR_VERSIONS,
+  SUPPORTED_LOCALES,
+  US_RXNORM_MEDICATION_CODES,
+  createAllergyIntoleranceBuilder,
+  createBundleBuilder,
+  createConditionBuilder,
+  createMedicationStatementBuilder,
+  createObservationBuilder,
+  createOrganizationBuilder,
+  createPatientBuilder,
+  createPractitionerBuilder,
+  createPractitionerRoleBuilder,
+  deepMerge,
+  getAllLocales,
+  getLocale
+} from "../chunk-T46LJ67Q.js";
+import {
+  FAULT_TYPES,
+  injectFaults
+} from "../chunk-CBIPVWLL.js";
+import {
+  createRng
+} from "../chunk-U2QJNKBG.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/generate.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+
+// src/core/annotations/index.ts
+var SHARED_NOTES = [
+  {
+    path: "id",
+    note: "Unique resource identifier (UUID v4)"
+  }
+];
+function identifierNotes(identifiers, defs) {
+  if (!identifiers) return [];
+  const notes = [];
+  identifiers.forEach((id, i) => {
+    const def = defs.find((d) => d.system === id.system);
+    if (!def) return;
+    const algorithmClause = def.algorithm ? `, validated with ${def.algorithm}` : "";
+    notes.push({
+      path: `identifier[${i}].value`,
+      note: `${def.name}${algorithmClause}`
+    });
+    notes.push({
+      path: `identifier[${i}].system`,
+      note: `FHIR NamingSystem URI for ${def.name} (${def.system})`
+    });
+  });
+  return notes;
+}
+function nameNotes(names) {
+  if (!names) return [];
+  return [
+    {
+      path: "name[0].use",
+      note: "FHIR name use \u2014 'official' is the primary legal name used in clinical records"
+    },
+    {
+      path: "name[0].prefix",
+      note: "Cultural or professional title prefix (e.g., Mr, Dr, Prof)"
+    }
+  ];
+}
+function addressNotes(locale) {
+  return [
+    {
+      path: "address[0].country",
+      note: `ISO 3166-1 alpha-2 country code \u2014 ${locale.address.country} = ${locale.name}`
+    },
+    {
+      path: "address[0].postalCode",
+      note: `Locale-appropriate postal code format for ${locale.name}`
+    }
+  ];
+}
+function annotatePatient(resource, locale) {
+  const identifiers = resource["identifier"];
+  const communication = resource["communication"];
+  const langCode = communication?.[0]?.language?.coding?.[0]?.code;
+  return [
+    ...SHARED_NOTES,
+    ...identifierNotes(identifiers, locale.patientIdentifiers),
+    ...nameNotes(resource["name"]),
+    {
+      path: "telecom",
+      note: "Home phone number and email address in FHIR ContactPoint format"
+    },
+    {
+      path: "gender",
+      note: "FHIR administrative gender code (male | female | other | unknown)"
+    },
+    {
+      path: "birthDate",
+      note: "Patient date of birth \u2014 ISO 8601 format (YYYY-MM-DD)"
+    },
+    ...addressNotes(locale),
+    ...langCode ? [
+      {
+        path: "communication[0].language.coding[0].code",
+        note: `BCP 47 language tag \u2014 ${langCode} identifies the primary language for this locale`
+      },
+      {
+        path: "communication[0].language.coding[0].system",
+        note: "BCP 47 \u2014 IETF language tag standard (urn:ietf:bcp:47)"
+      }
+    ] : []
+  ];
+}
+function annotatePractitioner(resource, locale) {
+  const identifiers = resource["identifier"];
+  return [
+    ...SHARED_NOTES,
+    ...identifierNotes(identifiers, locale.practitionerIdentifiers),
+    ...nameNotes(resource["name"]),
+    {
+      path: "name[0].prefix",
+      note: "Professional title prefix for practitioners (e.g., Dr, Prof)"
+    },
+    {
+      path: "telecom",
+      note: "Work email address in FHIR ContactPoint format"
+    },
+    {
+      path: "gender",
+      note: "FHIR administrative gender code (male | female | other | unknown)"
+    },
+    {
+      path: "qualification[0].code.coding[0].code",
+      note: "MD \u2014 Doctor of Medicine credential code"
+    },
+    {
+      path: "qualification[0].code.coding[0].system",
+      note: "http://terminology.hl7.org/CodeSystem/v2-0360 \u2014 HL7 degree/license/certificate code system"
+    }
+  ];
+}
+function annotatePractitionerRole(_resource) {
+  return [
+    ...SHARED_NOTES,
+    {
+      path: "active",
+      note: "Whether this role relationship is currently active"
+    },
+    {
+      path: "practitioner",
+      note: "Reference to the Practitioner resource this role belongs to (urn:uuid: format)"
+    },
+    {
+      path: "organization",
+      note: "Reference to the Organization where this role is performed (urn:uuid: format)"
+    },
+    {
+      path: "code[0].coding[0].code",
+      note: "doctor \u2014 SNOMED CT code for general practitioner role"
+    },
+    {
+      path: "code[0].coding[0].system",
+      note: "SNOMED CT code system (http://snomed.info/sct)"
+    }
+  ];
+}
+function annotateOrganization(resource, locale) {
+  const identifiers = resource["identifier"];
+  return [
+    ...SHARED_NOTES,
+    ...identifierNotes(identifiers, locale.organizationIdentifiers),
+    {
+      path: "active",
+      note: "Whether this organization is currently active \u2014 always true for generated resources"
+    },
+    {
+      path: "type[0].coding[0].code",
+      note: "prov \u2014 FHIR organization type code for healthcare provider"
+    },
+    {
+      path: "type[0].coding[0].system",
+      note: "http://terminology.hl7.org/CodeSystem/organization-type \u2014 HL7 organization type code system"
+    },
+    {
+      path: "name",
+      note: "Locale-appropriate hospital or organization name"
+    },
+    ...addressNotes(locale)
+  ];
+}
+function annotateObservation(resource) {
+  const coding = resource["code"]?.coding;
+  const loincCode = coding?.[0]?.code;
+  const loinc = loincCode ? COMMON_LOINC_CODES.find((c) => c.code === loincCode) : void 0;
+  const vq = resource["valueQuantity"];
+  const category = resource["category"]?.[0]?.coding?.[0]?.code;
+  const notes = [...SHARED_NOTES];
+  if (loinc) {
+    notes.push({
+      path: "code.coding[0].code",
+      note: `LOINC ${loinc.code} \u2014 ${loinc.display}`
+    });
+    notes.push({
+      path: "code.coding[0].system",
+      note: "LOINC \u2014 Logical Observation Identifiers Names and Codes (https://loinc.org)"
+    });
+    notes.push({
+      path: "code.coding[0].display",
+      note: `Clinical display name for LOINC ${loinc.code}`
+    });
+  }
+  if (category) {
+    notes.push({
+      path: "category[0].coding[0].code",
+      note: `${category} \u2014 FHIR observation category; groups this observation for clinical workflows`
+    });
+  }
+  notes.push({
+    path: "status",
+    note: "FHIR observation status \u2014 'final' indicates a completed, unmodified observation"
+  });
+  notes.push({
+    path: "effectiveDateTime",
+    note: "Date and time the observation was clinically relevant \u2014 ISO 8601 format"
+  });
+  if (vq) {
+    if (loinc) {
+      notes.push({
+        path: "valueQuantity.value",
+        note: `${loinc.display} measurement \u2014 clinically plausible range: ${loinc.valueRange.min}\u2013${loinc.valueRange.max}`
+      });
+      notes.push({
+        path: "valueQuantity.unit",
+        note: `${loinc.unit} \u2014 UCUM code: ${loinc.unitCode}, per HL7 FHIR guidelines for units of measure`
+      });
+    } else {
+      notes.push({
+        path: "valueQuantity.value",
+        note: "Observation measurement value"
+      });
+    }
+    notes.push({
+      path: "valueQuantity.system",
+      note: "UCUM \u2014 Unified Code for Units of Measure (https://ucum.org), required by HL7 FHIR guidelines"
+    });
+  }
+  notes.push({
+    path: "subject",
+    note: "Reference to the Patient this observation belongs to (urn:uuid: format)"
+  });
+  return notes;
+}
+function annotateCondition(resource) {
+  const coding = resource["code"]?.coding;
+  const snomedCode = coding?.[0]?.code;
+  const snomed = snomedCode ? COMMON_SNOMED_CONDITIONS.find((c) => c.code === snomedCode) : void 0;
+  const notes = [...SHARED_NOTES];
+  if (snomed) {
+    notes.push({
+      path: "code.coding[0].code",
+      note: `SNOMED CT ${snomed.code} \u2014 ${snomed.display}`
+    });
+    notes.push({
+      path: "code.coding[0].system",
+      note: "SNOMED CT \u2014 Systematized Nomenclature of Medicine Clinical Terms (http://snomed.info/sct)"
+    });
+  }
+  notes.push({
+    path: "clinicalStatus.coding[0].code",
+    note: "FHIR condition clinical status \u2014 'active' or 'remission'; indicates current state of the condition"
+  });
+  notes.push({
+    path: "verificationStatus.coding[0].code",
+    note: "FHIR verification status \u2014 'confirmed' indicates the condition has been clinically verified"
+  });
+  notes.push({
+    path: "onsetDateTime",
+    note: "Date when the condition was first clinically noted \u2014 ISO 8601 format"
+  });
+  notes.push({
+    path: "subject",
+    note: "Reference to the Patient this condition belongs to (urn:uuid: format)"
+  });
+  return notes;
+}
+function annotateAllergyIntolerance(resource) {
+  const coding = resource["code"]?.coding;
+  const code = coding?.[0]?.code;
+  const allergy = code ? COMMON_ALLERGY_CODES.find((c) => c.code === code) : void 0;
+  const notes = [...SHARED_NOTES];
+  if (allergy) {
+    notes.push({
+      path: "code.coding[0].code",
+      note: `SNOMED CT ${allergy.code} \u2014 ${allergy.display}`
+    });
+    notes.push({
+      path: "code.coding[0].system",
+      note: "SNOMED CT \u2014 Systematized Nomenclature of Medicine Clinical Terms (http://snomed.info/sct)"
+    });
+    notes.push({
+      path: "category",
+      note: `FHIR allergy category \u2014 ${allergy.category}: type of substance causing the reaction`
+    });
+  }
+  notes.push({
+    path: "type",
+    note: "FHIR allergy type \u2014 'allergy' (immune-mediated) or 'intolerance' (non-immune mechanism)"
+  });
+  notes.push({
+    path: "criticality",
+    note: "FHIR allergy criticality \u2014 potential severity: low | high | unable-to-assess"
+  });
+  notes.push({
+    path: "patient",
+    note: "Reference to the Patient this allergy record belongs to (urn:uuid: format)"
+  });
+  notes.push({
+    path: "recordedDate",
+    note: "Date when this allergy was first recorded \u2014 ISO 8601 format (YYYY-MM-DD)"
+  });
+  return notes;
+}
+function annotateMedicationStatement(resource) {
+  const r4Coding = resource["medicationCodeableConcept"]?.coding;
+  const r5Coding = resource["medication"]?.concept?.coding;
+  const coding = r4Coding ?? r5Coding;
+  const code = coding?.[0]?.code;
+  const allMeds = [...COMMON_MEDICATION_CODES, ...US_RXNORM_MEDICATION_CODES];
+  const med = code ? allMeds.find((m) => m.code === code) : void 0;
+  const resourceType = resource["resourceType"];
+  const isR5 = resourceType === "MedicationUsage";
+  const notes = [...SHARED_NOTES];
+  if (med) {
+    const codePath = isR5 ? "medication.concept.coding[0].code" : "medicationCodeableConcept.coding[0].code";
+    const systemPath = isR5 ? "medication.concept.coding[0].system" : "medicationCodeableConcept.coding[0].system";
+    notes.push({
+      path: codePath,
+      note: `${med.system.includes("rxnorm") ? "RxNorm" : "SNOMED CT"} ${med.code} \u2014 ${med.display}; typical dose: ${med.typicalDoseMg}mg ${med.frequency}`
+    });
+    notes.push({
+      path: systemPath,
+      note: med.system.includes("rxnorm") ? "RxNorm \u2014 US National Library of Medicine drug terminology (http://www.nlm.nih.gov/research/umls/rxnorm)" : "SNOMED CT \u2014 Systematized Nomenclature of Medicine Clinical Terms (http://snomed.info/sct)"
+    });
+  }
+  notes.push({
+    path: "status",
+    note: `FHIR ${isR5 ? "MedicationUsage" : "MedicationStatement"} status \u2014 'active' or 'stopped'`
+  });
+  notes.push({
+    path: "subject",
+    note: "Reference to the Patient this medication record belongs to (urn:uuid: format)"
+  });
+  return notes;
+}
+function annotateBundle(resource) {
+  const entries = resource["entry"];
+  const resourceTypes = entries ? [...new Set(entries.map((e) => e.resource?.resourceType).filter(Boolean))] : [];
+  return [
+    ...SHARED_NOTES,
+    {
+      path: "type",
+      note: "FHIR Bundle type \u2014 'transaction' includes request entries; 'collection' is a plain grouping"
+    },
+    {
+      path: "entry",
+      note: `Bundle entries \u2014 ${entries?.length ?? 0} resources: ${resourceTypes.join(", ")}`
+    },
+    {
+      path: "entry[*].fullUrl",
+      note: "urn:uuid: format \u2014 temporary URIs used for cross-reference within the bundle"
+    },
+    {
+      path: "entry[*].request",
+      note: "FHIR transaction request metadata \u2014 method (PUT/POST) and URL for server processing"
+    }
+  ];
+}
+function annotateResource(resource, locale) {
+  switch (resource.resourceType) {
+    case "Patient":
+      return annotatePatient(resource, locale);
+    case "Practitioner":
+      return annotatePractitioner(resource, locale);
+    case "PractitionerRole":
+      return annotatePractitionerRole(resource);
+    case "Organization":
+      return annotateOrganization(resource, locale);
+    case "Observation":
+      return annotateObservation(resource);
+    case "Condition":
+      return annotateCondition(resource);
+    case "AllergyIntolerance":
+      return annotateAllergyIntolerance(resource);
+    case "MedicationStatement":
+    case "MedicationUsage":
+      return annotateMedicationStatement(resource);
+    case "Bundle":
+      return annotateBundle(resource);
+    default:
+      return [...SHARED_NOTES];
+  }
+}
+
+// src/cli/commands/generate.ts
+var BUILDER_FACTORIES = {
+  patient: (l, c, s, v) => createPatientBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  practitioner: (l, c, s, v) => createPractitionerBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  "practitioner-role": (l, c, s, v) => createPractitionerRoleBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  organization: (l, c, s, v) => createOrganizationBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  observation: (l, c, s, v) => createObservationBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  condition: (l, c, s, v) => createConditionBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  "allergy-intolerance": (l, c, s, v) => createAllergyIntoleranceBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  "medication-statement": (l, c, s, v) => createMedicationStatementBuilder().locale(l).count(c).seed(s).fhirVersion(v).build(),
+  bundle: (l, c, s, v) => createBundleBuilder().locale(l).count(c).seed(s).fhirVersion(v).build()
+};
+var CONCRETE_RESOURCE_TYPES = Object.keys(BUILDER_FACTORIES);
+var ALL_RESOURCE_TYPES = [...CONCRETE_RESOURCE_TYPES, "all"];
+function parseFaults(raw) {
+  const types = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const invalid = types.filter((t) => !FAULT_TYPES.includes(t));
+  if (invalid.length > 0) {
+    return {
+      error: `Unknown fault type(s): ${invalid.join(", ")}. Valid types: ${FAULT_TYPES.join(", ")}`
+    };
+  }
+  return types;
+}
+async function readStdinOverrides() {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      if (!data.trim()) {
+        resolve(null);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(data);
+        resolve(parsed);
+      } catch {
+        reject(
+          new Error(
+            `stdin is not valid JSON. Received: ${data.slice(0, 120)}${data.length > 120 ? "\u2026" : ""}`
+          )
+        );
+      }
+    });
+    process.stdin.on("error", reject);
+  });
+}
+function formatIndex(i, total) {
+  const width = Math.max(3, String(total).length);
+  return String(i + 1).padStart(width, "0");
+}
+function writeToOutput(units, resourceType, outputDir, format, annotate) {
+  mkdirSync(outputDir, { recursive: true });
+  const firstResource = annotate ? units[0]?.resource : units[0];
+  const fhirType = firstResource?.["resourceType"] ?? resourceType;
+  if (format === "ndjson") {
+    const content = units.map((u) => JSON.stringify(u)).join("\n") + "\n";
+    const filePath = join(outputDir, `${fhirType}.ndjson`);
+    writeFileSync(filePath, content, "utf8");
+  } else {
+    for (let i = 0; i < units.length; i++) {
+      const idx = formatIndex(i, units.length);
+      const filePath = join(outputDir, `${fhirType}-${idx}.json`);
+      writeFileSync(filePath, JSON.stringify(units[i], null, 2) + "\n", "utf8");
+    }
+  }
+  process.stderr.write(
+    `Generated ${units.length} ${fhirType} resource${units.length === 1 ? "" : "s"} in ${outputDir}
+`
+  );
+}
+function writeToStdout(units, format, pretty, forceCompact = false) {
+  if (format === "ndjson" || forceCompact) {
+    for (const u of units) {
+      process.stdout.write(JSON.stringify(u) + "\n");
+    }
+  } else if (units.length === 1) {
+    const indent = pretty ? 2 : void 0;
+    process.stdout.write(JSON.stringify(units[0], null, indent) + "\n");
+  } else {
+    const indent = pretty ? 2 : void 0;
+    process.stdout.write(JSON.stringify(units, null, indent) + "\n");
+  }
+}
+async function runGenerate(resourceType, opts) {
+  if (!ALL_RESOURCE_TYPES.includes(resourceType)) {
+    process.stderr.write(
+      `Error: unknown resource type "${resourceType}". Valid types: ${ALL_RESOURCE_TYPES.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  if (!SUPPORTED_LOCALES.includes(opts.locale)) {
+    process.stderr.write(
+      `Error: unknown locale "${opts.locale}". Supported locales: ${SUPPORTED_LOCALES.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  if (!SUPPORTED_FHIR_VERSIONS.includes(opts.fhirVersion)) {
+    process.stderr.write(
+      `Error: unknown FHIR version "${opts.fhirVersion}". Supported versions: ${SUPPORTED_FHIR_VERSIONS.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  let faults = [];
+  if (opts.faults !== void 0) {
+    const parsed = parseFaults(opts.faults);
+    if ("error" in parsed) {
+      process.stderr.write(`Error: ${parsed.error}
+`);
+      process.exit(1);
+    }
+    faults = parsed;
+  }
+  let overridesObj = {};
+  try {
+    const stdinOverrides = await readStdinOverrides();
+    if (stdinOverrides !== null) {
+      overridesObj = stdinOverrides;
+    }
+  } catch (err) {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+  if (opts.overrides !== void 0) {
+    try {
+      const cliOverrides = JSON.parse(opts.overrides);
+      overridesObj = deepMerge(overridesObj, cliOverrides);
+    } catch {
+      process.stderr.write(
+        `Error: --overrides value is not valid JSON. Received: ${opts.overrides.slice(0, 120)}
+`
+      );
+      process.exit(1);
+    }
+  }
+  const hasOverrides = Object.keys(overridesObj).length > 0;
+  const locale = opts.locale;
+  const fhirVersion = opts.fhirVersion;
+  const count = Number.parseInt(opts.count, 10);
+  const seed = opts.seed !== void 0 ? Number.parseInt(opts.seed, 10) : Math.floor(Math.random() * 2147483647);
+  const format = opts.format === "ndjson" ? "ndjson" : "json";
+  const localeDefinition = getLocale(locale);
+  const typesToGenerate = resourceType === "all" ? CONCRETE_RESOURCE_TYPES : [resourceType];
+  let coordinatedPractId;
+  let coordinatedOrgId;
+  if (resourceType === "all") {
+    const [firstPract] = BUILDER_FACTORIES["practitioner"](locale, count, seed, fhirVersion);
+    const [firstOrg] = BUILDER_FACTORIES["organization"](locale, count, seed, fhirVersion);
+    coordinatedPractId = firstPract?.["id"];
+    coordinatedOrgId = firstOrg?.["id"];
+  }
+  for (const type of typesToGenerate) {
+    let resources;
+    if (type === "practitioner-role" && coordinatedPractId !== void 0 && coordinatedOrgId !== void 0) {
+      resources = createPractitionerRoleBuilder().locale(locale).count(count).seed(seed).fhirVersion(fhirVersion).practitionerId(coordinatedPractId).organizationId(coordinatedOrgId).build();
+    } else {
+      resources = BUILDER_FACTORIES[type](locale, count, seed, fhirVersion);
+    }
+    if (faults.length > 0) {
+      const faultRng = createRng(seed + 1);
+      resources = resources.map((r) => injectFaults(r, faults, faultRng));
+    }
+    if (hasOverrides) {
+      resources = resources.map(
+        (r) => deepMerge(r, overridesObj)
+      );
+    }
+    const units = opts.annotate ? resources.map((r) => ({
+      resource: r,
+      notes: annotateResource(r, localeDefinition)
+    })) : resources;
+    if (opts.output !== void 0) {
+      try {
+        writeToOutput(units, type, opts.output, format, opts.annotate);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error writing output: ${message}
+`);
+        process.exit(2);
+      }
+    } else {
+      writeToStdout(units, format, opts.pretty, typesToGenerate.length > 1);
+    }
+  }
+}
+function registerGenerateCommand(program2) {
+  program2.command("generate <resource-type>").description(`Generate FHIR resources. Resource types: ${ALL_RESOURCE_TYPES.join(", ")}`).option("--locale <code>", "locale for identifiers and addresses", "us").option("--count <n>", "number of resources to generate", "1").option("--seed <n>", "seed for deterministic output").option(
+    "--fhir-version <version>",
+    `FHIR version to target: ${SUPPORTED_FHIR_VERSIONS.join(" | ")}`,
+    "R4"
+  ).option("--output <dir>", "output directory (one file per resource)").option("--format <fmt>", "output format: json | ndjson", "json").option("--pretty", "pretty-print JSON (default for stdout)", true).option("--no-pretty", "compact JSON output").option(
+    "--faults <types>",
+    `comma-separated fault types to inject. Valid: ${FAULT_TYPES.join(", ")}`
+  ).option(
+    "--overrides <json>",
+    "JSON object to deep-merge into every generated resource (also readable from stdin)"
+  ).option(
+    "--annotate",
+    "wrap each resource with a notes array explaining its fields in plain language",
+    false
+  ).action(runGenerate);
+}
+
+// src/cli/commands/locales.ts
+function runLocales(opts) {
+  const locales = getAllLocales().map((locale) => ({
+    code: locale.code,
+    name: locale.name,
+    patientIdentifiers: locale.patientIdentifiers.map((id) => ({
+      name: id.name,
+      system: id.system,
+      ...id.algorithm !== void 0 ? { algorithm: id.algorithm } : {}
+    })),
+    practitionerIdentifiers: locale.practitionerIdentifiers.map((id) => ({
+      name: id.name,
+      system: id.system,
+      ...id.algorithm !== void 0 ? { algorithm: id.algorithm } : {}
+    })),
+    organizationIdentifiers: locale.organizationIdentifiers.map((id) => ({
+      name: id.name,
+      system: id.system,
+      ...id.algorithm !== void 0 ? { algorithm: id.algorithm } : {}
+    }))
+  }));
+  const indent = opts.pretty ? 2 : void 0;
+  process.stdout.write(JSON.stringify(locales, null, indent) + "\n");
+}
+function registerLocalesCommand(program2) {
+  program2.command("locales").description(
+    "List all supported locales with their identifier systems and check-digit algorithms"
+  ).option("--pretty", "pretty-print JSON (default for stdout)", true).option("--no-pretty", "compact JSON output").action(runLocales);
+}
+
+// src/cli/commands/describe.ts
+var RESOURCE_DESCRIPTIONS = {
+  patient: {
+    resourceType: "Patient",
+    description: "FHIR Patient with locale-appropriate identifiers, names, address, and communication language",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      identifier: "Locale-specific patient identifiers (check-digit validated where applicable)",
+      "name[0].use": "FHIR name use \u2014 'official' is the primary legal name for clinical records",
+      "name[0].family": "Family (last) name drawn from locale name pool",
+      "name[0].given": "Given (first) name drawn from locale name pool",
+      "name[0].prefix": "Cultural or professional title prefix (Mr, Mrs, Dr, etc.)",
+      "telecom[0]": "Home phone number in locale-appropriate format (FHIR ContactPoint)",
+      "telecom[1]": "Email address (FHIR ContactPoint)",
+      gender: "FHIR administrative gender: male | female",
+      birthDate: "Random date in adult age range \u2014 ISO 8601 format (YYYY-MM-DD)",
+      "address[0]": "Locale-appropriate street address with city and postal code",
+      "communication[0].language.coding[0].code": "BCP 47 language tag \u2014 primary language for the locale"
+    }
+  },
+  practitioner: {
+    resourceType: "Practitioner",
+    description: "FHIR Practitioner with locale-appropriate identifiers, professional name, and MD qualification",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      identifier: "Locale-specific practitioner identifiers (check-digit validated where applicable)",
+      "name[0].prefix": "Professional title prefix (Dr, Prof)",
+      "name[0].family": "Family name drawn from locale name pool",
+      "name[0].given": "Given name drawn from locale name pool",
+      "telecom[0]": "Work email address (FHIR ContactPoint)",
+      gender: "FHIR administrative gender: male | female",
+      "qualification[0].code.coding[0].code": "MD \u2014 Doctor of Medicine credential code",
+      "qualification[0].code.coding[0].system": "http://terminology.hl7.org/CodeSystem/v2-0360 \u2014 HL7 degree/license/certificate code system"
+    }
+  },
+  "practitioner-role": {
+    resourceType: "PractitionerRole",
+    description: "FHIR PractitionerRole linking a Practitioner to an Organization with a coded role",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      active: "Whether this role relationship is currently active",
+      practitioner: "Reference to the Practitioner (urn:uuid: format)",
+      organization: "Reference to the Organization where this role is performed (urn:uuid: format)",
+      "code[0].coding[0].code": "doctor \u2014 SNOMED CT code for general practitioner role",
+      "code[0].coding[0].system": "SNOMED CT code system (http://snomed.info/sct)"
+    }
+  },
+  organization: {
+    resourceType: "Organization",
+    description: "FHIR Organization (healthcare provider) with locale-appropriate identifiers and address",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      identifier: "Locale-specific organization identifiers",
+      active: "Whether this organization is currently active \u2014 always true for generated resources",
+      "type[0].coding[0].code": "prov \u2014 FHIR organization type code for healthcare provider",
+      "type[0].coding[0].system": "http://terminology.hl7.org/CodeSystem/organization-type \u2014 HL7 organization type code system",
+      name: "Locale-appropriate hospital or clinic name",
+      "telecom[0]": "Main phone number (FHIR ContactPoint)",
+      "address[0]": "Locale-appropriate street address with city and postal code"
+    }
+  },
+  observation: {
+    resourceType: "Observation",
+    description: "FHIR Observation with a real LOINC code, value in a clinically plausible range, and HL7-consistent UCUM units",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      status: "FHIR observation status \u2014 'final' indicates a completed, unmodified observation",
+      "category[0].coding[0].code": "FHIR observation category \u2014 vital-signs or laboratory",
+      "code.coding[0].code": "LOINC code identifying the observation type (https://loinc.org)",
+      "code.coding[0].system": "LOINC \u2014 Logical Observation Identifiers Names and Codes (https://loinc.org)",
+      "code.coding[0].display": "Human-readable LOINC display name",
+      subject: "Reference to the Patient this observation belongs to (urn:uuid: format)",
+      effectiveDateTime: "Date and time the observation was clinically relevant \u2014 ISO 8601 format",
+      "valueQuantity.value": "Numeric measurement in a clinically plausible range for the LOINC code",
+      "valueQuantity.unit": "Human-readable unit name (e.g., 'mmHg' for blood pressure)",
+      "valueQuantity.system": "UCUM \u2014 Unified Code for Units of Measure (https://ucum.org), required by HL7 FHIR",
+      "valueQuantity.code": "UCUM code for the unit (e.g., 'mm[Hg]'), machine-readable unit identifier"
+    }
+  },
+  condition: {
+    resourceType: "Condition",
+    description: "FHIR Condition with a real SNOMED CT code, clinical status, and verification status",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      "clinicalStatus.coding[0].code": "FHIR condition clinical status \u2014 'active' or 'remission'",
+      "clinicalStatus.coding[0].system": "http://terminology.hl7.org/CodeSystem/condition-clinical",
+      "verificationStatus.coding[0].code": "FHIR verification status \u2014 'confirmed' indicates clinically verified",
+      "code.coding[0].code": "SNOMED CT code identifying the clinical condition (https://snomed.info/sct)",
+      "code.coding[0].system": "SNOMED CT \u2014 Systematized Nomenclature of Medicine Clinical Terms",
+      "code.coding[0].display": "Human-readable SNOMED CT display name",
+      subject: "Reference to the Patient this condition belongs to (urn:uuid: format)",
+      onsetDateTime: "Date when the condition was first noted \u2014 ISO 8601 format"
+    }
+  },
+  "allergy-intolerance": {
+    resourceType: "AllergyIntolerance",
+    description: "FHIR AllergyIntolerance with SNOMED CT coded substance, type, category, and criticality",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      type: "FHIR allergy type \u2014 'allergy' (immune-mediated) or 'intolerance' (non-immune)",
+      category: "FHIR allergy category \u2014 food | medication | environment | biologic",
+      criticality: "Potential severity \u2014 low | high | unable-to-assess",
+      "code.coding[0].code": "SNOMED CT code identifying the substance or reaction",
+      "code.coding[0].system": "SNOMED CT \u2014 Systematized Nomenclature of Medicine Clinical Terms",
+      patient: "Reference to the Patient this allergy record belongs to (urn:uuid: format)",
+      recordedDate: "Date when this allergy was first recorded \u2014 ISO 8601 (YYYY-MM-DD)"
+    }
+  },
+  "medication-statement": {
+    resourceType: "MedicationStatement (R4/R4B) | MedicationUsage (R5)",
+    description: "FHIR MedicationStatement (R4/R4B) or MedicationUsage (R5) with a SNOMED CT or RxNorm coded medication",
+    fields: {
+      id: "UUID v4 \u2014 unique resource identifier",
+      status: "FHIR medication status \u2014 'active' or 'stopped'",
+      "medicationCodeableConcept.coding[0].code": "SNOMED CT or RxNorm code identifying the medication (R4/R4B only)",
+      "medication.concept.coding[0].code": "SNOMED CT or RxNorm code identifying the medication (R5 MedicationUsage only)",
+      subject: "Reference to the Patient this medication record belongs to (urn:uuid: format)",
+      "effectivePeriod.start": "Start date of medication use \u2014 ISO 8601 format",
+      "effectivePeriod.end": "End date of medication use \u2014 ISO 8601 format (may be absent for active)"
+    }
+  },
+  bundle: {
+    resourceType: "Bundle",
+    description: "FHIR Bundle composing Patient, Practitioner, PractitionerRole, Organization, and clinical resources with automatic urn:uuid: reference wiring",
+    fields: {
+      id: "UUID v4 \u2014 unique bundle identifier",
+      type: "FHIR Bundle type \u2014 transaction | collection | searchset | document",
+      "entry[*].fullUrl": "urn:uuid: URIs used for cross-referencing resources within the bundle",
+      "entry[*].resource": "Embedded FHIR resource \u2014 Patient, Practitioner, Organization, Observation, etc.",
+      "entry[*].request": "Transaction request metadata \u2014 method and URL (transaction bundles only)",
+      "entry[*].search": "Search mode metadata \u2014 match or include (searchset bundles only)"
+    }
+  }
+};
+var DESCRIBABLE_RESOURCE_TYPES = Object.keys(
+  RESOURCE_DESCRIPTIONS
+);
+function runDescribe(resourceType, opts) {
+  if (!DESCRIBABLE_RESOURCE_TYPES.includes(resourceType)) {
+    process.stderr.write(
+      `Error: unknown resource type "${resourceType}". Valid types: ${DESCRIBABLE_RESOURCE_TYPES.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  if (opts.locale !== void 0 && !SUPPORTED_LOCALES.includes(opts.locale)) {
+    process.stderr.write(
+      `Error: unknown locale "${opts.locale}". Supported locales: ${SUPPORTED_LOCALES.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  const description = RESOURCE_DESCRIPTIONS[resourceType];
+  const output = {
+    resourceType: description.resourceType,
+    description: description.description,
+    fields: description.fields,
+    supportedLocales: [...SUPPORTED_LOCALES]
+  };
+  if (opts.locale !== void 0) {
+    const locale = getLocale(opts.locale);
+    output["localeDetail"] = {
+      code: locale.code,
+      name: locale.name,
+      patientIdentifiers: locale.patientIdentifiers.map((id) => ({
+        name: id.name,
+        system: id.system,
+        ...id.algorithm !== void 0 ? { algorithm: id.algorithm } : {}
+      })),
+      practitionerIdentifiers: locale.practitionerIdentifiers.map((id) => ({
+        name: id.name,
+        system: id.system,
+        ...id.algorithm !== void 0 ? { algorithm: id.algorithm } : {}
+      })),
+      organizationIdentifiers: locale.organizationIdentifiers.map((id) => ({
+        name: id.name,
+        system: id.system,
+        ...id.algorithm !== void 0 ? { algorithm: id.algorithm } : {}
+      }))
+    };
+  }
+  const indent = opts.pretty ? 2 : void 0;
+  process.stdout.write(JSON.stringify(output, null, indent) + "\n");
+}
+function registerDescribeCommand(program2) {
+  program2.command("describe <resource-type>").description(
+    `Describe what a resource type generates. Types: ${DESCRIBABLE_RESOURCE_TYPES.join(", ")}`
+  ).option("--locale <code>", "include locale-specific identifier details for this locale").option("--pretty", "pretty-print JSON (default for stdout)", true).option("--no-pretty", "compact JSON output").action(runDescribe);
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("fhir-test-data").description("Generate valid FHIR R4 test resources with country-aware identifiers").version("0.1.0");
+registerGenerateCommand(program);
+registerLocalesCommand(program);
+registerDescribeCommand(program);
+var argv = process.argv[2] === "--" ? [...process.argv.slice(0, 2), ...process.argv.slice(3)] : process.argv;
+await program.parseAsync(argv);
+//# sourceMappingURL=index.js.map