fhir-data-utils-ts 0.2.4 → 0.3.1

package/dist/converters/convert-composition.js

@@ -0,0 +1,70 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-composition.ts
+import { CompositionClaim } from '../claims/composition-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue, requireClaim } from './convert-shared.js';
+function splitAlignedCsv(value) {
+    return value === undefined ? [] : value.split(',').map((item) => item.trim());
+}
+function attestersFromClaims(claims) {
+    const partyClaim = claims[CompositionClaim.Attester];
+    const modeClaim = claims[CompositionClaim.AttesterMode];
+    const timeClaim = claims[CompositionClaim.AttesterTime];
+    if (partyClaim === undefined && modeClaim === undefined && timeClaim === undefined)
+        return undefined;
+    const modes = splitAlignedCsv(requireClaim(claims, CompositionClaim.AttesterMode));
+    const parties = splitAlignedCsv(partyClaim);
+    const times = splitAlignedCsv(timeClaim);
+    if (modes.some((mode) => !mode) || parties.length > modes.length || times.length > modes.length) {
+        throw new Error('Composition attester claims must be positionally aligned with non-empty attester modes.');
+    }
+    return modes.map((mode, index) => ({
+        mode,
+        ...(parties[index] ? { party: { reference: parties[index] } } : {}),
+        ...(times[index] ? { time: times[index] } : {}),
+    }));
+}
+function alignedAttesterValue(attesters, select) {
+    if (attesters.length === 0)
+        return undefined;
+    return attesters.map((attester) => select(attester) || '').join(',');
+}
+export function compositionFlatToFhirR4(claims) {
+    return {
+        resourceType: 'Composition',
+        identifier: claims[CompositionClaim.Identifier] ? { value: claims[CompositionClaim.Identifier] } : undefined,
+        subject: claims[CompositionClaim.Subject] ? { reference: claims[CompositionClaim.Subject] } : undefined,
+        author: claims[CompositionClaim.Author] ? claims[CompositionClaim.Author].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        attester: attestersFromClaims(claims),
+        custodian: claims[CompositionClaim.Custodian] ? { reference: claims[CompositionClaim.Custodian] } : undefined,
+        date: claims[CompositionClaim.Date],
+        title: claims[CompositionClaim.Title],
+        type: claims[CompositionClaim.Type] ? { coding: codingFromValue(claims[CompositionClaim.Type]) } : undefined,
+        section: claims[CompositionClaim.Section]
+            ? claims[CompositionClaim.Section].split(',').map((value) => ({ code: { coding: codingFromValue(value.trim()) } }))
+            : undefined,
+    };
+}
+export function compositionFhirR4ToFlat(resource) {
+    const attesters = Array.isArray(resource.attester)
+        ? resource.attester
+        : [];
+    const sectionValues = Array.isArray(resource.section)
+        ? resource.section
+            .map((item) => codingToValue(item?.code?.coding?.[0]))
+            .filter((item) => Boolean(item))
+        : [];
+    return {
+        [CompositionClaim.Subject]: referenceToValue(resource.subject),
+        [CompositionClaim.Section]: sectionValues.length ? sectionValues.join(',') : undefined,
+        [CompositionClaim.Author]: referenceListToCsv(resource.author),
+        [CompositionClaim.Attester]: alignedAttesterValue(attesters, (attester) => attester.party?.reference),
+        [CompositionClaim.AttesterMode]: alignedAttesterValue(attesters, (attester) => attester.mode),
+        [CompositionClaim.AttesterTime]: alignedAttesterValue(attesters, (attester) => attester.time),
+        [CompositionClaim.Custodian]: referenceToValue(resource.custodian),
+        [CompositionClaim.Date]: resource.date,
+        [CompositionClaim.Entry]: undefined,
+        [CompositionClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [CompositionClaim.Identifier]: resource.identifier?.value,
+        [CompositionClaim.Title]: resource.title,
+    };
+}

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

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

package/dist/converters/convert-condition.js

@@ -0,0 +1,51 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-condition.ts
+import { ConditionClaim } from '../claims/condition-claims.js';
+import { codingFromValue, codingToValue, requireClaim } from './convert-shared.js';
+export function conditionFlatToFhirR4(claims) {
+    const subject = requireClaim(claims, ConditionClaim.Subject);
+    return {
+        resourceType: 'Condition',
+        identifier: claims[ConditionClaim.Identifier] ? [{ value: claims[ConditionClaim.Identifier] }] : undefined,
+        subject: { reference: subject },
+        code: claims[ConditionClaim.Code]
+            ? {
+                coding: codingFromValue(claims[ConditionClaim.Code])?.map((coding) => ({
+                    ...coding,
+                    ...(claims[ConditionClaim.CodeDisplay]
+                        ? { display: claims[ConditionClaim.CodeDisplay] }
+                        : {}),
+                })),
+                ...(claims[ConditionClaim.CodeText]
+                    ? { text: claims[ConditionClaim.CodeText] }
+                    : {}),
+            }
+            : 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) {
+    const code = resource.code;
+    return {
+        [ConditionClaim.Identifier]: resource.identifier?.[0]?.value,
+        [ConditionClaim.Subject]: resource.subject?.reference,
+        [ConditionClaim.Code]: codingToValue(code?.coding?.[0]) || code?.text,
+        [ConditionClaim.CodeText]: code?.text,
+        [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/converters/convert-consent.d.ts

@@ -0,0 +1,9 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+/** Converts native FHIR R4 Consent into the canonical flat claims contract. */
+export declare function consentFhirR4ToFlat(resource: FhirResource, context?: string): FlatClaims;
+/** Projects canonical Consent claims to native FHIR R4. ODRL stays in sourceAttachment. */
+export declare function consentFlatToFhirR4(claims: FlatClaims): FhirResource;
+/** Converts native FHIR R5 Consent into the same version-neutral flat claims contract. */
+export declare function consentFhirR5ToFlat(resource: FhirResource, context?: string): FlatClaims;
+/** Projects canonical Consent claims to native FHIR R5. ODRL stays in sourceAttachment. */
+export declare function consentFlatToFhirR5(claims: FlatClaims): FhirResource;

package/dist/converters/convert-consent.js

@@ -0,0 +1,174 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { ClaimConsent } from '../claims/consent-claims.js';
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+const firstReference = (value) => referenceToValue(value?.[0]);
+const conceptFromClaim = (value, display) => {
+    const coding = codingFromValue(value)?.map((item) => ({ ...item, ...(display ? { display } : {}) }));
+    return coding ? [{ coding }] : undefined;
+};
+const referencesFromClaim = (value) => value ? value.split(',').filter(Boolean).map((reference) => ({ reference })) : undefined;
+const codingsFromClaim = (value) => {
+    const codings = value?.split(',').filter(Boolean).flatMap((token) => codingFromValue(token) || []);
+    return codings?.length ? codings : undefined;
+};
+const codingsToClaim = (value) => {
+    const tokens = (value || []).map((coding) => codingToValue(coding)).filter(Boolean);
+    return tokens.length ? tokens.join(',') : undefined;
+};
+const conceptsToClaim = (value) => {
+    const tokens = (value || []).flatMap((concept) => concept.coding || []).map((coding) => codingToValue(coding)).filter(Boolean);
+    return tokens.length ? tokens.join(',') : undefined;
+};
+const conceptsFromClaim = (value, display) => codingsFromClaim(value)?.map((coding) => ({ coding: [{ ...coding, ...(display ? { display } : {}) }] }));
+const conceptWithCodingsFromClaim = (value) => {
+    const coding = codingsFromClaim(value);
+    return coding ? { coding } : undefined;
+};
+const attachmentFromClaims = (claims) => claims[ClaimConsent.attachmentContentType] || claims[ClaimConsent.attachmentData]
+    ? { contentType: claims[ClaimConsent.attachmentContentType], data: claims[ClaimConsent.attachmentData] }
+    : undefined;
+const periodFromClaims = (claims, start, end) => claims[start] || claims[end] ? { start: claims[start], end: claims[end] } : undefined;
+/** Converts native FHIR R4 Consent into the canonical flat claims contract. */
+export function consentFhirR4ToFlat(resource, context = 'org.hl7.fhir.api') {
+    const category = resource.category?.[0];
+    const provision = resource.provision;
+    const attachment = resource.sourceAttachment;
+    const scope = resource.scope;
+    const policyRule = resource.policyRule;
+    return {
+        '@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.periodStart]: provision?.period?.start,
+        [ClaimConsent.periodEnd]: provision?.period?.end,
+        [ClaimConsent.dataPeriodStart]: provision?.dataPeriod?.start,
+        [ClaimConsent.dataPeriodEnd]: provision?.dataPeriod?.end,
+        [ClaimConsent.grantor]: firstReference(resource.performer),
+        [ClaimConsent.grantee]: referenceToValue(provision?.actor?.[0]?.reference),
+        [ClaimConsent.manager]: firstReference(resource.organization),
+        [ClaimConsent.actorIdentifier]: referenceToValue(provision?.actor?.[0]?.reference),
+        [ClaimConsent.actorRole]: codingsToClaim(provision?.actor?.[0]?.role?.coding),
+        [ClaimConsent.action]: conceptsToClaim(provision?.action),
+        [ClaimConsent.purpose]: codingsToClaim(provision?.purpose),
+        [ClaimConsent.securityLabel]: codingsToClaim(provision?.securityLabel),
+        [ClaimConsent.resourceType]: codingsToClaim(provision?.class),
+        [ClaimConsent.provisionCode]: conceptsToClaim(provision?.code),
+        [ClaimConsent.provisionCodeDisplay]: provision?.code?.[0]?.coding?.[0]?.display,
+        [ClaimConsent.sourceReference]: referenceToValue(resource.sourceReference),
+        [ClaimConsent.attachmentContentType]: attachment?.contentType,
+        [ClaimConsent.attachmentData]: attachment?.data,
+        [ClaimConsent.category]: codingToValue(category?.coding?.[0]),
+        [ClaimConsent.categoryText]: category?.text,
+        [ClaimConsent.categoryDisplay]: category?.coding?.[0]?.display,
+        [ClaimConsent.scope]: codingToValue(scope?.coding?.[0]),
+        [ClaimConsent.scopeDisplay]: scope?.coding?.[0]?.display,
+        [ClaimConsent.policyRule]: codingToValue(policyRule?.coding?.[0]),
+    };
+}
+/** Projects canonical Consent claims to native FHIR R4. ODRL stays in sourceAttachment. */
+export function consentFlatToFhirR4(claims) {
+    const actorRole = conceptWithCodingsFromClaim(claims[ClaimConsent.actorRole]);
+    const actorReference = claims[ClaimConsent.grantee] || claims[ClaimConsent.actorIdentifier];
+    const provisionCode = conceptsFromClaim(claims[ClaimConsent.provisionCode], claims[ClaimConsent.provisionCodeDisplay]);
+    const attachment = attachmentFromClaims(claims);
+    return {
+        resourceType: ResourceTypesFhirR4.Consent,
+        identifier: claims[ClaimConsent.identifier] ? [{ value: claims[ClaimConsent.identifier] }] : undefined,
+        status: claims[ClaimConsent.status],
+        scope: conceptFromClaim(claims[ClaimConsent.scope], claims[ClaimConsent.scopeDisplay])?.[0],
+        category: conceptFromClaim(claims[ClaimConsent.category], claims[ClaimConsent.categoryDisplay]),
+        patient: claims[ClaimConsent.subject] || claims[ClaimConsent.patient] ? { reference: claims[ClaimConsent.subject] || claims[ClaimConsent.patient] } : undefined,
+        dateTime: claims[ClaimConsent.date],
+        performer: referencesFromClaim(claims[ClaimConsent.grantor]),
+        organization: referencesFromClaim(claims[ClaimConsent.manager]),
+        sourceAttachment: attachment,
+        sourceReference: claims[ClaimConsent.sourceReference] ? { reference: claims[ClaimConsent.sourceReference] } : undefined,
+        policyRule: conceptFromClaim(claims[ClaimConsent.policyRule])?.[0],
+        provision: {
+            type: claims[ClaimConsent.decision],
+            period: periodFromClaims(claims, ClaimConsent.periodStart, ClaimConsent.periodEnd),
+            actor: actorReference ? [{ role: actorRole, reference: { reference: actorReference } }] : undefined,
+            action: conceptsFromClaim(claims[ClaimConsent.action]),
+            purpose: codingsFromClaim(claims[ClaimConsent.purpose]),
+            securityLabel: codingsFromClaim(claims[ClaimConsent.securityLabel]),
+            class: codingsFromClaim(claims[ClaimConsent.resourceType]),
+            code: provisionCode,
+            dataPeriod: periodFromClaims(claims, ClaimConsent.dataPeriodStart, ClaimConsent.dataPeriodEnd),
+        },
+    };
+}
+/** Converts native FHIR R5 Consent into the same version-neutral flat claims contract. */
+export function consentFhirR5ToFlat(resource, context = 'org.hl7.fhir.api') {
+    const categories = resource.category;
+    const scopeConcept = categories?.find((item) => item.coding?.[0]?.system?.includes('consentscope'));
+    const categoryConcept = categories?.find((item) => item !== scopeConcept);
+    const provision = resource.provision?.[0];
+    const attachment = resource.sourceAttachment?.[0];
+    return {
+        '@context': context,
+        [ClaimConsent.identifier]: resource.identifier?.[0]?.value || resource.id,
+        [ClaimConsent.status]: resource.status,
+        [ClaimConsent.subject]: referenceToValue(resource.subject),
+        [ClaimConsent.date]: resource.date,
+        [ClaimConsent.decision]: resource.decision,
+        [ClaimConsent.periodStart]: resource.period?.start,
+        [ClaimConsent.periodEnd]: resource.period?.end,
+        [ClaimConsent.grantor]: firstReference(resource.grantor),
+        [ClaimConsent.grantee]: firstReference(resource.grantee),
+        [ClaimConsent.manager]: firstReference(resource.manager),
+        [ClaimConsent.controller]: firstReference(resource.controller),
+        [ClaimConsent.actorIdentifier]: referenceToValue(provision?.actor?.[0]?.reference) || firstReference(resource.grantee),
+        [ClaimConsent.actorRole]: codingsToClaim(provision?.actor?.[0]?.role?.coding),
+        [ClaimConsent.action]: conceptsToClaim(provision?.action),
+        [ClaimConsent.purpose]: codingsToClaim(provision?.purpose),
+        [ClaimConsent.securityLabel]: codingsToClaim(provision?.securityLabel),
+        [ClaimConsent.documentType]: codingsToClaim(provision?.documentType),
+        [ClaimConsent.resourceType]: codingsToClaim(provision?.resourceType),
+        [ClaimConsent.provisionCode]: conceptsToClaim(provision?.code),
+        [ClaimConsent.dataPeriodStart]: provision?.dataPeriod?.start,
+        [ClaimConsent.dataPeriodEnd]: provision?.dataPeriod?.end,
+        [ClaimConsent.attachmentContentType]: attachment?.contentType,
+        [ClaimConsent.attachmentData]: attachment?.data,
+        [ClaimConsent.sourceReference]: firstReference(resource.sourceReference),
+        [ClaimConsent.scope]: codingToValue(scopeConcept?.coding?.[0]),
+        [ClaimConsent.category]: codingToValue(categoryConcept?.coding?.[0] || categories?.[0]?.coding?.[0]),
+    };
+}
+/** Projects canonical Consent claims to native FHIR R5. ODRL stays in sourceAttachment. */
+export function consentFlatToFhirR5(claims) {
+    const category = conceptFromClaim(claims[ClaimConsent.category], claims[ClaimConsent.categoryDisplay]);
+    const scope = conceptFromClaim(claims[ClaimConsent.scope], claims[ClaimConsent.scopeDisplay]);
+    const actorReference = claims[ClaimConsent.grantee] || claims[ClaimConsent.actorIdentifier];
+    const attachment = attachmentFromClaims(claims);
+    return {
+        resourceType: ResourceTypesFhirR4.Consent,
+        identifier: claims[ClaimConsent.identifier] ? [{ value: claims[ClaimConsent.identifier] }] : undefined,
+        status: claims[ClaimConsent.status],
+        category: [...(scope || []), ...(category || [])],
+        subject: claims[ClaimConsent.subject] ? { reference: claims[ClaimConsent.subject] } : undefined,
+        date: claims[ClaimConsent.date],
+        period: periodFromClaims(claims, ClaimConsent.periodStart, ClaimConsent.periodEnd),
+        grantor: referencesFromClaim(claims[ClaimConsent.grantor]),
+        grantee: referencesFromClaim(claims[ClaimConsent.grantee] || claims[ClaimConsent.actorIdentifier]),
+        manager: referencesFromClaim(claims[ClaimConsent.manager]),
+        controller: referencesFromClaim(claims[ClaimConsent.controller]),
+        sourceAttachment: attachment ? [attachment] : undefined,
+        sourceReference: referencesFromClaim(claims[ClaimConsent.sourceReference]),
+        decision: claims[ClaimConsent.decision],
+        provision: [{
+                actor: actorReference ? [{ role: conceptWithCodingsFromClaim(claims[ClaimConsent.actorRole]), reference: { reference: actorReference } }] : undefined,
+                action: conceptsFromClaim(claims[ClaimConsent.action]),
+                securityLabel: codingsFromClaim(claims[ClaimConsent.securityLabel]),
+                purpose: codingsFromClaim(claims[ClaimConsent.purpose]),
+                documentType: codingsFromClaim(claims[ClaimConsent.documentType]),
+                resourceType: codingsFromClaim(claims[ClaimConsent.resourceType]),
+                code: conceptsFromClaim(claims[ClaimConsent.provisionCode], claims[ClaimConsent.provisionCodeDisplay]),
+                dataPeriod: periodFromClaims(claims, ClaimConsent.dataPeriodStart, ClaimConsent.dataPeriodEnd),
+            }],
+    };
+}

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

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

package/dist/converters/convert-coverage.js

@@ -0,0 +1,51 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-coverage.ts
+import { CoverageClaim } from '../claims/coverage-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+export function coverageFlatToFhirR4(claims) {
+    return {
+        resourceType: 'Coverage',
+        identifier: claims[CoverageClaim.Identifier] ? [{ value: claims[CoverageClaim.Identifier] }] : undefined,
+        status: claims[CoverageClaim.Status],
+        type: claims[CoverageClaim.Type] ? { coding: codingFromValue(claims[CoverageClaim.Type]) } : undefined,
+        policyHolder: claims[CoverageClaim.PolicyHolder] ? { reference: claims[CoverageClaim.PolicyHolder] } : undefined,
+        subscriber: claims[CoverageClaim.Subscriber] ? { reference: claims[CoverageClaim.Subscriber] } : undefined,
+        beneficiary: claims[CoverageClaim.Beneficiary] ? { reference: claims[CoverageClaim.Beneficiary] } : undefined,
+        relationship: claims[CoverageClaim.Relationship] ? { coding: codingFromValue(claims[CoverageClaim.Relationship]) } : undefined,
+        period: (claims[CoverageClaim.PeriodStart] || claims[CoverageClaim.PeriodEnd]) ? {
+            start: claims[CoverageClaim.PeriodStart],
+            end: claims[CoverageClaim.PeriodEnd],
+        } : undefined,
+        payor: claims[CoverageClaim.Payor] ? claims[CoverageClaim.Payor].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        class: claims[CoverageClaim.Class]
+            ? claims[CoverageClaim.Class].split(',').map((value) => {
+                const [type, val] = value.trim().split('|');
+                return { type: { text: type }, value: val ?? type };
+            })
+            : undefined,
+    };
+}
+export function coverageFhirR4ToFlat(resource) {
+    const classValues = Array.isArray(resource.class)
+        ? resource.class
+            .map((item) => {
+            const type = item?.type?.text;
+            const value = item?.value;
+            return type && value ? `${type}|${value}` : undefined;
+        })
+            .filter((item) => Boolean(item))
+        : [];
+    return {
+        [CoverageClaim.Identifier]: resource.identifier?.[0]?.value,
+        [CoverageClaim.Status]: resource.status,
+        [CoverageClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [CoverageClaim.PolicyHolder]: referenceToValue(resource.policyHolder),
+        [CoverageClaim.Subscriber]: referenceToValue(resource.subscriber),
+        [CoverageClaim.Beneficiary]: referenceToValue(resource.beneficiary),
+        [CoverageClaim.Relationship]: codingToValue(resource.relationship?.coding?.[0]),
+        [CoverageClaim.PeriodStart]: resource.period?.start,
+        [CoverageClaim.PeriodEnd]: resource.period?.end,
+        [CoverageClaim.Payor]: referenceListToCsv(resource.payor),
+        [CoverageClaim.Class]: classValues.length ? classValues.join(',') : undefined,
+    };
+}

package/dist/converters/convert-device-use-statement.d.ts

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

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

@@ -0,0 +1,36 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-device-use-statement.ts
+import { DeviceUseStatementClaim } from '../claims/device-use-statement-claims.js';
+import { requireClaim } from './convert-shared.js';
+export function deviceUseStatementFlatToFhirR4(claims) {
+    const subject = requireClaim(claims, DeviceUseStatementClaim.Subject);
+    const device = requireClaim(claims, DeviceUseStatementClaim.Device);
+    const status = requireClaim(claims, DeviceUseStatementClaim.Status);
+    return {
+        resourceType: 'DeviceUseStatement',
+        identifier: claims[DeviceUseStatementClaim.Identifier] ? [{ value: claims[DeviceUseStatementClaim.Identifier] }] : undefined,
+        subject: { reference: subject },
+        device: {
+            reference: device,
+            ...(claims[DeviceUseStatementClaim.DeviceDisplay]
+                ? { display: claims[DeviceUseStatementClaim.DeviceDisplay] }
+                : {}),
+        },
+        status,
+        recordedOn: claims[DeviceUseStatementClaim.RecordedOn] || claims[DeviceUseStatementClaim.RecordedOnLegacy],
+        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) {
+    return {
+        [DeviceUseStatementClaim.Identifier]: resource.identifier?.[0]?.value,
+        [DeviceUseStatementClaim.Subject]: resource.subject?.reference,
+        [DeviceUseStatementClaim.Device]: resource.device?.reference,
+        [DeviceUseStatementClaim.DeviceDisplay]: resource.device?.display,
+        [DeviceUseStatementClaim.Status]: resource.status,
+        [DeviceUseStatementClaim.RecordedOn]: resource.recordedOn,
+        [DeviceUseStatementClaim.TimingDateTime]: resource.timingDateTime,
+        [DeviceUseStatementClaim.TimingAbsentReason]: (resource._timingDateTime?.extension)?.[0]?.valueCode,
+    };
+}

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

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

package/dist/converters/convert-device.js

@@ -0,0 +1,48 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-device.ts
+import { DeviceClaim } from '../claims/device-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function deviceFlatToFhirR4(claims) {
+    const typeCoding = codingFromValue(claims[DeviceClaim.Type])?.map((coding) => ({
+        ...coding,
+        ...(claims[DeviceClaim.TypeDisplay] ? { display: claims[DeviceClaim.TypeDisplay] } : {}),
+    }));
+    return {
+        resourceType: 'Device',
+        identifier: claims[DeviceClaim.Identifier] ? [{ value: claims[DeviceClaim.Identifier] }] : undefined,
+        deviceName: claims[DeviceClaim.DeviceName] ? [{ name: claims[DeviceClaim.DeviceName] }] : undefined,
+        location: claims[DeviceClaim.Location] ? { reference: claims[DeviceClaim.Location] } : undefined,
+        manufacturer: claims[DeviceClaim.Manufacturer],
+        modelNumber: claims[DeviceClaim.Model],
+        owner: claims[DeviceClaim.Organization] ? { reference: claims[DeviceClaim.Organization] } : undefined,
+        patient: claims[DeviceClaim.Patient] ? { reference: claims[DeviceClaim.Patient] } : undefined,
+        serialNumber: claims[DeviceClaim.SerialNumber],
+        status: claims[DeviceClaim.Status],
+        type: claims[DeviceClaim.Type] || claims[DeviceClaim.TypeText] || claims[DeviceClaim.TypeDisplay]
+            ? {
+                ...(typeCoding ? { coding: typeCoding } : {}),
+                ...(claims[DeviceClaim.TypeText] ? { text: claims[DeviceClaim.TypeText] } : {}),
+            }
+            : undefined,
+        udiCarrier: claims[DeviceClaim.UdiCarrier] ? [{ carrierHRF: claims[DeviceClaim.UdiCarrier] }] : undefined,
+        url: claims[DeviceClaim.Url],
+    };
+}
+export function deviceFhirR4ToFlat(resource) {
+    return {
+        [DeviceClaim.DeviceName]: resource.deviceName?.[0]?.name,
+        [DeviceClaim.Identifier]: resource.identifier?.[0]?.value,
+        [DeviceClaim.Location]: referenceToValue(resource.location),
+        [DeviceClaim.Manufacturer]: resource.manufacturer,
+        [DeviceClaim.Model]: resource.modelNumber || resource.model,
+        [DeviceClaim.Organization]: referenceToValue(resource.owner),
+        [DeviceClaim.Patient]: referenceToValue(resource.patient),
+        [DeviceClaim.SerialNumber]: resource.serialNumber,
+        [DeviceClaim.Status]: resource.status,
+        [DeviceClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [DeviceClaim.TypeText]: resource.type?.text,
+        [DeviceClaim.TypeDisplay]: resource.type?.coding?.[0]?.display,
+        [DeviceClaim.UdiCarrier]: resource.udiCarrier?.[0]?.carrierHRF,
+        [DeviceClaim.Url]: resource.url,
+    };
+}

package/dist/converters/convert-diagnostic-report.d.ts

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

package/dist/converters/convert-diagnostic-report.js

@@ -0,0 +1,63 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-diagnostic-report.ts
+import { DiagnosticReportClaim } from '../claims/diagnostic-report-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+export function diagnosticReportFlatToFhirR4(claims) {
+    const subject = claims[DiagnosticReportClaim.Subject] ?? claims[DiagnosticReportClaim.Patient];
+    return {
+        resourceType: 'DiagnosticReport',
+        identifier: claims[DiagnosticReportClaim.Identifier] ? [{ value: claims[DiagnosticReportClaim.Identifier] }] : undefined,
+        status: claims[DiagnosticReportClaim.Status],
+        category: claims[DiagnosticReportClaim.Category] ? [{ coding: codingFromValue(claims[DiagnosticReportClaim.Category]) }] : undefined,
+        code: claims[DiagnosticReportClaim.Code] ? {
+            coding: codingFromValue(claims[DiagnosticReportClaim.Code])?.map((coding) => ({
+                ...coding,
+                ...(claims[DiagnosticReportClaim.CodeDisplay] ? { display: claims[DiagnosticReportClaim.CodeDisplay] } : {}),
+            })),
+            ...(claims[DiagnosticReportClaim.CodeText] ? { text: claims[DiagnosticReportClaim.CodeText] } : {}),
+        } : undefined,
+        subject: subject ? { reference: subject } : undefined,
+        encounter: claims[DiagnosticReportClaim.Encounter] ? { reference: claims[DiagnosticReportClaim.Encounter] } : undefined,
+        effectiveDateTime: claims[DiagnosticReportClaim.Date],
+        basedOn: claims[DiagnosticReportClaim.BasedOn] ? claims[DiagnosticReportClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        performer: claims[DiagnosticReportClaim.Performer] ? claims[DiagnosticReportClaim.Performer].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        result: claims[DiagnosticReportClaim.Result] ? claims[DiagnosticReportClaim.Result].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        resultsInterpreter: claims[DiagnosticReportClaim.ResultsInterpreter] ? claims[DiagnosticReportClaim.ResultsInterpreter].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        specimen: claims[DiagnosticReportClaim.Specimen] ? claims[DiagnosticReportClaim.Specimen].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        media: claims[DiagnosticReportClaim.Media] ? claims[DiagnosticReportClaim.Media].split(',').map((reference) => ({ link: { reference: reference.trim() } })) : undefined,
+        presentedForm: (claims[DiagnosticReportClaim.PresentedFormContentType] || claims[DiagnosticReportClaim.PresentedFormData] || claims[DiagnosticReportClaim.PresentedFormUrl]) ? [{
+                contentType: claims[DiagnosticReportClaim.PresentedFormContentType],
+                data: claims[DiagnosticReportClaim.PresentedFormData],
+                url: claims[DiagnosticReportClaim.PresentedFormUrl],
+            }] : undefined,
+    };
+}
+export function diagnosticReportFhirR4ToFlat(resource) {
+    const form = Array.isArray(resource.presentedForm) ? resource.presentedForm[0] : undefined;
+    const media = Array.isArray(resource.media)
+        ? resource.media
+            .map((item) => referenceToValue(item?.link))
+            .filter((item) => Boolean(item))
+        : [];
+    return {
+        [DiagnosticReportClaim.BasedOn]: referenceListToCsv(resource.basedOn),
+        [DiagnosticReportClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [DiagnosticReportClaim.Code]: codingToValue(resource.code?.coding?.[0]),
+        [DiagnosticReportClaim.CodeText]: resource.code?.text,
+        [DiagnosticReportClaim.CodeDisplay]: resource.code?.coding?.[0]?.display,
+        [DiagnosticReportClaim.Date]: resource.effectiveDateTime || resource.issued,
+        [DiagnosticReportClaim.Encounter]: referenceToValue(resource.encounter),
+        [DiagnosticReportClaim.Identifier]: resource.identifier?.[0]?.value,
+        [DiagnosticReportClaim.Media]: media.length ? media.join(',') : undefined,
+        [DiagnosticReportClaim.Patient]: referenceToValue(resource.subject),
+        [DiagnosticReportClaim.Performer]: referenceListToCsv(resource.performer),
+        [DiagnosticReportClaim.Result]: referenceListToCsv(resource.result),
+        [DiagnosticReportClaim.ResultsInterpreter]: referenceListToCsv(resource.resultsInterpreter),
+        [DiagnosticReportClaim.Specimen]: referenceListToCsv(resource.specimen),
+        [DiagnosticReportClaim.Status]: resource.status,
+        [DiagnosticReportClaim.Subject]: referenceToValue(resource.subject),
+        [DiagnosticReportClaim.PresentedFormContentType]: form?.contentType,
+        [DiagnosticReportClaim.PresentedFormData]: form?.data,
+        [DiagnosticReportClaim.PresentedFormUrl]: form?.url,
+    };
+}

package/dist/converters/convert-document-reference.d.ts

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

package/dist/converters/convert-document-reference.js

@@ -0,0 +1,54 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-document-reference.ts
+import { DocumentReferenceClaim } from '../claims/document-reference-claims.js';
+import { codingFromValue, codingToValue, requireClaim } from './convert-shared.js';
+export function documentReferenceFlatToFhirR4(claims) {
+    const subject = requireClaim(claims, DocumentReferenceClaim.Subject);
+    const typeCoding = codingFromValue(claims[DocumentReferenceClaim.Type])?.map((coding) => ({
+        ...coding,
+        ...(claims[DocumentReferenceClaim.TypeDisplay] ? { display: claims[DocumentReferenceClaim.TypeDisplay] } : {}),
+    }));
+    return {
+        resourceType: 'DocumentReference',
+        identifier: claims[DocumentReferenceClaim.Identifier] ? [{ value: claims[DocumentReferenceClaim.Identifier] }] : undefined,
+        subject: { reference: subject },
+        description: claims[DocumentReferenceClaim.Description],
+        category: claims[DocumentReferenceClaim.Category]
+            ? [{ coding: codingFromValue(claims[DocumentReferenceClaim.Category]) }]
+            : undefined,
+        type: claims[DocumentReferenceClaim.Type]
+            || claims[DocumentReferenceClaim.TypeText]
+            || claims[DocumentReferenceClaim.TypeDisplay]
+            ? {
+                ...(typeCoding ? { coding: typeCoding } : {}),
+                ...(claims[DocumentReferenceClaim.TypeText] ? { text: claims[DocumentReferenceClaim.TypeText] } : {}),
+            }
+            : undefined,
+        date: claims[DocumentReferenceClaim.Date],
+        content: [{ attachment: {
+                    contentType: claims[DocumentReferenceClaim.ContentType],
+                    data: claims[DocumentReferenceClaim.ContentData],
+                    url: claims[DocumentReferenceClaim.Location],
+                    hash: claims[DocumentReferenceClaim.ContentHash],
+                    language: claims[DocumentReferenceClaim.Language],
+                } }],
+    };
+}
+export function documentReferenceFhirR4ToFlat(resource) {
+    const attachment = resource.content?.[0]?.attachment;
+    return {
+        [DocumentReferenceClaim.Identifier]: resource.identifier?.[0]?.value,
+        [DocumentReferenceClaim.Subject]: resource.subject?.reference,
+        [DocumentReferenceClaim.Description]: resource.description,
+        [DocumentReferenceClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [DocumentReferenceClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [DocumentReferenceClaim.TypeText]: resource.type?.text,
+        [DocumentReferenceClaim.TypeDisplay]: resource.type?.coding?.[0]?.display,
+        [DocumentReferenceClaim.Date]: resource.date,
+        [DocumentReferenceClaim.ContentType]: attachment?.contentType,
+        [DocumentReferenceClaim.ContentData]: attachment?.data,
+        [DocumentReferenceClaim.Location]: attachment?.url,
+        [DocumentReferenceClaim.ContentHash]: attachment?.hash,
+        [DocumentReferenceClaim.Language]: attachment?.language,
+    };
+}

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

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