fhir-data-utils-ts 0.2.4 → 0.3.1

package/dist/converters/convert-encounter.js

@@ -0,0 +1,68 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-encounter.ts
+import { EncounterClaim } from '../claims/encounter-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function encounterFlatToFhirR4(claims) {
+    const subject = claims[EncounterClaim.Subject] ?? claims[EncounterClaim.Patient];
+    return {
+        resourceType: 'Encounter',
+        identifier: claims[EncounterClaim.Identifier] ? [{ value: claims[EncounterClaim.Identifier] }] : undefined,
+        status: claims[EncounterClaim.Status],
+        class: claims[EncounterClaim.Class]
+            ? (() => {
+                const [system, code] = claims[EncounterClaim.Class].split('|');
+                return code ? { system, code } : { code: system };
+            })()
+            : undefined,
+        type: claims[EncounterClaim.Type] ? [{ coding: codingFromValue(claims[EncounterClaim.Type]) }] : undefined,
+        subject: subject ? { reference: subject } : undefined,
+        participant: claims[EncounterClaim.Participant]
+            ? claims[EncounterClaim.Participant].split(',').map((reference) => ({ individual: { reference: reference.trim() } }))
+            : undefined,
+        serviceProvider: claims[EncounterClaim.ServiceProvider] ? { reference: claims[EncounterClaim.ServiceProvider] } : undefined,
+        period: (claims[EncounterClaim.PeriodStart] || claims[EncounterClaim.PeriodEnd]) ? {
+            start: claims[EncounterClaim.PeriodStart],
+            end: claims[EncounterClaim.PeriodEnd],
+        } : undefined,
+        reasonCode: claims[EncounterClaim.ReasonCode] ? [{ coding: codingFromValue(claims[EncounterClaim.ReasonCode]) }] : undefined,
+        diagnosis: claims[EncounterClaim.Diagnosis]
+            ? claims[EncounterClaim.Diagnosis].split(',').map((reference) => ({ condition: { reference: reference.trim() } }))
+            : undefined,
+        location: claims[EncounterClaim.Location]
+            ? claims[EncounterClaim.Location].split(',').map((reference) => ({ location: { reference: reference.trim() } }))
+            : undefined,
+    };
+}
+export function encounterFhirR4ToFlat(resource) {
+    const klass = resource.class;
+    return {
+        [EncounterClaim.Identifier]: resource.identifier?.[0]?.value,
+        [EncounterClaim.Status]: resource.status,
+        [EncounterClaim.Class]: klass?.code ? (klass.system ? `${klass.system}|${klass.code}` : klass.code) : undefined,
+        [EncounterClaim.Type]: codingToValue(resource.type?.[0]?.coding?.[0]),
+        [EncounterClaim.Subject]: referenceToValue(resource.subject),
+        [EncounterClaim.Patient]: referenceToValue(resource.subject),
+        [EncounterClaim.Participant]: Array.isArray(resource.participant)
+            ? resource.participant
+                .map((item) => referenceToValue(item?.individual))
+                .filter((item) => Boolean(item))
+                .join(',')
+            : undefined,
+        [EncounterClaim.ServiceProvider]: referenceToValue(resource.serviceProvider),
+        [EncounterClaim.PeriodStart]: resource.period?.start,
+        [EncounterClaim.PeriodEnd]: resource.period?.end,
+        [EncounterClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
+        [EncounterClaim.Diagnosis]: Array.isArray(resource.diagnosis)
+            ? resource.diagnosis
+                .map((item) => referenceToValue(item?.condition))
+                .filter((item) => Boolean(item))
+                .join(',')
+            : undefined,
+        [EncounterClaim.Location]: Array.isArray(resource.location)
+            ? resource.location
+                .map((item) => referenceToValue(item?.location))
+                .filter((item) => Boolean(item))
+                .join(',')
+            : undefined,
+    };
+}

package/dist/converters/convert-flag.d.ts

@@ -0,0 +1,3 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+export declare function flagFlatToFhirR4(claims: FlatClaims): FhirResource;
+export declare function flagFhirR4ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-flag.js

@@ -0,0 +1,42 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-flag.ts
+import { FlagClaim } from '../claims/flag-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function flagFlatToFhirR4(claims) {
+    const subject = claims[FlagClaim.Subject] ?? claims[FlagClaim.Patient];
+    return {
+        resourceType: 'Flag',
+        identifier: claims[FlagClaim.Identifier] ? [{ value: claims[FlagClaim.Identifier] }] : undefined,
+        status: claims[FlagClaim.Status],
+        category: claims[FlagClaim.Category] ? { coding: codingFromValue(claims[FlagClaim.Category]) } : undefined,
+        code: claims[FlagClaim.Code] ? {
+            coding: codingFromValue(claims[FlagClaim.Code])?.map((coding) => ({
+                ...coding,
+                ...(claims[FlagClaim.CodeDisplay] ? { display: claims[FlagClaim.CodeDisplay] } : {}),
+            })),
+            ...(claims[FlagClaim.CodeText] ? { text: claims[FlagClaim.CodeText] } : {}),
+        } : undefined,
+        subject: subject ? { reference: subject } : undefined,
+        author: claims[FlagClaim.Author] ? { reference: claims[FlagClaim.Author] } : undefined,
+        encounter: claims[FlagClaim.Encounter] ? { reference: claims[FlagClaim.Encounter] } : undefined,
+        period: (claims[FlagClaim.PeriodStart] || claims[FlagClaim.PeriodEnd]) ? { start: claims[FlagClaim.PeriodStart], end: claims[FlagClaim.PeriodEnd] } : undefined,
+    };
+}
+export function flagFhirR4ToFlat(resource) {
+    const period = resource.period;
+    return {
+        [FlagClaim.Author]: referenceToValue(resource.author),
+        [FlagClaim.Date]: undefined,
+        [FlagClaim.Encounter]: referenceToValue(resource.encounter),
+        [FlagClaim.Identifier]: resource.identifier?.[0]?.value,
+        [FlagClaim.Patient]: referenceToValue(resource.subject),
+        [FlagClaim.Subject]: referenceToValue(resource.subject),
+        [FlagClaim.Status]: resource.status,
+        [FlagClaim.Category]: codingToValue(resource.category?.coding?.[0]),
+        [FlagClaim.Code]: codingToValue(resource.code?.coding?.[0]),
+        [FlagClaim.CodeText]: resource.code?.text,
+        [FlagClaim.CodeDisplay]: resource.code?.coding?.[0]?.display,
+        [FlagClaim.PeriodStart]: period?.start,
+        [FlagClaim.PeriodEnd]: period?.end,
+    };
+}

