gdc-common-utils-ts 1.14.9 → 1.14.13

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

@@ -0,0 +1,35 @@
+// 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 '../models/interoperable-claims/document-reference-claims.js';
+import { requireClaim } from './convert-shared.js';
+export function documentReferenceFlatToFhirR4(claims) {
+    const subject = requireClaim(claims, DocumentReferenceClaim.Subject);
+    return {
+        resourceType: 'DocumentReference',
+        identifier: claims[DocumentReferenceClaim.Identifier] ? [{ value: claims[DocumentReferenceClaim.Identifier] }] : undefined,
+        subject: { reference: subject },
+        description: claims[DocumentReferenceClaim.Description],
+        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.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/convert/convert-encounter.d.ts

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

package/dist/convert/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 '../models/interoperable-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/convert/convert-flag.d.ts

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

package/dist/convert/convert-flag.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-flag.ts
+import { FlagClaim } from '../models/interoperable-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]) } : 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.PeriodStart]: period?.start,
+        [FlagClaim.PeriodEnd]: period?.end,
+    };
+}

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

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

package/dist/convert/convert-immunization.js

@@ -0,0 +1,56 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-immunization.ts
+import { ImmunizationClaim } from '../models/interoperable-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]) } : 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],
+        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,
+                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.DoseSequence]: protocolApplied?.doseNumberString,
+        [ImmunizationClaim.Subject]: referenceToValue(resource.patient),
+        [ImmunizationClaim.Note]: resource.note?.[0]?.text,
+    };
+}

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

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

package/dist/convert/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 '../models/interoperable-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/convert/convert-medication-statement.d.ts

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

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

@@ -0,0 +1,64 @@
+// 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 '../models/interoperable-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 effectiveDateTime = claims[MedicationStatementClaim.Effective];
+    const medicationText = claims[MedicationStatementClaim.MedicationText];
+    const medicationIdentifier = claims[MedicationStatementClaim.MedicationIdentifier];
+    const medicationSerialNumber = claims[MedicationStatementClaim.MedicationSerialNumber];
+    const medicationExpirationDate = claims[MedicationStatementClaim.MedicationExpirationDate];
+    const hasContainedMedication = Boolean(medicationIdentifier) || Boolean(medicationSerialNumber) || Boolean(medicationExpirationDate) || Boolean(medicationText);
+    const containedMedicationId = 'medication-contained-1';
+    const containedMedication = hasContainedMedication ? {
+        resourceType: 'Medication',
+        id: containedMedicationId,
+        identifier: medicationIdentifier ? [{ value: medicationIdentifier }] : undefined,
+        code: medicationText ? { text: medicationText } : undefined,
+        batch: medicationSerialNumber || medicationExpirationDate ? {
+            lotNumber: medicationSerialNumber,
+            expirationDate: medicationExpirationDate,
+        } : undefined,
+    } : undefined;
+    return {
+        resourceType: 'MedicationStatement',
+        identifier: claims[MedicationStatementClaim.Identifier] ? [{ value: claims[MedicationStatementClaim.Identifier] }] : undefined,
+        status,
+        subject: { reference: subject },
+        effectiveDateTime,
+        medicationCodeableConcept: claims[MedicationStatementClaim.Code]
+            ? { coding: codingFromValue(claims[MedicationStatementClaim.Code]) }
+            : (!hasContainedMedication && medicationText ? { text: medicationText } : undefined),
+        medicationReference: hasContainedMedication ? { reference: `#${containedMedicationId}` } : undefined,
+        contained: containedMedication ? [containedMedication] : undefined,
+        dosage: claims[MedicationStatementClaim.DosageInstruction] ? [{ text: claims[MedicationStatementClaim.DosageInstruction] }] : 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 containedMedicationText = containedMedication?.code?.text;
+    const batch = containedMedication?.batch;
+    const medicationCode = codingToValue(resource.medicationCodeableConcept?.coding?.[0]);
+    const medicationText = containedMedicationText || resource.medicationCodeableConcept?.text || undefined;
+    return {
+        [MedicationStatementClaim.Identifier]: resource.identifier?.[0]?.value,
+        [MedicationStatementClaim.Subject]: resource.subject?.reference,
+        [MedicationStatementClaim.Status]: resource.status,
+        [MedicationStatementClaim.Effective]: resource.effectiveDateTime,
+        [MedicationStatementClaim.Code]: medicationCode,
+        [MedicationStatementClaim.MedicationText]: medicationText,
+        [MedicationStatementClaim.Note]: resource.note?.[0]?.text,
+        [MedicationStatementClaim.DosageInstruction]: resource.dosage?.[0]?.text,
+        [MedicationStatementClaim.MedicationIdentifier]: containedMedicationIdentifier,
+        [MedicationStatementClaim.MedicationSerialNumber]: batch?.lotNumber,
+        [MedicationStatementClaim.MedicationExpirationDate]: batch?.expirationDate,
+    };
+}

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

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

