gdc-common-utils-ts 2.3.25 → 2.3.27

package/README.md

@@ -49,6 +49,11 @@ It is intentionally not a full backend orchestration layer.
   `Communication.topic`; the native projection may contain
   `Communication.topic.coding`, but `Communication.topic.coding` is not a
   claims key.
+- FHIR claims are version-independent FHIR API SearchParameter claims. Their
+  only context is `@context: org.hl7.fhir.api`; an expanded key is therefore
+  `org.hl7.fhir.api.<ResourceType>.<concrete-parameter>`. Never use
+  `org.hl7.fhir.r4.*` as a claim namespace: R4 identifies a native FHIR
+  resource representation, not the claims vocabulary.
 - Schema.org claims are a different vocabulary and preserve the canonical
   Schema.org camelCase property name.
 - Only define custom names when no canonical FHIR SearchParameter exists.

package/dist/convert/convert-care-plan.js

@@ -21,6 +21,8 @@ export function carePlanFlatToFhirR4(claims) {
                 }]
             : undefined,
         created: claims[CarePlanClaim.Date],
+        description: claims[CarePlanClaim.Description],
+        period: claims[CarePlanClaim.PeriodStart] || claims[CarePlanClaim.PeriodEnd] ? { start: claims[CarePlanClaim.PeriodStart], end: claims[CarePlanClaim.PeriodEnd] } : undefined,
         note: claims[CarePlanClaim.Note] ? [{ text: claims[CarePlanClaim.Note] }] : undefined,
         basedOn: claims[CarePlanClaim.BasedOn] ? claims[CarePlanClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
         careTeam: claims[CarePlanClaim.CareTeam] ? claims[CarePlanClaim.CareTeam].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
@@ -29,12 +31,22 @@ export function carePlanFlatToFhirR4(claims) {
         goal: claims[CarePlanClaim.Goal] ? claims[CarePlanClaim.Goal].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
         partOf: claims[CarePlanClaim.PartOf] ? claims[CarePlanClaim.PartOf].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
         replaces: claims[CarePlanClaim.Replaces] ? claims[CarePlanClaim.Replaces].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
-        activity: (claims[CarePlanClaim.ActivityCode] || claims[CarePlanClaim.ActivityDate] || claims[CarePlanClaim.ActivityReference] || claims[CarePlanClaim.Performer]) ? [{
+        activity: (claims[CarePlanClaim.ActivityCode] || claims[CarePlanClaim.ActivityDate] || claims[CarePlanClaim.ActivityReference] || claims[CarePlanClaim.Performer] || claims[CarePlanClaim.ActivityStatus]) ? [{
+                outcomeCodeableConcept: claims[CarePlanClaim.ActivityOutcome] ? [{ coding: codingFromValue(claims[CarePlanClaim.ActivityOutcome]) }] : undefined,
                 reference: claims[CarePlanClaim.ActivityReference] ? { reference: claims[CarePlanClaim.ActivityReference] } : undefined,
                 detail: {
                     code: claims[CarePlanClaim.ActivityCode] ? { coding: codingFromValue(claims[CarePlanClaim.ActivityCode]) } : undefined,
                     scheduledString: claims[CarePlanClaim.ActivityDate],
                     performer: claims[CarePlanClaim.Performer] ? claims[CarePlanClaim.Performer].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+                    status: claims[CarePlanClaim.ActivityStatus],
+                    statusReason: claims[CarePlanClaim.ActivityStatusReason] ? { text: claims[CarePlanClaim.ActivityStatusReason] } : undefined,
+                    doNotPerform: claims[CarePlanClaim.ActivityDoNotPerform] === undefined ? undefined : claims[CarePlanClaim.ActivityDoNotPerform] === 'true',
+                    scheduledTiming: claims[CarePlanClaim.ActivityTimingFrequency] || claims[CarePlanClaim.ActivityTimingPeriod] ? { repeat: {
+                            frequency: claims[CarePlanClaim.ActivityTimingFrequency] ? Number(claims[CarePlanClaim.ActivityTimingFrequency]) : undefined,
+                            period: claims[CarePlanClaim.ActivityTimingPeriod] ? Number(claims[CarePlanClaim.ActivityTimingPeriod]) : undefined,
+                            periodUnit: claims[CarePlanClaim.ActivityTimingPeriodUnit],
+                        } } : undefined,
+                    location: claims[CarePlanClaim.ActivityLocationDisplay] ? { display: claims[CarePlanClaim.ActivityLocationDisplay] } : undefined,
                 },
             }] : undefined,
     };
@@ -43,6 +55,7 @@ export function carePlanFhirR4ToFlat(resource) {
     const activity = Array.isArray(resource.activity) ? resource.activity[0] : undefined;
     const detail = activity?.detail;
     const period = resource.period;
+    const repeat = detail?.scheduledTiming?.repeat;
     return {
         [CarePlanClaim.ActivityCode]: codingToValue(detail?.code?.coding?.[0]),
         [CarePlanClaim.ActivityDate]: detail?.scheduledString,
@@ -65,5 +78,16 @@ export function carePlanFhirR4ToFlat(resource) {
         [CarePlanClaim.Status]: resource.status,
         [CarePlanClaim.Subject]: referenceToValue(resource.subject),
         [CarePlanClaim.Note]: resource.note?.[0]?.text,
+        [CarePlanClaim.Description]: resource.description,
+        [CarePlanClaim.PeriodStart]: period?.start,
+        [CarePlanClaim.PeriodEnd]: period?.end,
+        [CarePlanClaim.ActivityStatus]: detail?.status,
+        [CarePlanClaim.ActivityStatusReason]: detail?.statusReason?.text,
+        [CarePlanClaim.ActivityDoNotPerform]: detail?.doNotPerform === undefined ? undefined : String(detail.doNotPerform),
+        [CarePlanClaim.ActivityOutcome]: codingToValue(activity?.outcomeCodeableConcept?.[0]?.coding?.[0]),
+        [CarePlanClaim.ActivityLocationDisplay]: detail?.location?.display,
+        [CarePlanClaim.ActivityTimingFrequency]: repeat?.frequency === undefined ? undefined : String(repeat.frequency),
+        [CarePlanClaim.ActivityTimingPeriod]: repeat?.period === undefined ? undefined : String(repeat.period),
+        [CarePlanClaim.ActivityTimingPeriodUnit]: repeat?.periodUnit,
     };
 }

package/dist/convert/convert-condition.js

@@ -23,6 +23,12 @@ export function conditionFlatToFhirR4(claims) {
             : undefined,
         clinicalStatus: claims[ConditionClaim.ClinicalStatus] ? { coding: [{ code: claims[ConditionClaim.ClinicalStatus] }] } : undefined,
         verificationStatus: claims[ConditionClaim.VerificationStatus] ? { coding: [{ code: claims[ConditionClaim.VerificationStatus] }] } : undefined,
+        category: claims[ConditionClaim.Category] ? [{ coding: codingFromValue(claims[ConditionClaim.Category]) }] : undefined,
+        severity: claims[ConditionClaim.Severity] ? { coding: codingFromValue(claims[ConditionClaim.Severity]) } : undefined,
+        onsetDateTime: claims[ConditionClaim.OnsetDateTime],
+        recordedDate: claims[ConditionClaim.RecordedDate],
+        asserter: claims[ConditionClaim.Asserter] ? { reference: claims[ConditionClaim.Asserter] } : undefined,
+        recorder: claims[ConditionClaim.Recorder] ? { reference: claims[ConditionClaim.Recorder] } : undefined,
     };
 }
 export function conditionFhirR4ToFlat(resource) {
@@ -35,5 +41,11 @@ export function conditionFhirR4ToFlat(resource) {
         [ConditionClaim.CodeDisplay]: code?.coding?.[0]?.display,
         [ConditionClaim.ClinicalStatus]: resource.clinicalStatus?.coding?.[0]?.code,
         [ConditionClaim.VerificationStatus]: resource.verificationStatus?.coding?.[0]?.code,
+        [ConditionClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [ConditionClaim.Severity]: codingToValue(resource.severity?.coding?.[0]),
+        [ConditionClaim.OnsetDateTime]: resource.onsetDateTime,
+        [ConditionClaim.RecordedDate]: resource.recordedDate,
+        [ConditionClaim.Asserter]: resource.asserter?.reference,
+        [ConditionClaim.Recorder]: resource.recorder?.reference,
     };
 }

package/dist/convert/convert-consent.js

@@ -1,32 +1,78 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 import { ClaimConsent } from '../models/consent-rule.js';
-import { codingFromValue, codingToValue, fhirResourceToFlatClaims, flatClaimsToFhirResource, } from './convert-shared.js';
-export function consentFhirR4ToFlat(resource, context = 'org.hl7.fhir.r4') {
+import { codingFromValue, codingToValue, referenceToValue, } from './convert-shared.js';
+export function consentFhirR4ToFlat(resource, context = 'org.hl7.fhir.api') {
     const concept = resource.category?.[0];
+    const provision = resource.provision;
+    const scope = resource.scope;
+    const policyRule = resource.policyRule;
     return {
-        ...fhirResourceToFlatClaims(resource, context),
+        '@context': context,
+        [ClaimConsent.identifier]: resource.identifier?.[0]?.value
+            || resource.id,
+        [ClaimConsent.status]: resource.status,
+        [ClaimConsent.subject]: referenceToValue(resource.patient),
+        [ClaimConsent.patient]: referenceToValue(resource.patient),
+        [ClaimConsent.date]: resource.dateTime,
+        [ClaimConsent.decision]: provision?.type,
+        [ClaimConsent.action]: codingToValue(provision?.action?.[0]?.coding?.[0]),
+        [ClaimConsent.periodStart]: provision?.period?.start,
+        [ClaimConsent.periodEnd]: provision?.period?.end,
+        [ClaimConsent.purpose]: codingToValue(provision?.purpose?.[0]),
+        [ClaimConsent.sourceReference]: referenceToValue(resource.sourceReference),
         [ClaimConsent.category]: codingToValue(concept?.coding?.[0]),
         [ClaimConsent.categoryText]: concept?.text,
         [ClaimConsent.categoryDisplay]: concept?.coding?.[0]?.display,
+        [ClaimConsent.scope]: codingToValue(scope?.coding?.[0]),
+        [ClaimConsent.scopeDisplay]: scope?.coding?.[0]?.display,
+        [ClaimConsent.policyRule]: codingToValue(policyRule?.coding?.[0]),
+        [ClaimConsent.provisionCode]: codingToValue(provision?.code?.[0]?.coding?.[0]),
+        [ClaimConsent.provisionCodeDisplay]: provision?.code?.[0]?.coding?.[0]?.display,
     };
 }
 export function consentFlatToFhirR4(claims) {
-    const structuralClaims = { ...claims };
-    delete structuralClaims[ClaimConsent.category];
-    delete structuralClaims[ClaimConsent.categoryText];
-    delete structuralClaims[ClaimConsent.categoryDisplay];
-    const resource = flatClaimsToFhirResource(structuralClaims);
     const coding = codingFromValue(claims[ClaimConsent.category])?.map((item) => ({
         ...item,
         ...(claims[ClaimConsent.categoryDisplay]
             ? { display: claims[ClaimConsent.categoryDisplay] }
             : {}),
     }));
-    if (coding || claims[ClaimConsent.categoryText]) {
-        resource.category = [{
+    const actionCoding = codingFromValue(claims[ClaimConsent.action]);
+    const purposeCoding = codingFromValue(claims[ClaimConsent.purpose]);
+    const scopeCoding = codingFromValue(claims[ClaimConsent.scope])?.map((item) => ({ ...item, ...(claims[ClaimConsent.scopeDisplay] ? { display: claims[ClaimConsent.scopeDisplay] } : {}) }));
+    const provisionCodeCoding = codingFromValue(claims[ClaimConsent.provisionCode])?.map((item) => ({ ...item, ...(claims[ClaimConsent.provisionCodeDisplay] ? { display: claims[ClaimConsent.provisionCodeDisplay] } : {}) }));
+    return {
+        resourceType: 'Consent',
+        identifier: claims[ClaimConsent.identifier] ? [{ value: claims[ClaimConsent.identifier] }] : undefined,
+        status: claims[ClaimConsent.status],
+        scope: scopeCoding ? { coding: scopeCoding } : undefined,
+        policyRule: claims[ClaimConsent.policyRule] ? { coding: codingFromValue(claims[ClaimConsent.policyRule]) } : undefined,
+        patient: claims[ClaimConsent.subject] || claims[ClaimConsent.patient]
+            ? { reference: claims[ClaimConsent.subject] || claims[ClaimConsent.patient] }
+            : undefined,
+        dateTime: claims[ClaimConsent.date],
+        sourceReference: claims[ClaimConsent.sourceReference]
+            ? { reference: claims[ClaimConsent.sourceReference] }
+            : undefined,
+        category: coding || claims[ClaimConsent.categoryText] ? [{
                 ...(coding ? { coding } : {}),
                 ...(claims[ClaimConsent.categoryText] ? { text: claims[ClaimConsent.categoryText] } : {}),
-            }];
-    }
-    return resource;
+            }] : undefined,
+        provision: claims[ClaimConsent.decision]
+            || claims[ClaimConsent.periodStart]
+            || claims[ClaimConsent.periodEnd]
+            || actionCoding
+            || purposeCoding
+            || provisionCodeCoding
+            ? {
+                type: claims[ClaimConsent.decision],
+                period: claims[ClaimConsent.periodStart] || claims[ClaimConsent.periodEnd]
+                    ? { start: claims[ClaimConsent.periodStart], end: claims[ClaimConsent.periodEnd] }
+                    : undefined,
+                action: actionCoding ? [{ coding: actionCoding }] : undefined,
+                purpose: purposeCoding,
+                code: provisionCodeCoding ? [{ coding: provisionCodeCoding }] : undefined,
+            }
+            : undefined,
+    };
 }

package/dist/convert/convert-device-use-statement.js

@@ -17,8 +17,9 @@ export function deviceUseStatementFlatToFhirR4(claims) {
                 : {}),
         },
         status,
-        recordedOn: claims[DeviceUseStatementClaim.RecordedOn],
+        recordedOn: claims[DeviceUseStatementClaim.RecordedOn] || claims['DeviceUseStatement.recordedon'],
         timingDateTime: claims[DeviceUseStatementClaim.TimingDateTime],
+        _timingDateTime: claims[DeviceUseStatementClaim.TimingAbsentReason] ? { extension: [{ url: 'http://hl7.org/fhir/StructureDefinition/data-absent-reason', valueCode: claims[DeviceUseStatementClaim.TimingAbsentReason] }] } : undefined,
     };
 }
 export function deviceUseStatementFhirR4ToFlat(resource) {
@@ -30,5 +31,6 @@ export function deviceUseStatementFhirR4ToFlat(resource) {
         [DeviceUseStatementClaim.Status]: resource.status,
         [DeviceUseStatementClaim.RecordedOn]: resource.recordedOn,
         [DeviceUseStatementClaim.TimingDateTime]: resource.timingDateTime,
+        [DeviceUseStatementClaim.TimingAbsentReason]: (resource._timingDateTime?.extension)?.[0]?.valueCode,
     };
 }

package/dist/convert/convert-immunization.js

@@ -26,6 +26,8 @@ export function immunizationFlatToFhirR4(claims) {
         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,
@@ -34,7 +36,9 @@ export function immunizationFlatToFhirR4(claims) {
         protocolApplied: (claims[ImmunizationClaim.Series] || claims[ImmunizationClaim.TargetDisease] || claims[ImmunizationClaim.DoseSequence]) ? [{
                 series: claims[ImmunizationClaim.Series],
                 targetDisease: claims[ImmunizationClaim.TargetDisease] ? [{ coding: codingFromValue(claims[ImmunizationClaim.TargetDisease]) }] : undefined,
-                doseNumberString: claims[ImmunizationClaim.DoseSequence],
+                ...(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,
     };
@@ -63,8 +67,14 @@ export function immunizationFhirR4ToFlat(resource) {
         [ImmunizationClaim.VaccineCode]: codingToValue(resource.vaccineCode?.coding?.[0]),
         [ImmunizationClaim.VaccineCodeText]: resource.vaccineCode?.text,
         [ImmunizationClaim.VaccineCodeDisplay]: resource.vaccineCode?.coding?.[0]?.display,
-        [ImmunizationClaim.DoseSequence]: protocolApplied?.doseNumberString,
+        [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/convert/convert-medication-statement.js

@@ -22,6 +22,13 @@ export function medicationStatementFlatToFhirR4(claims) {
             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,
@@ -39,7 +46,21 @@ export function medicationStatementFlatToFhirR4(claims) {
             : (!hasContainedMedication && medicationText ? { text: medicationText } : undefined),
         medicationReference: hasContainedMedication ? { reference: `#${containedMedicationId}` } : undefined,
         contained: containedMedication ? [containedMedication] : undefined,
-        dosage: claims[MedicationStatementClaim.DosageInstruction] ? [{ text: claims[MedicationStatementClaim.DosageInstruction] }] : 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,
     };
 }
@@ -55,6 +76,12 @@ export function medicationStatementFhirR4ToFlat(resource) {
     const medicationConcept = resource.medicationCodeableConcept;
     const medicationCode = codingToValue(medicationConcept?.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);
     return {
         [MedicationStatementClaim.Identifier]: resource.identifier?.[0]?.value,
         [MedicationStatementClaim.Subject]: resource.subject?.reference,
@@ -65,6 +92,13 @@ export function medicationStatementFhirR4ToFlat(resource) {
         [MedicationStatementClaim.CodeDisplay]: medicationConcept?.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/convert/convert-observation.js

@@ -2,6 +2,8 @@
 // File: src/utils/convert-observation.ts
 import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
 import { codingFromValue, codingListToCsv, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+/** Legacy camelCase claim accepted only while reading previously persisted rows. */
+const LEGACY_OBSERVATION_EFFECTIVE_DATE_TIME = 'Observation.effectiveDateTime';
 /**
  * Converts flat editable Observation claims into a FHIR R4 Observation.
  *
@@ -33,6 +35,11 @@ export function observationFromFlatToFhirR4(claims) {
             ? { display: claims[ObservationClaim.ValueConceptDisplay] }
             : {}),
     }));
+    const componentCodes = splitClaimList(claims[ObservationClaim.ComponentCode]);
+    const componentDisplays = splitClaimList(claims[ObservationClaim.ComponentCodeDisplay]);
+    const componentNumbers = splitClaimList(claims[ObservationClaim.ComponentValueQuantityNumber]);
+    const componentUnits = splitClaimList(claims[ObservationClaim.ComponentValueQuantityUnit]);
+    const referenceUnit = claims[ObservationClaim.ReferenceRangeUnit];
     return {
         resourceType: 'Observation',
         identifier: claims[ObservationClaim.Identifier] ? [{ value: claims[ObservationClaim.Identifier] }] : undefined,
@@ -45,8 +52,12 @@ export function observationFromFlatToFhirR4(claims) {
             }
             : undefined,
         subject: subject ? { reference: subject } : undefined,
-        effectiveDateTime: claims[ObservationClaim.EffectiveDateTime] ?? claims[ObservationClaim.Date],
-        issued: claims[ObservationClaim.EffectiveDateTime] ? undefined : claims[ObservationClaim.Date],
+        effectiveDateTime: claims[ObservationClaim.EffectiveDateTime]
+            ?? claims[LEGACY_OBSERVATION_EFFECTIVE_DATE_TIME]
+            ?? claims[ObservationClaim.Date],
+        issued: claims[ObservationClaim.EffectiveDateTime] || claims[LEGACY_OBSERVATION_EFFECTIVE_DATE_TIME]
+            ? undefined
+            : claims[ObservationClaim.Date],
         performer: claims[ObservationClaim.Performer] ? claims[ObservationClaim.Performer].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
         valueCodeableConcept: valueConceptToken
             ? {
@@ -81,6 +92,17 @@ export function observationFromFlatToFhirR4(claims) {
         hasMember: claims[ObservationClaim.HasMember] ? claims[ObservationClaim.HasMember].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
         method: claims[ObservationClaim.Method] ? { coding: codingFromValue(claims[ObservationClaim.Method]) } : undefined,
         specimen: claims[ObservationClaim.Specimen] ? { reference: claims[ObservationClaim.Specimen] } : undefined,
+        referenceRange: claims[ObservationClaim.ReferenceRangeLowNumber] || claims[ObservationClaim.ReferenceRangeHighNumber] || claims[ObservationClaim.ReferenceRangeText]
+            ? [{
+                    low: claims[ObservationClaim.ReferenceRangeLowNumber] ? quantityFromClaims(claims[ObservationClaim.ReferenceRangeLowNumber], referenceUnit) : undefined,
+                    high: claims[ObservationClaim.ReferenceRangeHighNumber] ? quantityFromClaims(claims[ObservationClaim.ReferenceRangeHighNumber], referenceUnit) : undefined,
+                    text: claims[ObservationClaim.ReferenceRangeText],
+                }]
+            : undefined,
+        component: componentCodes.map((code, index) => ({
+            code: { coding: codingFromValue(code)?.map((coding) => ({ ...coding, ...(componentDisplays[index] ? { display: componentDisplays[index] } : {}) })) },
+            valueQuantity: componentNumbers[index] ? quantityFromClaims(componentNumbers[index], componentUnits[index]) : undefined,
+        })),
     };
 }
 /**
@@ -94,6 +116,10 @@ export function observationToFlatFhirR4(resource) {
     const codeCoding = resource.code?.coding?.[0];
     const valueConceptCoding = valueCodeableConcept?.coding?.[0];
     const valueQuantity = resource.valueQuantity;
+    const referenceRange = resource.referenceRange?.[0];
+    const referenceLow = referenceRange?.low;
+    const referenceHigh = referenceRange?.high;
+    const components = resource.component || [];
     return {
         [ObservationClaim.BasedOn]: referenceListToCsv(resource.basedOn),
         [ObservationClaim.Category]: codingListToCsv(resource.category?.flatMap((item) => item.coding || [])),
@@ -128,8 +154,23 @@ export function observationToFlatFhirR4(resource) {
         [ObservationClaim.ValueString]: resource.valueString,
         [ObservationClaim.Note]: resource.note?.[0]?.text,
         [ObservationClaim.EffectiveDateTime]: resource.effectiveDateTime,
+        [ObservationClaim.ReferenceRangeLowNumber]: scalarString(referenceLow?.value),
+        [ObservationClaim.ReferenceRangeHighNumber]: scalarString(referenceHigh?.value),
+        [ObservationClaim.ReferenceRangeUnit]: codingToValue(referenceLow?.system || referenceLow?.code ? { system: referenceLow?.system, code: referenceLow?.code } : referenceHigh?.system || referenceHigh?.code ? { system: referenceHigh?.system, code: referenceHigh?.code } : undefined) || referenceLow?.unit || referenceHigh?.unit,
+        [ObservationClaim.ReferenceRangeText]: referenceRange?.text,
+        [ObservationClaim.ComponentCode]: joinClaimList(components.map((component) => codingToValue(component.code?.coding?.[0]))),
+        [ObservationClaim.ComponentCodeDisplay]: joinClaimList(components.map((component) => component.code?.coding?.[0]?.display)),
+        [ObservationClaim.ComponentValueQuantityNumber]: joinClaimList(components.map((component) => scalarString(component.valueQuantity?.value))),
+        [ObservationClaim.ComponentValueQuantityUnit]: joinClaimList(components.map((component) => { const quantity = component.valueQuantity; return codingToValue(quantity?.system || quantity?.code ? { system: quantity?.system, code: quantity?.code } : undefined) || quantity?.unit; })),
     };
 }
+function splitClaimList(value) { return value ? JSON.parse(value) : []; }
+function joinClaimList(values) { return values.some((value) => value !== undefined) ? JSON.stringify(values.map((value) => value || '')) : undefined; }
+function scalarString(value) { return value === undefined || value === null ? undefined : String(value); }
+function quantityFromClaims(number, unit) {
+    const coding = codingFromValue(unit)?.[0];
+    return { value: Number(number), ...(unit ? { unit, ...(coding?.system ? { system: coding.system } : {}), ...(coding?.code ? { code: coding.code } : {}) } : {}) };
+}
 /** @deprecated Prefer `observationFromFlatToFhirR4`. */
 export const observationFlatToFhirR4 = observationFromFlatToFhirR4;
 /** @deprecated Prefer `observationToFlatFhirR4`. */

package/dist/convert/convert-practitioner-role.d.ts

@@ -1,3 +1,3 @@
 import type { FhirResource, FlatClaims } from './convert-shared';
-export declare function practitionerRoleFhirR4ToFlat(resource: FhirResource, context?: string): FlatClaims;
+export declare function practitionerRoleFhirR4ToFlat(resource: FhirResource, _context?: string): FlatClaims;
 export declare function practitionerRoleFlatToFhirR4(claims: FlatClaims): FhirResource;

package/dist/convert/convert-practitioner-role.js

@@ -1,34 +1,62 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 import { PractitionerRoleClaim } from '../models/interoperable-claims/practitioner-role-claims.js';
-import { codingFromValue, codingToValue, fhirResourceToFlatClaims, flatClaimsToFhirResource, } from './convert-shared.js';
-export function practitionerRoleFhirR4ToFlat(resource, context = 'org.hl7.fhir.r4') {
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue, } from './convert-shared.js';
+export function practitionerRoleFhirR4ToFlat(resource, _context = 'org.hl7.fhir.api') {
     const concept = resource.code?.[0];
     return {
-        ...fhirResourceToFlatClaims(resource, context),
+        [PractitionerRoleClaim.Identifier]: resource.identifier?.[0]?.value,
+        [PractitionerRoleClaim.Active]: resource.active === undefined ? undefined : String(resource.active),
+        [PractitionerRoleClaim.Practitioner]: referenceToValue(resource.practitioner),
+        [PractitionerRoleClaim.Organization]: referenceToValue(resource.organization),
+        [PractitionerRoleClaim.Location]: referenceListToCsv(resource.location),
+        [PractitionerRoleClaim.Service]: referenceListToCsv(resource.healthcareService),
+        [PractitionerRoleClaim.Specialty]: codingToValue(resource.specialty?.[0]?.coding?.[0]),
+        [PractitionerRoleClaim.PeriodStart]: resource.period?.start,
+        [PractitionerRoleClaim.PeriodEnd]: resource.period?.end,
         [PractitionerRoleClaim.Code]: codingToValue(concept?.coding?.[0]),
         [PractitionerRoleClaim.CodeText]: concept?.text,
         [PractitionerRoleClaim.CodeDisplay]: concept?.coding?.[0]?.display,
     };
 }
 export function practitionerRoleFlatToFhirR4(claims) {
-    const structuralClaims = { ...claims };
-    delete structuralClaims[PractitionerRoleClaim.Code];
-    delete structuralClaims[PractitionerRoleClaim.CodeText];
-    delete structuralClaims[PractitionerRoleClaim.CodeDisplay];
-    const resource = flatClaimsToFhirResource(structuralClaims);
+    const location = claims[PractitionerRoleClaim.Location]?.split(',').map((reference) => ({ reference: reference.trim() }));
+    const healthcareService = claims[PractitionerRoleClaim.Service]?.split(',').map((reference) => ({ reference: reference.trim() }));
     const coding = codingFromValue(claims[PractitionerRoleClaim.Code])?.map((item) => ({
         ...item,
         ...(claims[PractitionerRoleClaim.CodeDisplay]
             ? { display: claims[PractitionerRoleClaim.CodeDisplay] }
             : {}),
     }));
-    if (coding || claims[PractitionerRoleClaim.CodeText]) {
-        resource.code = [{
+    return {
+        resourceType: 'PractitionerRole',
+        identifier: claims[PractitionerRoleClaim.Identifier]
+            ? [{ value: claims[PractitionerRoleClaim.Identifier] }]
+            : undefined,
+        active: claims[PractitionerRoleClaim.Active] === undefined
+            ? undefined
+            : claims[PractitionerRoleClaim.Active] === 'true',
+        practitioner: claims[PractitionerRoleClaim.Practitioner]
+            ? { reference: claims[PractitionerRoleClaim.Practitioner] }
+            : undefined,
+        organization: claims[PractitionerRoleClaim.Organization]
+            ? { reference: claims[PractitionerRoleClaim.Organization] }
+            : undefined,
+        location,
+        healthcareService,
+        specialty: claims[PractitionerRoleClaim.Specialty]
+            ? [{ coding: codingFromValue(claims[PractitionerRoleClaim.Specialty]) }]
+            : undefined,
+        period: claims[PractitionerRoleClaim.PeriodStart] || claims[PractitionerRoleClaim.PeriodEnd]
+            ? {
+                start: claims[PractitionerRoleClaim.PeriodStart],
+                end: claims[PractitionerRoleClaim.PeriodEnd],
+            }
+            : undefined,
+        code: coding || claims[PractitionerRoleClaim.CodeText] ? [{
                 ...(coding ? { coding } : {}),
                 ...(claims[PractitionerRoleClaim.CodeText]
                     ? { text: claims[PractitionerRoleClaim.CodeText] }
                     : {}),
-            }];
-    }
-    return resource;
+            }] : undefined,
+    };
 }

package/dist/convert/convert-shared.js

@@ -139,7 +139,7 @@ function assignInflatedPath(target, path, value, typeHint) {
 /**
  * Generic structural fallback for unsupported resources.
  */
-export function fhirResourceToFlatClaims(resource, context = 'org.hl7.fhir.r4') {
+export function fhirResourceToFlatClaims(resource, context = 'org.hl7.fhir.api') {
     if (!resource?.resourceType) {
         throw new Error('FHIR resource must define resourceType.');
     }

package/dist/models/consent-rule.d.ts

@@ -1,11 +1,13 @@
 export declare enum ClaimConsent {
     'decision' = "Consent.decision",
+    'status' = "Consent.status",
     'action' = "Consent.action",
     'category' = "Consent.category",
     'categoryText' = "Consent.category-text",
     'categoryDisplay' = "Consent.category-display",
     'resourceType' = "Consent.resourceType",
     'subject' = "Consent.subject",
+    'patient' = "Consent.patient",
     'actorIdentifier' = "Consent.actor-identifier",
     'actorRole' = "Consent.actor-role",
     'date' = "Consent.date",
@@ -18,6 +20,11 @@ export declare enum ClaimConsent {
     'identifier' = "Consent.identifier",
     'eventBasedOn' = "Consent.event-basedon",
     'sourceReference' = "Consent.source-reference",
+    'scope' = "Consent.scope",
+    'scopeDisplay' = "Consent.scope-display",
+    'policyRule' = "Consent.policy-rule",
+    'provisionCode' = "Consent.provision-code",
+    'provisionCodeDisplay' = "Consent.provision-code-display",
     'containedReferenceList' = "Consent.contained-reference-list",
     /**
      * @deprecated Use `containedReferenceList`.

package/dist/models/consent-rule.js

@@ -2,12 +2,14 @@
 export var ClaimConsent;
 (function (ClaimConsent) {
     ClaimConsent["decision"] = "Consent.decision";
+    ClaimConsent["status"] = "Consent.status";
     ClaimConsent["action"] = "Consent.action";
     ClaimConsent["category"] = "Consent.category";
     ClaimConsent["categoryText"] = "Consent.category-text";
     ClaimConsent["categoryDisplay"] = "Consent.category-display";
     ClaimConsent["resourceType"] = "Consent.resourceType";
     ClaimConsent["subject"] = "Consent.subject";
+    ClaimConsent["patient"] = "Consent.patient";
     ClaimConsent["actorIdentifier"] = "Consent.actor-identifier";
     ClaimConsent["actorRole"] = "Consent.actor-role";
     ClaimConsent["date"] = "Consent.date";
@@ -20,6 +22,11 @@ export var ClaimConsent;
     ClaimConsent["identifier"] = "Consent.identifier";
     ClaimConsent["eventBasedOn"] = "Consent.event-basedon";
     ClaimConsent["sourceReference"] = "Consent.source-reference";
+    ClaimConsent["scope"] = "Consent.scope";
+    ClaimConsent["scopeDisplay"] = "Consent.scope-display";
+    ClaimConsent["policyRule"] = "Consent.policy-rule";
+    ClaimConsent["provisionCode"] = "Consent.provision-code";
+    ClaimConsent["provisionCodeDisplay"] = "Consent.provision-code-display";
     ClaimConsent["containedReferenceList"] = "Consent.contained-reference-list";
     /**
      * @deprecated Use `containedReferenceList`.

package/dist/models/indexing.d.ts

@@ -29,14 +29,14 @@ export declare const AllowedIndexableClaims: {
          * Keep this aligned with GW managers that build `indexed.attributes` from
          * claims-first payloads. UI-only or long free-text fields stay out.
          */
-        readonly General: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effectiveDateTime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.encounter", "Observation.device", "Observation.specimen", "Observation.performer", "Observation.based-on", "Observation.focus", "Observation.method", "Observation.language"];
+        readonly General: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effective-datetime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.encounter", "Observation.device", "Observation.specimen", "Observation.performer", "Observation.based-on", "Observation.focus", "Observation.method", "Observation.language"];
         /**
          * Searchable/indexable subset for a Vital Signs Observation row.
          *
          * This is intentionally narrower than the full persisted claims list and
          * excludes local-language labels, XHTML/narrative, and note text.
          */
-        readonly VitalSigns: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effectiveDateTime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.method", "Observation.language"];
+        readonly VitalSigns: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effective-datetime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.method", "Observation.language"];
     };
     readonly Condition: {
         readonly General: readonly ["Condition.identifier", "Condition.subject", "Condition.clinical-status", "Condition.verification-status", "Condition.category", "Condition.code", "Condition.severity", "Condition.onset-datetime", "Condition.recorder"];
@@ -58,8 +58,8 @@ export type AllowedIndexableClaimsKey = keyof typeof AllowedIndexableClaims;
  */
 export declare const AllowedIndexableClaimAliases: Readonly<{
     readonly organizationRegistry: readonly [ClaimsOrganizationSchemaorg.alternateName, ClaimsOrganizationSchemaorg.identifierValue, ClaimsOrganizationSchemaorg.identifierType, ClaimsOrganizationSchemaorg.addressCountry];
-    readonly observationGeneral: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effectiveDateTime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.encounter", "Observation.device", "Observation.specimen", "Observation.performer", "Observation.based-on", "Observation.focus", "Observation.method", "Observation.language"];
-    readonly observationVitalSigns: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effectiveDateTime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.method", "Observation.language"];
+    readonly observationGeneral: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effective-datetime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.encounter", "Observation.device", "Observation.specimen", "Observation.performer", "Observation.based-on", "Observation.focus", "Observation.method", "Observation.language"];
+    readonly observationVitalSigns: readonly ["Observation.identifier", "Observation.subject", "Observation.patient", "Observation.status", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code", "Observation.date", "Observation.effective-datetime", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.has-member", "Observation.method", "Observation.language"];
 }>;
 /**
  * Projects a claims-first record to the `ParameterData[]` shape used by GW/KMS