@metriport/fhir-sdk 1.12.0 → 2.0.0

package/dist/__tests__/audit-reference-methods.test.js

@@ -0,0 +1,911 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Tests for reference methods added during the AUDITING_REFERENCE_FIELDS.md gap-fill.
+ * Each section covers one resource type and only the newly-added getter methods.
+ */
+const index_1 = require("../index");
+// ---------------------------------------------------------------------------
+// MedicationAdministration
+// ---------------------------------------------------------------------------
+const medAdminBundle = {
+    resourceType: "Bundle",
+    type: "collection",
+    entry: [
+        {
+            resource: {
+                resourceType: "Patient",
+                id: "patient-ma",
+            },
+        },
+        {
+            resource: {
+                resourceType: "Encounter",
+                id: "encounter-ma",
+                status: "finished",
+                class: { code: "AMB" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Medication",
+                id: "medication-ma",
+                code: { text: "Aspirin" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Procedure",
+                id: "procedure-ma",
+                status: "completed",
+                subject: { reference: "Patient/patient-ma" },
+                code: { text: "IV Insertion" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Condition",
+                id: "condition-ma",
+                clinicalStatus: { coding: [{ code: "active" }] },
+                subject: { reference: "Patient/patient-ma" },
+                code: { text: "Pain" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Observation",
+                id: "observation-ma",
+                status: "final",
+                code: { text: "Vital sign" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "MedicationRequest",
+                id: "medrequest-ma",
+                status: "active",
+                intent: "order",
+                subject: { reference: "Patient/patient-ma" },
+                medicationCodeableConcept: { text: "Aspirin" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Device",
+                id: "device-ma",
+                deviceName: [{ name: "IV Pump", type: "user-friendly-name" }],
+            },
+        },
+        {
+            resource: {
+                resourceType: "Provenance",
+                id: "provenance-ma",
+                recorded: "2024-01-01T00:00:00Z",
+                target: [],
+                agent: [],
+            },
+        },
+        {
+            resource: {
+                resourceType: "MedicationAdministration",
+                id: "medadmin-main",
+                status: "completed",
+                medicationReference: { reference: "Medication/medication-ma" },
+                subject: { reference: "Patient/patient-ma" },
+                context: { reference: "Encounter/encounter-ma" },
+                effectiveDateTime: "2024-01-01T10:00:00Z",
+                partOf: [{ reference: "Procedure/procedure-ma" }],
+                supportingInformation: [{ reference: "Observation/observation-ma" }],
+                reasonReference: [{ reference: "Condition/condition-ma" }],
+                request: { reference: "MedicationRequest/medrequest-ma" },
+                device: [{ reference: "Device/device-ma" }],
+                eventHistory: [{ reference: "Provenance/provenance-ma" }],
+            },
+        },
+    ],
+};
+describe("MedicationAdministration new reference methods", () => {
+    it("getPartOf resolves to Procedure", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medAdminBundle);
+        const ma = sdk.getResourceById("medadmin-main");
+        const partOf = ma?.getPartOf?.();
+        expect(partOf).toHaveLength(1);
+        expect(partOf?.[0]?.resourceType).toBe("Procedure");
+        expect(partOf?.[0]?.id).toBe("procedure-ma");
+    });
+    it("getSupportingInformation resolves to Observation", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medAdminBundle);
+        const ma = sdk.getResourceById("medadmin-main");
+        const info = ma?.getSupportingInformation?.();
+        expect(info).toHaveLength(1);
+        expect(info?.[0]?.resourceType).toBe("Observation");
+        expect(info?.[0]?.id).toBe("observation-ma");
+    });
+    it("getReasonReferences resolves to Condition", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medAdminBundle);
+        const ma = sdk.getResourceById("medadmin-main");
+        const reasons = ma?.getReasonReferences?.();
+        expect(reasons).toHaveLength(1);
+        expect(reasons?.[0]?.resourceType).toBe("Condition");
+        expect(reasons?.[0]?.id).toBe("condition-ma");
+    });
+    it("getRequest resolves to MedicationRequest", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medAdminBundle);
+        const ma = sdk.getResourceById("medadmin-main");
+        const request = ma?.getRequest?.();
+        expect(request?.resourceType).toBe("MedicationRequest");
+        expect(request?.id).toBe("medrequest-ma");
+    });
+    it("getDevices resolves to Device", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medAdminBundle);
+        const ma = sdk.getResourceById("medadmin-main");
+        const devices = ma?.getDevices?.();
+        expect(devices).toHaveLength(1);
+        expect(devices?.[0]?.resourceType).toBe("Device");
+        expect(devices?.[0]?.id).toBe("device-ma");
+    });
+    it("getEventHistory resolves to Provenance", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medAdminBundle);
+        const ma = sdk.getResourceById("medadmin-main");
+        const history = ma?.getEventHistory?.();
+        expect(history).toHaveLength(1);
+        expect(history?.[0]?.resourceType).toBe("Provenance");
+        expect(history?.[0]?.id).toBe("provenance-ma");
+    });
+    it("returns empty array for missing optional array fields", async () => {
+        const sdk = await index_1.FhirBundleSdk.create({
+            resourceType: "Bundle",
+            type: "collection",
+            entry: [
+                {
+                    resource: {
+                        resourceType: "Patient",
+                        id: "patient-ma-min",
+                    },
+                },
+                {
+                    resource: {
+                        resourceType: "MedicationAdministration",
+                        id: "medadmin-min",
+                        status: "completed",
+                        medicationCodeableConcept: { text: "Aspirin" },
+                        subject: { reference: "Patient/patient-ma-min" },
+                        effectiveDateTime: "2024-01-01T10:00:00Z",
+                    },
+                },
+            ],
+        });
+        const ma = sdk.getResourceById("medadmin-min");
+        const partOf = ma?.getPartOf?.();
+        expect(partOf === undefined || partOf.length === 0).toBe(true);
+        const supportingInfo = ma?.getSupportingInformation?.();
+        expect(supportingInfo === undefined || supportingInfo.length === 0).toBe(true);
+        const reasonRef = ma?.getReasonReferences?.();
+        expect(reasonRef === undefined || reasonRef.length === 0).toBe(true);
+        expect(ma?.getRequest?.()).toBeUndefined();
+        const devices = ma?.getDevices?.();
+        expect(devices === undefined || devices.length === 0).toBe(true);
+        const eventHistory = ma?.getEventHistory?.();
+        expect(eventHistory === undefined || eventHistory.length === 0).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// MedicationDispense
+// ---------------------------------------------------------------------------
+const medDispenseBundle = {
+    resourceType: "Bundle",
+    type: "collection",
+    entry: [
+        {
+            resource: {
+                resourceType: "Patient",
+                id: "patient-md",
+            },
+        },
+        {
+            resource: {
+                resourceType: "Procedure",
+                id: "procedure-md",
+                status: "completed",
+                subject: { reference: "Patient/patient-md" },
+                code: { text: "Dispense event" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "DetectedIssue",
+                id: "detectedissue-md",
+                status: "final",
+                patient: { reference: "Patient/patient-md" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Location",
+                id: "location-md",
+                name: "Pharmacy",
+            },
+        },
+        {
+            resource: {
+                resourceType: "MedicationRequest",
+                id: "medrequest-md",
+                status: "active",
+                intent: "order",
+                subject: { reference: "Patient/patient-md" },
+                medicationCodeableConcept: { text: "Metformin" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Practitioner",
+                id: "practitioner-md",
+                name: [{ family: "Smith" }],
+            },
+        },
+        {
+            resource: {
+                resourceType: "Provenance",
+                id: "provenance-md",
+                recorded: "2024-01-01T00:00:00Z",
+                target: [],
+                agent: [],
+            },
+        },
+        {
+            resource: {
+                resourceType: "Medication",
+                id: "medication-md",
+                code: { text: "Metformin" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "MedicationDispense",
+                id: "meddispense-main",
+                status: "completed",
+                medicationReference: { reference: "Medication/medication-md" },
+                subject: { reference: "Patient/patient-md" },
+                partOf: [{ reference: "Procedure/procedure-md" }],
+                statusReasonReference: { reference: "DetectedIssue/detectedissue-md" },
+                supportingInformation: [{ reference: "Patient/patient-md" }],
+                location: { reference: "Location/location-md" },
+                authorizingPrescription: [{ reference: "MedicationRequest/medrequest-md" }],
+                destination: { reference: "Location/location-md" },
+                receiver: [{ reference: "Practitioner/practitioner-md" }],
+                detectedIssue: [{ reference: "DetectedIssue/detectedissue-md" }],
+                eventHistory: [{ reference: "Provenance/provenance-md" }],
+                substitution: {
+                    wasSubstituted: false,
+                    responsibleParty: [{ reference: "Practitioner/practitioner-md" }],
+                },
+            },
+        },
+    ],
+};
+describe("MedicationDispense new reference methods", () => {
+    it("getPartOf resolves to Procedure", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const partOf = md?.getPartOf?.();
+        expect(partOf).toHaveLength(1);
+        expect(partOf?.[0]?.resourceType).toBe("Procedure");
+        expect(partOf?.[0]?.id).toBe("procedure-md");
+    });
+    it("getStatusReasonReference resolves to DetectedIssue", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const reason = md?.getStatusReasonReference?.();
+        expect(reason?.resourceType).toBe("DetectedIssue");
+        expect(reason?.id).toBe("detectedissue-md");
+    });
+    it("getSupportingInformation resolves to resources", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const info = md?.getSupportingInformation?.();
+        expect(info).toHaveLength(1);
+        expect(info?.[0]?.id).toBe("patient-md");
+    });
+    it("getLocation resolves to Location", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const location = md?.getLocation?.();
+        expect(location?.resourceType).toBe("Location");
+        expect(location?.id).toBe("location-md");
+    });
+    it("getAuthorizingPrescriptions resolves to MedicationRequest", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const prescriptions = md?.getAuthorizingPrescriptions?.();
+        expect(prescriptions).toHaveLength(1);
+        expect(prescriptions?.[0]?.resourceType).toBe("MedicationRequest");
+        expect(prescriptions?.[0]?.id).toBe("medrequest-md");
+    });
+    it("getDestination resolves to Location", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const dest = md?.getDestination?.();
+        expect(dest?.resourceType).toBe("Location");
+        expect(dest?.id).toBe("location-md");
+    });
+    it("getReceivers resolves to Practitioner", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const receivers = md?.getReceivers?.();
+        expect(receivers).toHaveLength(1);
+        expect(receivers?.[0]?.resourceType).toBe("Practitioner");
+        expect(receivers?.[0]?.id).toBe("practitioner-md");
+    });
+    it("getDetectedIssues resolves to DetectedIssue", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const issues = md?.getDetectedIssues?.();
+        expect(issues).toHaveLength(1);
+        expect(issues?.[0]?.resourceType).toBe("DetectedIssue");
+        expect(issues?.[0]?.id).toBe("detectedissue-md");
+    });
+    it("getEventHistory resolves to Provenance", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const history = md?.getEventHistory?.();
+        expect(history).toHaveLength(1);
+        expect(history?.[0]?.resourceType).toBe("Provenance");
+        expect(history?.[0]?.id).toBe("provenance-md");
+    });
+    it("getResponsibleParties resolves to Practitioner", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medDispenseBundle);
+        const md = sdk.getResourceById("meddispense-main");
+        const responsible = md?.getResponsibleParties?.();
+        expect(responsible).toHaveLength(1);
+        expect(responsible?.[0]?.resourceType).toBe("Practitioner");
+        expect(responsible?.[0]?.id).toBe("practitioner-md");
+    });
+});
+// ---------------------------------------------------------------------------
+// MedicationStatement
+// ---------------------------------------------------------------------------
+const medStatementBundle = {
+    resourceType: "Bundle",
+    type: "collection",
+    entry: [
+        {
+            resource: {
+                resourceType: "Patient",
+                id: "patient-ms",
+            },
+        },
+        {
+            resource: {
+                resourceType: "MedicationRequest",
+                id: "medrequest-ms",
+                status: "active",
+                intent: "order",
+                subject: { reference: "Patient/patient-ms" },
+                medicationCodeableConcept: { text: "Lisinopril" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Observation",
+                id: "observation-ms",
+                status: "final",
+                code: { text: "BP" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Condition",
+                id: "condition-ms",
+                clinicalStatus: { coding: [{ code: "active" }] },
+                subject: { reference: "Patient/patient-ms" },
+                code: { text: "Hypertension" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Medication",
+                id: "medication-ms",
+                code: { text: "Lisinopril" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "MedicationStatement",
+                id: "medstatement-main",
+                status: "active",
+                medicationReference: { reference: "Medication/medication-ms" },
+                subject: { reference: "Patient/patient-ms" },
+                basedOn: [{ reference: "MedicationRequest/medrequest-ms" }],
+                partOf: [{ reference: "Observation/observation-ms" }],
+                derivedFrom: [{ reference: "Observation/observation-ms" }],
+                reasonReference: [{ reference: "Condition/condition-ms" }],
+            },
+        },
+    ],
+};
+describe("MedicationStatement new reference methods", () => {
+    it("getBasedOn resolves to MedicationRequest", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medStatementBundle);
+        const ms = sdk.getResourceById("medstatement-main");
+        const basedOn = ms?.getBasedOn?.();
+        expect(basedOn).toHaveLength(1);
+        expect(basedOn?.[0]?.resourceType).toBe("MedicationRequest");
+        expect(basedOn?.[0]?.id).toBe("medrequest-ms");
+    });
+    it("getPartOf resolves to Observation", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medStatementBundle);
+        const ms = sdk.getResourceById("medstatement-main");
+        const partOf = ms?.getPartOf?.();
+        expect(partOf).toHaveLength(1);
+        expect(partOf?.[0]?.resourceType).toBe("Observation");
+        expect(partOf?.[0]?.id).toBe("observation-ms");
+    });
+    it("getDerivedFrom resolves to Observation", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medStatementBundle);
+        const ms = sdk.getResourceById("medstatement-main");
+        const derived = ms?.getDerivedFrom?.();
+        expect(derived).toHaveLength(1);
+        expect(derived?.[0]?.resourceType).toBe("Observation");
+        expect(derived?.[0]?.id).toBe("observation-ms");
+    });
+    it("getReasonReferences resolves to Condition", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(medStatementBundle);
+        const ms = sdk.getResourceById("medstatement-main");
+        const reasons = ms?.getReasonReferences?.();
+        expect(reasons).toHaveLength(1);
+        expect(reasons?.[0]?.resourceType).toBe("Condition");
+        expect(reasons?.[0]?.id).toBe("condition-ms");
+    });
+});
+// ---------------------------------------------------------------------------
+// ServiceRequest
+// ---------------------------------------------------------------------------
+const serviceRequestBundle = {
+    resourceType: "Bundle",
+    type: "collection",
+    entry: [
+        {
+            resource: {
+                resourceType: "Patient",
+                id: "patient-sr",
+            },
+        },
+        {
+            resource: {
+                resourceType: "CarePlan",
+                id: "careplan-sr",
+                status: "active",
+                intent: "plan",
+                subject: { reference: "Patient/patient-sr" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "ServiceRequest",
+                id: "servicerequest-sr-replaced",
+                status: "revoked",
+                intent: "order",
+                subject: { reference: "Patient/patient-sr" },
+                code: { text: "Old blood test" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Location",
+                id: "location-sr",
+                name: "Lab",
+            },
+        },
+        {
+            resource: {
+                resourceType: "Condition",
+                id: "condition-sr",
+                clinicalStatus: { coding: [{ code: "active" }] },
+                subject: { reference: "Patient/patient-sr" },
+                code: { text: "Diabetes" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Observation",
+                id: "observation-sr",
+                status: "final",
+                code: { text: "Support info" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Specimen",
+                id: "specimen-sr",
+                status: "available",
+                type: { text: "Blood" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Provenance",
+                id: "provenance-sr",
+                recorded: "2024-01-01T00:00:00Z",
+                target: [],
+                agent: [],
+            },
+        },
+        {
+            resource: {
+                resourceType: "ServiceRequest",
+                id: "servicerequest-main",
+                status: "active",
+                intent: "order",
+                subject: { reference: "Patient/patient-sr" },
+                code: { text: "Blood glucose" },
+                basedOn: [{ reference: "CarePlan/careplan-sr" }],
+                replaces: [{ reference: "ServiceRequest/servicerequest-sr-replaced" }],
+                locationReference: [{ reference: "Location/location-sr" }],
+                reasonReference: [{ reference: "Condition/condition-sr" }],
+                supportingInfo: [{ reference: "Observation/observation-sr" }],
+                specimen: [{ reference: "Specimen/specimen-sr" }],
+                relevantHistory: [{ reference: "Provenance/provenance-sr" }],
+            },
+        },
+    ],
+};
+describe("ServiceRequest new reference methods", () => {
+    it("getBasedOn resolves to CarePlan", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(serviceRequestBundle);
+        const sr = sdk.getResourceById("servicerequest-main");
+        const basedOn = sr?.getBasedOn?.();
+        expect(basedOn).toHaveLength(1);
+        expect(basedOn?.[0]?.resourceType).toBe("CarePlan");
+        expect(basedOn?.[0]?.id).toBe("careplan-sr");
+    });
+    it("getReplaces resolves to ServiceRequest", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(serviceRequestBundle);
+        const sr = sdk.getResourceById("servicerequest-main");
+        const replaces = sr?.getReplaces?.();
+        expect(replaces).toHaveLength(1);
+        expect(replaces?.[0]?.resourceType).toBe("ServiceRequest");
+        expect(replaces?.[0]?.id).toBe("servicerequest-sr-replaced");
+    });
+    it("getLocationReferences resolves to Location", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(serviceRequestBundle);
+        const sr = sdk.getResourceById("servicerequest-main");
+        const locs = sr?.getLocationReferences?.();
+        expect(locs).toHaveLength(1);
+        expect(locs?.[0]?.resourceType).toBe("Location");
+        expect(locs?.[0]?.id).toBe("location-sr");
+    });
+    it("getReasonReferences resolves to Condition", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(serviceRequestBundle);
+        const sr = sdk.getResourceById("servicerequest-main");
+        const reasons = sr?.getReasonReferences?.();
+        expect(reasons).toHaveLength(1);
+        expect(reasons?.[0]?.resourceType).toBe("Condition");
+        expect(reasons?.[0]?.id).toBe("condition-sr");
+    });
+    it("getSupportingInfo resolves to Observation", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(serviceRequestBundle);
+        const sr = sdk.getResourceById("servicerequest-main");
+        const info = sr?.getSupportingInfo?.();
+        expect(info).toHaveLength(1);
+        expect(info?.[0]?.resourceType).toBe("Observation");
+        expect(info?.[0]?.id).toBe("observation-sr");
+    });
+    it("getSpecimens resolves to Specimen", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(serviceRequestBundle);
+        const sr = sdk.getResourceById("servicerequest-main");
+        const specimens = sr?.getSpecimens?.();
+        expect(specimens).toHaveLength(1);
+        expect(specimens?.[0]?.resourceType).toBe("Specimen");
+        expect(specimens?.[0]?.id).toBe("specimen-sr");
+    });
+    it("getRelevantHistory resolves to Provenance", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(serviceRequestBundle);
+        const sr = sdk.getResourceById("servicerequest-main");
+        const history = sr?.getRelevantHistory?.();
+        expect(history).toHaveLength(1);
+        expect(history?.[0]?.resourceType).toBe("Provenance");
+        expect(history?.[0]?.id).toBe("provenance-sr");
+    });
+});
+// ---------------------------------------------------------------------------
+// RiskAssessment
+// ---------------------------------------------------------------------------
+const riskAssessmentBundle = {
+    resourceType: "Bundle",
+    type: "collection",
+    entry: [
+        {
+            resource: {
+                resourceType: "Patient",
+                id: "patient-ra",
+            },
+        },
+        {
+            resource: {
+                resourceType: "Observation",
+                id: "observation-ra",
+                status: "final",
+                code: { text: "Risk basis" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "Condition",
+                id: "condition-ra",
+                clinicalStatus: { coding: [{ code: "active" }] },
+                subject: { reference: "Patient/patient-ra" },
+                code: { text: "Hypertension" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "DiagnosticReport",
+                id: "diagnosticreport-ra",
+                status: "final",
+                code: { text: "Lab panel" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "RiskAssessment",
+                id: "riskassessment-parent",
+                status: "final",
+                subject: { reference: "Patient/patient-ra" },
+                prediction: [],
+            },
+        },
+        {
+            resource: {
+                resourceType: "RiskAssessment",
+                id: "riskassessment-main",
+                status: "final",
+                subject: { reference: "Patient/patient-ra" },
+                prediction: [],
+                basedOn: { reference: "Observation/observation-ra" },
+                parent: { reference: "RiskAssessment/riskassessment-parent" },
+                condition: { reference: "Condition/condition-ra" },
+                reasonReference: [{ reference: "DiagnosticReport/diagnosticreport-ra" }],
+                basis: [{ reference: "Observation/observation-ra" }],
+            },
+        },
+    ],
+};
+describe("RiskAssessment new reference methods", () => {
+    it("getBasedOn resolves to Observation", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(riskAssessmentBundle);
+        const ra = sdk.getResourceById("riskassessment-main");
+        const basedOn = ra?.getBasedOn?.();
+        expect(basedOn?.resourceType).toBe("Observation");
+        expect(basedOn?.id).toBe("observation-ra");
+    });
+    it("getParent resolves to RiskAssessment", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(riskAssessmentBundle);
+        const ra = sdk.getResourceById("riskassessment-main");
+        const parent = ra?.getParent?.();
+        expect(parent?.resourceType).toBe("RiskAssessment");
+        expect(parent?.id).toBe("riskassessment-parent");
+    });
+    it("getCondition resolves to Condition", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(riskAssessmentBundle);
+        const ra = sdk.getResourceById("riskassessment-main");
+        const condition = ra?.getCondition?.();
+        expect(condition?.resourceType).toBe("Condition");
+        expect(condition?.id).toBe("condition-ra");
+    });
+    it("getReasonReferences resolves to DiagnosticReport", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(riskAssessmentBundle);
+        const ra = sdk.getResourceById("riskassessment-main");
+        const reasons = ra?.getReasonReferences?.();
+        expect(reasons).toHaveLength(1);
+        expect(reasons?.[0]?.resourceType).toBe("DiagnosticReport");
+        expect(reasons?.[0]?.id).toBe("diagnosticreport-ra");
+    });
+    it("getBasis resolves to Observation", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(riskAssessmentBundle);
+        const ra = sdk.getResourceById("riskassessment-main");
+        const basis = ra?.getBasis?.();
+        expect(basis).toHaveLength(1);
+        expect(basis?.[0]?.resourceType).toBe("Observation");
+        expect(basis?.[0]?.id).toBe("observation-ra");
+    });
+    it("returns undefined/empty for resources missing optional fields", async () => {
+        const sdk = await index_1.FhirBundleSdk.create({
+            resourceType: "Bundle",
+            type: "collection",
+            entry: [
+                {
+                    resource: {
+                        resourceType: "Patient",
+                        id: "patient-ra-min",
+                    },
+                },
+                {
+                    resource: {
+                        resourceType: "RiskAssessment",
+                        id: "riskassessment-min",
+                        status: "final",
+                        subject: { reference: "Patient/patient-ra-min" },
+                        prediction: [],
+                    },
+                },
+            ],
+        });
+        const ra = sdk.getResourceById("riskassessment-min");
+        expect(ra?.getBasedOn?.()).toBeUndefined();
+        expect(ra?.getParent?.()).toBeUndefined();
+        expect(ra?.getCondition?.()).toBeUndefined();
+        const reasonRef = ra?.getReasonReferences?.();
+        expect(reasonRef === undefined || reasonRef.length === 0).toBe(true);
+        const basis = ra?.getBasis?.();
+        expect(basis === undefined || basis.length === 0).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// FamilyMemberHistory
+// ---------------------------------------------------------------------------
+const familyMemberHistoryBundle = {
+    resourceType: "Bundle",
+    type: "collection",
+    entry: [
+        {
+            resource: {
+                resourceType: "Patient",
+                id: "patient-fmh",
+            },
+        },
+        {
+            resource: {
+                resourceType: "Condition",
+                id: "condition-fmh",
+                clinicalStatus: { coding: [{ code: "active" }] },
+                subject: { reference: "Patient/patient-fmh" },
+                code: { text: "Heart disease" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "AllergyIntolerance",
+                id: "allergy-fmh",
+                patient: { reference: "Patient/patient-fmh" },
+                clinicalStatus: { coding: [{ code: "active" }] },
+                code: { text: "Peanuts" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "QuestionnaireResponse",
+                id: "qr-fmh",
+                status: "completed",
+                questionnaire: "Questionnaire/family-history-q",
+                subject: { reference: "Patient/patient-fmh" },
+            },
+        },
+        {
+            resource: {
+                resourceType: "FamilyMemberHistory",
+                id: "fmh-main",
+                status: "completed",
+                patient: { reference: "Patient/patient-fmh" },
+                relationship: { coding: [{ code: "FTH", display: "Father" }] },
+                reasonReference: [
+                    { reference: "Condition/condition-fmh" },
+                    { reference: "AllergyIntolerance/allergy-fmh" },
+                    { reference: "QuestionnaireResponse/qr-fmh" },
+                ],
+            },
+        },
+    ],
+};
+describe("FamilyMemberHistory new reference methods", () => {
+    it("getReasonReferences resolves to multiple resource types", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(familyMemberHistoryBundle);
+        const fmh = sdk.getResourceById("fmh-main");
+        const reasons = fmh?.getReasonReferences?.();
+        expect(reasons).toHaveLength(3);
+        const types = reasons?.map(r => r.resourceType).sort();
+        expect(types).toEqual(["AllergyIntolerance", "Condition", "QuestionnaireResponse"]);
+    });
+    it("getReasonReferences resolves Condition correctly", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(familyMemberHistoryBundle);
+        const fmh = sdk.getResourceById("fmh-main");
+        const reasons = fmh?.getReasonReferences?.();
+        const condition = reasons?.find(r => r.resourceType === "Condition");
+        expect(condition?.id).toBe("condition-fmh");
+    });
+    it("getReasonReferences returns empty array when not set", async () => {
+        const sdk = await index_1.FhirBundleSdk.create({
+            resourceType: "Bundle",
+            type: "collection",
+            entry: [
+                {
+                    resource: {
+                        resourceType: "Patient",
+                        id: "patient-fmh-min",
+                    },
+                },
+                {
+                    resource: {
+                        resourceType: "FamilyMemberHistory",
+                        id: "fmh-min",
+                        status: "completed",
+                        patient: { reference: "Patient/patient-fmh-min" },
+                        relationship: { coding: [{ code: "FTH" }] },
+                    },
+                },
+            ],
+        });
+        const fmh = sdk.getResourceById("fmh-min");
+        const reasons = fmh?.getReasonReferences?.();
+        expect(reasons === undefined || reasons.length === 0).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Coverage
+// ---------------------------------------------------------------------------
+const coverageBundle = {
+    resourceType: "Bundle",
+    type: "collection",
+    entry: [
+        {
+            resource: {
+                resourceType: "Patient",
+                id: "patient-cov",
+            },
+        },
+        {
+            resource: {
+                resourceType: "Contract",
+                id: "contract-cov",
+                status: "executed",
+            },
+        },
+        {
+            resource: {
+                resourceType: "Coverage",
+                id: "coverage-main",
+                status: "active",
+                beneficiary: { reference: "Patient/patient-cov" },
+                payor: [{ reference: "Patient/patient-cov" }],
+                contract: [{ reference: "Contract/contract-cov" }],
+            },
+        },
+    ],
+};
+describe("Coverage new reference methods", () => {
+    it("getContracts resolves to Contract", async () => {
+        const sdk = await index_1.FhirBundleSdk.create(coverageBundle);
+        const cov = sdk.getResourceById("coverage-main");
+        const contracts = cov?.getContracts?.();
+        expect(contracts).toHaveLength(1);
+        expect(contracts?.[0]?.resourceType).toBe("Contract");
+        expect(contracts?.[0]?.id).toBe("contract-cov");
+    });
+    it("getContracts returns empty array when not set", async () => {
+        const sdk = await index_1.FhirBundleSdk.create({
+            resourceType: "Bundle",
+            type: "collection",
+            entry: [
+                {
+                    resource: {
+                        resourceType: "Patient",
+                        id: "patient-cov-min",
+                    },
+                },
+                {
+                    resource: {
+                        resourceType: "Coverage",
+                        id: "coverage-min",
+                        status: "active",
+                        beneficiary: { reference: "Patient/patient-cov-min" },
+                        payor: [{ reference: "Patient/patient-cov-min" }],
+                    },
+                },
+            ],
+        });
+        const cov = sdk.getResourceById("coverage-min");
+        const contracts = cov?.getContracts?.();
+        expect(contracts === undefined || contracts.length === 0).toBe(true);
+    });
+});
+//# sourceMappingURL=audit-reference-methods.test.js.map