package/dist/convert/convert-observation.js

@@ -0,0 +1,57 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// 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';
+export function observationFlatToFhirR4(claims) {
+    const subject = claims[ObservationClaim.Subject] ?? claims[ObservationClaim.Patient];
+    return {
+        resourceType: 'Observation',
+        identifier: claims[ObservationClaim.Identifier] ? [{ value: claims[ObservationClaim.Identifier] }] : undefined,
+        status: claims[ObservationClaim.Status],
+        category: claims[ObservationClaim.Category] ? claims[ObservationClaim.Category].split(',').map((value) => ({ coding: codingFromValue(value.trim()) })) : undefined,
+        code: claims[ObservationClaim.Code] ? { coding: codingFromValue(claims[ObservationClaim.Code]) } : undefined,
+        subject: subject ? { reference: subject } : undefined,
+        effectiveDateTime: claims[ObservationClaim.EffectiveDateTime] ?? claims[ObservationClaim.Date],
+        issued: claims[ObservationClaim.EffectiveDateTime] ? undefined : claims[ObservationClaim.Date],
+        performer: claims[ObservationClaim.Performer] ? claims[ObservationClaim.Performer].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        valueCodeableConcept: claims[ObservationClaim.ValueConcept] ? { coding: codingFromValue(claims[ObservationClaim.ValueConcept]) } : undefined,
+        valueDateTime: claims[ObservationClaim.ValueDate],
+        valueString: claims[ObservationClaim.ValueString],
+        note: claims[ObservationClaim.Note] ? [{ text: claims[ObservationClaim.Note] }] : undefined,
+        basedOn: claims[ObservationClaim.BasedOn] ? claims[ObservationClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        device: claims[ObservationClaim.Device] ? { reference: claims[ObservationClaim.Device] } : undefined,
+        encounter: claims[ObservationClaim.Encounter] ? { reference: claims[ObservationClaim.Encounter] } : undefined,
+        focus: claims[ObservationClaim.Focus] ? claims[ObservationClaim.Focus].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        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,
+        component: claims[ObservationClaim.ComponentCode] ? [{ code: { coding: codingFromValue(claims[ObservationClaim.ComponentCode]) } }] : undefined,
+    };
+}
+export function observationFhirR4ToFlat(resource) {
+    const valueCodeableConcept = resource.valueCodeableConcept;
+    const component = Array.isArray(resource.component) ? resource.component[0] : undefined;
+    return {
+        [ObservationClaim.BasedOn]: referenceListToCsv(resource.basedOn),
+        [ObservationClaim.Category]: codingListToCsv(resource.category?.flatMap((item) => item.coding || [])),
+        [ObservationClaim.Code]: codingToValue(resource.code?.coding?.[0]),
+        [ObservationClaim.Date]: resource.effectiveDateTime || resource.issued,
+        [ObservationClaim.Device]: referenceToValue(resource.device),
+        [ObservationClaim.Encounter]: referenceToValue(resource.encounter),
+        [ObservationClaim.Focus]: referenceListToCsv(resource.focus),
+        [ObservationClaim.HasMember]: referenceListToCsv(resource.hasMember),
+        [ObservationClaim.Identifier]: resource.identifier?.[0]?.value,
+        [ObservationClaim.Method]: codingToValue(resource.method?.coding?.[0]),
+        [ObservationClaim.Patient]: referenceToValue(resource.subject),
+        [ObservationClaim.Performer]: referenceListToCsv(resource.performer),
+        [ObservationClaim.Specimen]: referenceToValue(resource.specimen),
+        [ObservationClaim.Status]: resource.status,
+        [ObservationClaim.Subject]: referenceToValue(resource.subject),
+        [ObservationClaim.ValueConcept]: codingToValue(valueCodeableConcept?.coding?.[0]),
+        [ObservationClaim.ValueDate]: resource.valueDateTime,
+        [ObservationClaim.ValueString]: resource.valueString,
+        [ObservationClaim.ComponentCode]: codingToValue(component?.code?.coding?.[0]),
+        [ObservationClaim.Note]: resource.note?.[0]?.text,
+        [ObservationClaim.EffectiveDateTime]: resource.effectiveDateTime,
+    };
+}

package/dist/convert/convert-organization.d.ts

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

package/dist/convert/convert-organization.js

@@ -0,0 +1,39 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/convert/convert-organization.ts
+import { OrganizationClaim } from '../models/interoperable-claims/organization-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 organizationFlatToFhirR4(claims) {
+    return {
+        resourceType: 'Organization',
+        identifier: claims[OrganizationClaim.Identifier] ? [{ value: claims[OrganizationClaim.Identifier] }] : undefined,
+        active: claims[OrganizationClaim.Active] === undefined ? undefined : claims[OrganizationClaim.Active] === 'true',
+        type: claims[OrganizationClaim.Type] ? [{ coding: codingFromValue(claims[OrganizationClaim.Type]) }] : undefined,
+        name: claims[OrganizationClaim.Name],
+        alias: splitCsv(claims[OrganizationClaim.Alias]),
+        partOf: claims[OrganizationClaim.PartOf] ? { reference: claims[OrganizationClaim.PartOf] } : undefined,
+        telecom: splitCsv(claims[OrganizationClaim.Telecom]).map((value) => ({ value })),
+        address: claims[OrganizationClaim.Address] ? [{ text: claims[OrganizationClaim.Address] }] : undefined,
+    };
+}
+export function organizationFhirR4ToFlat(resource) {
+    const alias = resource.alias?.filter(Boolean);
+    const telecom = resource.telecom
+        ?.map((item) => item?.value)
+        .filter((item) => Boolean(item));
+    return {
+        [OrganizationClaim.Identifier]: resource.identifier?.[0]?.value,
+        [OrganizationClaim.Active]: resource.active === undefined ? undefined : String(resource.active),
+        [OrganizationClaim.Type]: codingToValue(resource.type?.[0]?.coding?.[0]),
+        [OrganizationClaim.Name]: resource.name,
+        [OrganizationClaim.Alias]: alias?.length ? alias.join(',') : undefined,
+        [OrganizationClaim.PartOf]: referenceToValue(resource.partOf),
+        [OrganizationClaim.Telecom]: telecom?.length ? telecom.join(',') : undefined,
+        [OrganizationClaim.Address]: resource.address?.[0]?.text,
+    };
+}