package/dist/converters/convert-immunization.d.ts

@@ -0,0 +1,3 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+export declare function immunizationFlatToFhirR4(claims: FlatClaims): FhirResource;
+export declare function immunizationFhirR4ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-immunization.js

@@ -0,0 +1,80 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-immunization.ts
+import { ImmunizationClaim } from '../claims/immunization-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function immunizationFlatToFhirR4(claims) {
+    const subject = claims[ImmunizationClaim.Subject] ?? claims[ImmunizationClaim.Patient];
+    return {
+        resourceType: 'Immunization',
+        identifier: claims[ImmunizationClaim.Identifier] ? [{ value: claims[ImmunizationClaim.Identifier] }] : undefined,
+        status: claims[ImmunizationClaim.Status],
+        vaccineCode: claims[ImmunizationClaim.VaccineCode]
+            ? {
+                coding: codingFromValue(claims[ImmunizationClaim.VaccineCode])?.map((coding) => ({
+                    ...coding,
+                    ...(claims[ImmunizationClaim.VaccineCodeDisplay]
+                        ? { display: claims[ImmunizationClaim.VaccineCodeDisplay] }
+                        : {}),
+                })),
+                ...(claims[ImmunizationClaim.VaccineCodeText]
+                    ? { text: claims[ImmunizationClaim.VaccineCodeText] }
+                    : {}),
+            }
+            : undefined,
+        patient: subject ? { reference: subject } : undefined,
+        occurrenceDateTime: claims[ImmunizationClaim.Date],
+        location: claims[ImmunizationClaim.Location] ? { reference: claims[ImmunizationClaim.Location] } : undefined,
+        manufacturer: claims[ImmunizationClaim.Manufacturer] ? { reference: claims[ImmunizationClaim.Manufacturer] } : undefined,
+        lotNumber: claims[ImmunizationClaim.LotNumber],
+        route: claims[ImmunizationClaim.Route] ? { coding: codingFromValue(claims[ImmunizationClaim.Route])?.map((coding) => ({ ...coding, ...(claims[ImmunizationClaim.RouteDisplay] ? { display: claims[ImmunizationClaim.RouteDisplay] } : {}) })) } : undefined,
+        site: claims[ImmunizationClaim.Site] ? { coding: codingFromValue(claims[ImmunizationClaim.Site])?.map((coding) => ({ ...coding, ...(claims[ImmunizationClaim.SiteDisplay] ? { display: claims[ImmunizationClaim.SiteDisplay] } : {}) })) } : undefined,
+        performer: claims[ImmunizationClaim.Performer] ? claims[ImmunizationClaim.Performer].split(',').map((reference) => ({ actor: { reference: reference.trim() } })) : undefined,
+        reasonCode: claims[ImmunizationClaim.ReasonCode] ? [{ coding: codingFromValue(claims[ImmunizationClaim.ReasonCode]) }] : undefined,
+        reasonReference: claims[ImmunizationClaim.ReasonReference] ? [{ reference: claims[ImmunizationClaim.ReasonReference] }] : undefined,
+        statusReason: claims[ImmunizationClaim.StatusReason] ? { coding: codingFromValue(claims[ImmunizationClaim.StatusReason]) } : undefined,
+        note: claims[ImmunizationClaim.Note] ? [{ text: claims[ImmunizationClaim.Note] }] : undefined,
+        protocolApplied: (claims[ImmunizationClaim.Series] || claims[ImmunizationClaim.TargetDisease] || claims[ImmunizationClaim.DoseSequence]) ? [{
+                series: claims[ImmunizationClaim.Series],
+                targetDisease: claims[ImmunizationClaim.TargetDisease] ? [{ coding: codingFromValue(claims[ImmunizationClaim.TargetDisease]) }] : undefined,
+                ...(claims[ImmunizationClaim.DoseSequence] && /^\d+$/.test(claims[ImmunizationClaim.DoseSequence])
+                    ? { doseNumberPositiveInt: Number(claims[ImmunizationClaim.DoseSequence]) }
+                    : { doseNumberString: claims[ImmunizationClaim.DoseSequence] }),
+            }] : undefined,
+        reaction: claims[ImmunizationClaim.ReactionDate] ? [{ date: claims[ImmunizationClaim.ReactionDate] }] : undefined,
+    };
+}
+export function immunizationFhirR4ToFlat(resource) {
+    const reaction = Array.isArray(resource.reaction) ? resource.reaction[0] : undefined;
+    const protocolApplied = Array.isArray(resource.protocolApplied) ? resource.protocolApplied[0] : undefined;
+    const performer = Array.isArray(resource.performer)
+        ? resource.performer.map((item) => referenceToValue(item?.actor)).filter((item) => Boolean(item))
+        : [];
+    return {
+        [ImmunizationClaim.Identifier]: resource.identifier?.[0]?.value,
+        [ImmunizationClaim.Date]: resource.occurrenceDateTime,
+        [ImmunizationClaim.Location]: referenceToValue(resource.location),
+        [ImmunizationClaim.LotNumber]: resource.lotNumber,
+        [ImmunizationClaim.Manufacturer]: referenceToValue(resource.manufacturer),
+        [ImmunizationClaim.Patient]: referenceToValue(resource.patient),
+        [ImmunizationClaim.Performer]: performer.length ? performer.join(',') : undefined,
+        [ImmunizationClaim.ReactionDate]: reaction?.date,
+        [ImmunizationClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
+        [ImmunizationClaim.ReasonReference]: referenceToValue(resource.reasonReference?.[0]),
+        [ImmunizationClaim.Series]: protocolApplied?.series,
+        [ImmunizationClaim.Status]: resource.status,
+        [ImmunizationClaim.StatusReason]: codingToValue(resource.statusReason?.coding?.[0]),
+        [ImmunizationClaim.TargetDisease]: codingToValue(protocolApplied?.targetDisease?.[0]?.coding?.[0]),
+        [ImmunizationClaim.VaccineCode]: codingToValue(resource.vaccineCode?.coding?.[0]),
+        [ImmunizationClaim.VaccineCodeText]: resource.vaccineCode?.text,
+        [ImmunizationClaim.VaccineCodeDisplay]: resource.vaccineCode?.coding?.[0]?.display,
+        [ImmunizationClaim.DoseSequence]: protocolApplied?.doseNumberPositiveInt === undefined
+            ? protocolApplied?.doseNumberString
+            : String(protocolApplied.doseNumberPositiveInt),
+        [ImmunizationClaim.Subject]: referenceToValue(resource.patient),
+        [ImmunizationClaim.Note]: resource.note?.[0]?.text,
+        [ImmunizationClaim.Route]: codingToValue(resource.route?.coding?.[0]),
+        [ImmunizationClaim.RouteDisplay]: resource.route?.coding?.[0]?.display,
+        [ImmunizationClaim.Site]: codingToValue(resource.site?.coding?.[0]),
+        [ImmunizationClaim.SiteDisplay]: resource.site?.coding?.[0]?.display,
+    };
+}

package/dist/converters/convert-location.d.ts

@@ -0,0 +1,3 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+export declare function locationFlatToFhirR4(claims: FlatClaims): FhirResource;
+export declare function locationFhirR4ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-location.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/convert/convert-location.ts
+import { LocationClaim } from '../claims/location-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+function splitCsv(value) {
+    return String(value || '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+export function locationFlatToFhirR4(claims) {
+    return {
+        resourceType: 'Location',
+        identifier: claims[LocationClaim.Identifier] ? [{ value: claims[LocationClaim.Identifier] }] : undefined,
+        status: claims[LocationClaim.Status],
+        name: claims[LocationClaim.Name],
+        description: claims[LocationClaim.Description],
+        type: claims[LocationClaim.Type] ? [{ coding: codingFromValue(claims[LocationClaim.Type]) }] : undefined,
+        mode: claims[LocationClaim.Mode],
+        telecom: splitCsv(claims[LocationClaim.Telecom]).map((value) => ({ value })),
+        address: claims[LocationClaim.Address] ? { text: claims[LocationClaim.Address] } : undefined,
+        physicalType: claims[LocationClaim.PhysicalType] ? { coding: codingFromValue(claims[LocationClaim.PhysicalType]) } : undefined,
+        managingOrganization: claims[LocationClaim.ManagingOrganization] ? { reference: claims[LocationClaim.ManagingOrganization] } : undefined,
+        partOf: claims[LocationClaim.PartOf] ? { reference: claims[LocationClaim.PartOf] } : undefined,
+    };
+}
+export function locationFhirR4ToFlat(resource) {
+    const telecom = resource.telecom
+        ?.map((item) => item?.value)
+        .filter((item) => Boolean(item));
+    return {
+        [LocationClaim.Identifier]: resource.identifier?.[0]?.value,
+        [LocationClaim.Status]: resource.status,
+        [LocationClaim.Name]: resource.name,
+        [LocationClaim.Description]: resource.description,
+        [LocationClaim.Type]: codingToValue(resource.type?.[0]?.coding?.[0]),
+        [LocationClaim.Mode]: resource.mode,
+        [LocationClaim.Telecom]: telecom?.length ? telecom.join(',') : undefined,
+        [LocationClaim.Address]: resource.address?.text,
+        [LocationClaim.PhysicalType]: codingToValue(resource.physicalType?.coding?.[0]),
+        [LocationClaim.ManagingOrganization]: referenceToValue(resource.managingOrganization),
+        [LocationClaim.PartOf]: referenceToValue(resource.partOf),
+    };
+}

package/dist/converters/convert-medication-statement.d.ts

@@ -0,0 +1,3 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+export declare function medicationStatementFlatToFhirR4(claims: FlatClaims): FhirResource;
+export declare function medicationStatementFhirR4ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-medication-statement.js

@@ -0,0 +1,130 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-medication-statement.ts
+import { MedicationStatementClaim } from '../claims/medication-statement-claims.js';
+import { codingFromValue, codingToValue, requireClaim } from './convert-shared.js';
+export function medicationStatementFlatToFhirR4(claims) {
+    const subject = requireClaim(claims, MedicationStatementClaim.Subject);
+    const status = requireClaim(claims, MedicationStatementClaim.Status);
+    const effectivePeriodEnd = claims[MedicationStatementClaim.EffectivePeriodEnd];
+    const effectivePeriodStart = claims[MedicationStatementClaim.EffectivePeriodStart]
+        || (effectivePeriodEnd ? claims[MedicationStatementClaim.Effective] : undefined);
+    const effectiveDateTime = effectivePeriodStart || effectivePeriodEnd
+        ? undefined
+        : claims[MedicationStatementClaim.Effective];
+    const medicationText = claims[MedicationStatementClaim.CodeText]
+        || claims[MedicationStatementClaim.MedicationText];
+    const medicationReference = claims[MedicationStatementClaim.Medication];
+    const medicationIdentifier = claims[MedicationStatementClaim.MedicationIdentifier];
+    const medicationSerialNumber = claims[MedicationStatementClaim.MedicationSerialNumber];
+    const medicationExpirationDate = claims[MedicationStatementClaim.MedicationExpirationDate];
+    const hasContainedMedication = Boolean(medicationIdentifier) || Boolean(medicationSerialNumber) || Boolean(medicationExpirationDate);
+    const containedMedicationId = 'medication-contained-1';
+    const containedMedication = hasContainedMedication ? {
+        resourceType: 'Medication',
+        id: containedMedicationId,
+        identifier: medicationIdentifier ? [{ value: medicationIdentifier }] : undefined,
+        code: claims[MedicationStatementClaim.Code] || medicationText ? {
+            coding: codingFromValue(claims[MedicationStatementClaim.Code])?.map((coding) => ({
+                ...coding,
+                ...(claims[MedicationStatementClaim.CodeDisplay] ? { display: claims[MedicationStatementClaim.CodeDisplay] } : {}),
+            })),
+            ...(medicationText ? { text: medicationText } : {}),
+        } : undefined,
+        batch: medicationSerialNumber || medicationExpirationDate ? {
+            lotNumber: medicationSerialNumber,
+            expirationDate: medicationExpirationDate,
+        } : undefined,
+    } : undefined;
+    const dosageRoute = claims[MedicationStatementClaim.DosageRoute];
+    const dosageFrequency = claims[MedicationStatementClaim.TimingFrequency];
+    const dosagePeriod = claims[MedicationStatementClaim.TimingPeriod];
+    const dosagePeriodUnit = claims[MedicationStatementClaim.TimingPeriodUnit];
+    const doseValue = claims[MedicationStatementClaim.DoseQuantityValue];
+    const doseUnit = claims[MedicationStatementClaim.DoseQuantityUnit];
+    const hasDosage = claims[MedicationStatementClaim.DosageInstruction] || dosageRoute || dosageFrequency || dosagePeriod || doseValue;
+    return {
+        resourceType: 'MedicationStatement',
+        identifier: claims[MedicationStatementClaim.Identifier] ? [{ value: claims[MedicationStatementClaim.Identifier] }] : undefined,
+        status,
+        subject: { reference: subject },
+        ...(effectiveDateTime ? { effectiveDateTime } : {}),
+        effectivePeriod: effectivePeriodStart || effectivePeriodEnd ? {
+            start: effectivePeriodStart,
+            end: effectivePeriodEnd,
+        } : undefined,
+        medicationCodeableConcept: !medicationReference && !hasContainedMedication && claims[MedicationStatementClaim.Code]
+            ? {
+                coding: codingFromValue(claims[MedicationStatementClaim.Code])?.map((coding) => ({
+                    ...coding,
+                    ...(claims[MedicationStatementClaim.CodeDisplay] ? { display: claims[MedicationStatementClaim.CodeDisplay] } : {}),
+                })),
+                ...(medicationText ? { text: medicationText } : {}),
+            }
+            : (!medicationReference && !hasContainedMedication && medicationText ? { text: medicationText } : undefined),
+        medicationReference: medicationReference
+            ? { reference: medicationReference }
+            : (hasContainedMedication ? { reference: `#${containedMedicationId}` } : undefined),
+        contained: containedMedication ? [containedMedication] : undefined,
+        informationSource: claims[MedicationStatementClaim.Source] ? { reference: claims[MedicationStatementClaim.Source] } : undefined,
+        dosage: hasDosage ? [{
+                text: claims[MedicationStatementClaim.DosageInstruction],
+                route: dosageRoute ? { coding: codingFromValue(dosageRoute) } : undefined,
+                timing: dosageFrequency || dosagePeriod || dosagePeriodUnit ? { repeat: {
+                        frequency: dosageFrequency ? Number(dosageFrequency) : undefined,
+                        period: dosagePeriod ? Number(dosagePeriod) : undefined,
+                        periodUnit: dosagePeriodUnit,
+                    } } : undefined,
+                doseAndRate: doseValue ? [{ doseQuantity: {
+                            value: Number(doseValue),
+                            unit: doseUnit,
+                            ...(codingFromValue(doseUnit)?.[0] || {}),
+                        } }] : undefined,
+            }] : undefined,
+        note: claims[MedicationStatementClaim.Note] ? [{ text: claims[MedicationStatementClaim.Note] }] : undefined,
+    };
+}
+export function medicationStatementFhirR4ToFlat(resource) {
+    const medicationReference = resource.medicationReference?.reference;
+    const containedResources = Array.isArray(resource.contained) ? resource.contained : [];
+    const containedMedication = medicationReference?.startsWith('#')
+        ? containedResources.find((item) => item?.resourceType === 'Medication' && String(item?.id || '') === medicationReference.slice(1))
+        : containedResources.find((item) => item?.resourceType === 'Medication');
+    const containedMedicationIdentifier = containedMedication?.identifier?.[0]?.value;
+    const containedMedicationConcept = containedMedication?.code;
+    const containedMedicationText = containedMedicationConcept?.text;
+    const batch = containedMedication?.batch;
+    const medicationConcept = resource.medicationCodeableConcept;
+    const medicationCode = codingToValue(medicationConcept?.coding?.[0] || containedMedicationConcept?.coding?.[0]);
+    const medicationText = containedMedicationText || medicationConcept?.text || undefined;
+    const dosage = resource.dosage?.[0];
+    const repeat = dosage?.timing
+        ? dosage.timing.repeat
+        : undefined;
+    const routeCoding = dosage?.route?.coding?.[0];
+    const doseQuantity = (dosage?.doseAndRate?.[0]?.doseQuantity);
+    const effectivePeriod = resource.effectivePeriod;
+    return {
+        [MedicationStatementClaim.Identifier]: resource.identifier?.[0]?.value,
+        [MedicationStatementClaim.Subject]: resource.subject?.reference,
+        [MedicationStatementClaim.Status]: resource.status,
+        [MedicationStatementClaim.Effective]: resource.effectiveDateTime,
+        [MedicationStatementClaim.EffectivePeriodStart]: effectivePeriod?.start,
+        [MedicationStatementClaim.EffectivePeriodEnd]: effectivePeriod?.end,
+        [MedicationStatementClaim.Code]: medicationCode,
+        [MedicationStatementClaim.CodeText]: medicationText,
+        [MedicationStatementClaim.Medication]: medicationReference?.startsWith('#') ? undefined : medicationReference,
+        [MedicationStatementClaim.CodeDisplay]: medicationConcept?.coding?.[0]?.display || containedMedicationConcept?.coding?.[0]?.display,
+        [MedicationStatementClaim.Note]: resource.note?.[0]?.text,
+        [MedicationStatementClaim.DosageInstruction]: resource.dosage?.[0]?.text,
+        [MedicationStatementClaim.Source]: resource.informationSource?.reference,
+        [MedicationStatementClaim.DosageRoute]: codingToValue(routeCoding),
+        [MedicationStatementClaim.DoseQuantityValue]: doseQuantity?.value === undefined ? undefined : String(doseQuantity.value),
+        [MedicationStatementClaim.DoseQuantityUnit]: codingToValue(doseQuantity?.system || doseQuantity?.code ? { system: doseQuantity?.system, code: doseQuantity?.code } : undefined) || doseQuantity?.unit,
+        [MedicationStatementClaim.TimingFrequency]: repeat?.frequency === undefined ? undefined : String(repeat.frequency),
+        [MedicationStatementClaim.TimingPeriod]: repeat?.period === undefined ? undefined : String(repeat.period),
+        [MedicationStatementClaim.TimingPeriodUnit]: repeat?.periodUnit,
+        [MedicationStatementClaim.MedicationIdentifier]: containedMedicationIdentifier,
+        [MedicationStatementClaim.MedicationSerialNumber]: batch?.lotNumber,
+        [MedicationStatementClaim.MedicationExpirationDate]: batch?.expirationDate,
+    };
+}

package/dist/converters/convert-observation.d.ts

@@ -0,0 +1,33 @@
+import { type FlatClaimResourceEntry } from '../flat-claim-resource-graph.js';
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+/**
+ * Converts flat editable Observation claims into a FHIR R4 Observation.
+ *
+ * Naming convention:
+ * - place the concrete FHIR version suffix at the end of the helper name
+ * - prefer `observationFromFlatToFhirR4` / `observationToFlatFhirR4`
+ * - avoid `observationFhirR4ToFlat`
+ */
+export declare function observationFromFlatToFhirR4(claims: FlatClaims): FhirResource;
+/**
+ * Converts a FHIR R4 Observation into the flat editable claims contract.
+ *
+ * `Observation.category` stays in `Observation.category`.
+ * Coded result values belong in `Observation.value-concept-*`.
+ */
+export declare function observationToFlatFhirR4(resource: FhirResource): FlatClaims;
+/**
+ * Flattens a native component Observation into a parent plus independently
+ * indexable reduced Observation entries. Membership belongs to the parent
+ * through `Observation.has-member`; child containment flags are never written.
+ */
+export declare function observationFhirR4ToFlatGraph(resource: FhirResource, options: Readonly<{
+    parentEntryId: string;
+    componentEntryIds?: readonly string[];
+}>): readonly FlatClaimResourceEntry[];
+/** Reconstructs a native FHIR R4 `Observation.component[]` from its flat graph. */
+export declare function observationFlatGraphToFhirR4(graph: readonly FlatClaimResourceEntry[], parentEntryId: string): FhirResource;
+/** @deprecated Prefer `observationFromFlatToFhirR4`. */
+export declare const observationFlatToFhirR4: typeof observationFromFlatToFhirR4;
+/** @deprecated Prefer `observationToFlatFhirR4`. */
+export declare const observationFhirR4ToFlat: typeof observationToFlatFhirR4;