package/dist/convert/convert-procedure.d.ts

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

package/dist/convert/convert-procedure.js

@@ -0,0 +1,50 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-procedure.ts
+import { ProcedureClaim } from '../models/interoperable-claims/procedure-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+export function procedureFlatToFhirR4(claims) {
+    const subject = claims[ProcedureClaim.Subject] ?? claims[ProcedureClaim.Patient];
+    return {
+        resourceType: 'Procedure',
+        identifier: claims[ProcedureClaim.Identifier] ? [{ value: claims[ProcedureClaim.Identifier] }] : undefined,
+        status: claims[ProcedureClaim.Status],
+        subject: subject ? { reference: subject } : undefined,
+        code: claims[ProcedureClaim.Code] ? { coding: codingFromValue(claims[ProcedureClaim.Code]) } : undefined,
+        performedDateTime: claims[ProcedureClaim.Date],
+        note: claims[ProcedureClaim.Note] ? [{ text: claims[ProcedureClaim.Note] }] : undefined,
+        basedOn: claims[ProcedureClaim.BasedOn] ? claims[ProcedureClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        bodySite: claims[ProcedureClaim.BodySite] ? [{ coding: codingFromValue(claims[ProcedureClaim.BodySite]) }] : undefined,
+        encounter: claims[ProcedureClaim.Encounter] ? { reference: claims[ProcedureClaim.Encounter] } : undefined,
+        instantiatesCanonical: claims[ProcedureClaim.InstantiatesCanonical] ? [claims[ProcedureClaim.InstantiatesCanonical]] : undefined,
+        instantiatesUri: claims[ProcedureClaim.InstantiatesUri] ? [claims[ProcedureClaim.InstantiatesUri]] : undefined,
+        location: claims[ProcedureClaim.Location] ? { reference: claims[ProcedureClaim.Location] } : undefined,
+        partOf: claims[ProcedureClaim.PartOf] ? claims[ProcedureClaim.PartOf].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        performer: claims[ProcedureClaim.Performer] ? claims[ProcedureClaim.Performer].split(',').map((reference) => ({ actor: { reference: reference.trim() } })) : undefined,
+        reasonCode: claims[ProcedureClaim.ReasonCode] ? [{ coding: codingFromValue(claims[ProcedureClaim.ReasonCode]) }] : undefined,
+        reasonReference: claims[ProcedureClaim.ReasonReference] ? claims[ProcedureClaim.ReasonReference].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+    };
+}
+export function procedureFhirR4ToFlat(resource) {
+    const performer = Array.isArray(resource.performer)
+        ? resource.performer.map((item) => referenceToValue(item?.actor)).filter((item) => Boolean(item))
+        : [];
+    return {
+        [ProcedureClaim.BasedOn]: referenceListToCsv(resource.basedOn),
+        [ProcedureClaim.BodySite]: codingToValue(resource.bodySite?.[0]?.coding?.[0]),
+        [ProcedureClaim.Code]: codingToValue(resource.code?.coding?.[0]),
+        [ProcedureClaim.Date]: resource.performedDateTime || resource.performedPeriod?.start,
+        [ProcedureClaim.Encounter]: referenceToValue(resource.encounter),
+        [ProcedureClaim.Identifier]: resource.identifier?.[0]?.value,
+        [ProcedureClaim.InstantiatesCanonical]: Array.isArray(resource.instantiatesCanonical) ? resource.instantiatesCanonical[0] : undefined,
+        [ProcedureClaim.InstantiatesUri]: Array.isArray(resource.instantiatesUri) ? resource.instantiatesUri[0] : undefined,
+        [ProcedureClaim.Location]: referenceToValue(resource.location),
+        [ProcedureClaim.PartOf]: referenceListToCsv(resource.partOf),
+        [ProcedureClaim.Patient]: referenceToValue(resource.subject),
+        [ProcedureClaim.Performer]: performer.length ? performer.join(',') : undefined,
+        [ProcedureClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
+        [ProcedureClaim.ReasonReference]: referenceListToCsv(resource.reasonReference),
+        [ProcedureClaim.Status]: resource.status,
+        [ProcedureClaim.Subject]: referenceToValue(resource.subject),
+        [ProcedureClaim.Note]: resource.note?.[0]?.text,
+    };
+}

package/dist/convert/convert-related-person.d.ts

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

package/dist/convert/convert-related-person.js

@@ -0,0 +1,31 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-related-person.ts
+import { RelatedPersonClaim } from '../models/interoperable-claims/related-person-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function relatedPersonFlatToFhirR4(claims) {
+    return {
+        resourceType: 'RelatedPerson',
+        identifier: claims[RelatedPersonClaim.Identifier] ? [{ value: claims[RelatedPersonClaim.Identifier] }] : undefined,
+        active: claims[RelatedPersonClaim.Active] === undefined ? undefined : claims[RelatedPersonClaim.Active] === 'true',
+        patient: claims[RelatedPersonClaim.Patient] ? { reference: claims[RelatedPersonClaim.Patient] } : undefined,
+        relationship: claims[RelatedPersonClaim.Relationship] ? [{ coding: codingFromValue(claims[RelatedPersonClaim.Relationship]) }] : undefined,
+        name: claims[RelatedPersonClaim.Name] ? [{ text: claims[RelatedPersonClaim.Name] }] : undefined,
+        telecom: claims[RelatedPersonClaim.Telecom] ? [{ value: claims[RelatedPersonClaim.Telecom] }] : undefined,
+        gender: claims[RelatedPersonClaim.Gender],
+        birthDate: claims[RelatedPersonClaim.BirthDate],
+        address: claims[RelatedPersonClaim.Address] ? [{ text: claims[RelatedPersonClaim.Address] }] : undefined,
+    };
+}
+export function relatedPersonFhirR4ToFlat(resource) {
+    return {
+        [RelatedPersonClaim.Identifier]: resource.identifier?.[0]?.value,
+        [RelatedPersonClaim.Active]: resource.active === undefined ? undefined : String(resource.active),
+        [RelatedPersonClaim.Patient]: referenceToValue(resource.patient),
+        [RelatedPersonClaim.Relationship]: codingToValue(resource.relationship?.[0]?.coding?.[0]),
+        [RelatedPersonClaim.Name]: resource.name?.[0]?.text,
+        [RelatedPersonClaim.Telecom]: resource.telecom?.[0]?.value,
+        [RelatedPersonClaim.Gender]: resource.gender,
+        [RelatedPersonClaim.BirthDate]: resource.birthDate,
+        [RelatedPersonClaim.Address]: resource.address?.[0]?.text,
+    };
+}

package/dist/convert/convert-shared.d.ts

@@ -0,0 +1,34 @@
+export type FlatClaims = Record<string, string | undefined>;
+export type FhirResource = Record<string, unknown> & {
+    resourceType: string;
+};
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function codingFromValue(value?: string): Array<{
+    system?: string;
+    code: string;
+}> | undefined;
+export declare function codingToValue(coding?: {
+    system?: string;
+    code?: string;
+}): string | undefined;
+export declare function referenceToValue(reference?: {
+    reference?: string;
+}): string | undefined;
+export declare function referenceListToCsv(references?: Array<{
+    reference?: string;
+}>): string | undefined;
+export declare function codingListToCsv(codings?: Array<{
+    system?: string;
+    code?: string;
+}>): string | undefined;
+export declare function requireClaim(claims: FlatClaims, key: string): string;
+export declare function requireSubjectIdentifier(value: string, key: string): void;
+export declare function requireDidWeb(value: string, key: string): void;
+/**
+ * Generic structural fallback for unsupported resources.
+ */
+export declare function fhirResourceToFlatClaims(resource: FhirResource, context?: string): FlatClaims;
+/**
+ * Generic structural regeneration for unsupported resources.
+ */
+export declare function flatClaimsToFhirResource(claims: FlatClaims): FhirResource;