gdc-common-utils-ts 1.14.10 → 1.14.13

package/dist/constants/fhir-resource-types.d.ts

@@ -8,19 +8,27 @@ export declare const ResourceTypesFhirR4: Readonly<{
     readonly AdverseEvent: "AdverseEvent";
     readonly AllergyIntolerance: "AllergyIntolerance";
     readonly Appointment: "Appointment";
+    readonly AppointmentResponse: "AppointmentResponse";
     readonly Bundle: "Bundle";
     readonly CarePlan: "CarePlan";
+    readonly ClinicalImpression: "ClinicalImpression";
     readonly Communication: "Communication";
     readonly Composition: "Composition";
     readonly Condition: "Condition";
     readonly Consent: "Consent";
+    readonly Coverage: "Coverage";
+    readonly Device: "Device";
+    readonly DeviceUseStatement: "DeviceUseStatement";
     readonly DiagnosticReport: "DiagnosticReport";
     readonly DocumentReference: "DocumentReference";
     readonly Encounter: "Encounter";
+    readonly Flag: "Flag";
     readonly ImagingStudy: "ImagingStudy";
     readonly Immunization: "Immunization";
+    readonly Location: "Location";
     readonly MedicationStatement: "MedicationStatement";
     readonly Observation: "Observation";
+    readonly Organization: "Organization";
     readonly Procedure: "Procedure";
     readonly RelatedPerson: "RelatedPerson";
 }>;
@@ -34,19 +42,27 @@ export declare const FhirResourceTypes: Readonly<{
     readonly AdverseEvent: "AdverseEvent";
     readonly AllergyIntolerance: "AllergyIntolerance";
     readonly Appointment: "Appointment";
+    readonly AppointmentResponse: "AppointmentResponse";
     readonly Bundle: "Bundle";
     readonly CarePlan: "CarePlan";
+    readonly ClinicalImpression: "ClinicalImpression";
     readonly Communication: "Communication";
     readonly Composition: "Composition";
     readonly Condition: "Condition";
     readonly Consent: "Consent";
+    readonly Coverage: "Coverage";
+    readonly Device: "Device";
+    readonly DeviceUseStatement: "DeviceUseStatement";
     readonly DiagnosticReport: "DiagnosticReport";
     readonly DocumentReference: "DocumentReference";
     readonly Encounter: "Encounter";
+    readonly Flag: "Flag";
     readonly ImagingStudy: "ImagingStudy";
     readonly Immunization: "Immunization";
+    readonly Location: "Location";
     readonly MedicationStatement: "MedicationStatement";
     readonly Observation: "Observation";
+    readonly Organization: "Organization";
     readonly Procedure: "Procedure";
     readonly RelatedPerson: "RelatedPerson";
 }>;

package/dist/constants/fhir-resource-types.js

@@ -8,19 +8,27 @@ export const ResourceTypesFhirR4 = Object.freeze({
     AdverseEvent: 'AdverseEvent',
     AllergyIntolerance: 'AllergyIntolerance',
     Appointment: 'Appointment',
+    AppointmentResponse: 'AppointmentResponse',
     Bundle: 'Bundle',
     CarePlan: 'CarePlan',
+    ClinicalImpression: 'ClinicalImpression',
     Communication: 'Communication',
     Composition: 'Composition',
     Condition: 'Condition',
     Consent: 'Consent',
+    Coverage: 'Coverage',
+    Device: 'Device',
+    DeviceUseStatement: 'DeviceUseStatement',
     DiagnosticReport: 'DiagnosticReport',
     DocumentReference: 'DocumentReference',
     Encounter: 'Encounter',
+    Flag: 'Flag',
     ImagingStudy: 'ImagingStudy',
     Immunization: 'Immunization',
+    Location: 'Location',
     MedicationStatement: 'MedicationStatement',
     Observation: 'Observation',
+    Organization: 'Organization',
     Procedure: 'Procedure',
     RelatedPerson: 'RelatedPerson',
 });

package/dist/convert/convert-allergy-intolerance.d.ts

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

package/dist/convert/convert-allergy-intolerance.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-allergy-intolerance.ts
+import { AllergyIntoleranceClaim } from '../models/interoperable-claims/allergy-intolerance-claims.js';
+import { codingFromValue, codingToValue, requireDidWeb, requireSubjectIdentifier } from './convert-shared.js';
+export function allergyIntoleranceFlatToFhirR4(claims) {
+    const patient = claims[AllergyIntoleranceClaim.Subject] ?? claims[AllergyIntoleranceClaim.Patient];
+    const recorder = claims[AllergyIntoleranceClaim.Recorder];
+    if (!patient)
+        throw new Error(`Missing required claim: ${AllergyIntoleranceClaim.Subject}`);
+    requireSubjectIdentifier(patient, AllergyIntoleranceClaim.Subject);
+    if (recorder)
+        requireDidWeb(recorder, AllergyIntoleranceClaim.Recorder);
+    return {
+        resourceType: 'AllergyIntolerance',
+        identifier: claims[AllergyIntoleranceClaim.Identifier] ? [{ value: claims[AllergyIntoleranceClaim.Identifier] }] : undefined,
+        patient: { reference: patient },
+        code: claims[AllergyIntoleranceClaim.Code] ? { coding: codingFromValue(claims[AllergyIntoleranceClaim.Code]) } : undefined,
+        clinicalStatus: claims[AllergyIntoleranceClaim.ClinicalStatus] ? { coding: [{ code: claims[AllergyIntoleranceClaim.ClinicalStatus] }] } : undefined,
+        verificationStatus: claims[AllergyIntoleranceClaim.VerificationStatus] ? { coding: [{ code: claims[AllergyIntoleranceClaim.VerificationStatus] }] } : undefined,
+        recorder: recorder ? { reference: recorder } : undefined,
+    };
+}
+export function allergyIntoleranceFhirR4ToFlat(resource) {
+    const subject = resource.patient?.reference;
+    return {
+        [AllergyIntoleranceClaim.Identifier]: resource.identifier?.[0]?.value,
+        [AllergyIntoleranceClaim.Subject]: subject,
+        [AllergyIntoleranceClaim.Patient]: subject,
+        [AllergyIntoleranceClaim.Code]: codingToValue(resource.code?.coding?.[0]),
+        [AllergyIntoleranceClaim.ClinicalStatus]: resource.clinicalStatus?.coding?.[0]?.code,
+        [AllergyIntoleranceClaim.VerificationStatus]: resource.verificationStatus?.coding?.[0]?.code,
+        [AllergyIntoleranceClaim.Recorder]: resource.recorder?.reference,
+    };
+}

package/dist/convert/convert-appointment-response.d.ts

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

package/dist/convert/convert-appointment-response.js

@@ -0,0 +1,32 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-appointment-response.ts
+import { AppointmentResponseClaim } from '../models/interoperable-claims/appointment-response-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function appointmentResponseFlatToFhirR4(claims) {
+    return {
+        resourceType: 'AppointmentResponse',
+        identifier: claims[AppointmentResponseClaim.Identifier] ? [{ value: claims[AppointmentResponseClaim.Identifier] }] : undefined,
+        appointment: claims[AppointmentResponseClaim.Appointment] ? { reference: claims[AppointmentResponseClaim.Appointment] } : undefined,
+        actor: claims[AppointmentResponseClaim.Actor] ? { reference: claims[AppointmentResponseClaim.Actor] } : undefined,
+        participantStatus: claims[AppointmentResponseClaim.ParticipantStatus],
+        participantType: claims[AppointmentResponseClaim.ParticipantType] ? [{ coding: codingFromValue(claims[AppointmentResponseClaim.ParticipantType]) }] : undefined,
+        start: claims[AppointmentResponseClaim.Start],
+        end: claims[AppointmentResponseClaim.End],
+        comment: claims[AppointmentResponseClaim.Comment],
+    };
+}
+export function appointmentResponseFhirR4ToFlat(resource) {
+    return {
+        [AppointmentResponseClaim.Actor]: referenceToValue(resource.actor),
+        [AppointmentResponseClaim.Appointment]: referenceToValue(resource.appointment),
+        [AppointmentResponseClaim.Comment]: resource.comment,
+        [AppointmentResponseClaim.Identifier]: resource.identifier?.[0]?.value,
+        [AppointmentResponseClaim.Start]: resource.start,
+        [AppointmentResponseClaim.End]: resource.end,
+        [AppointmentResponseClaim.ParticipantType]: codingToValue(resource.participantType?.[0]?.coding?.[0]),
+        [AppointmentResponseClaim.ParticipantStatus]: resource.participantStatus,
+        [AppointmentResponseClaim.Patient]: undefined,
+        [AppointmentResponseClaim.Practitioner]: undefined,
+        [AppointmentResponseClaim.Location]: undefined,
+    };
+}

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

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

package/dist/convert/convert-appointment.js

@@ -0,0 +1,61 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-appointment.ts
+import { AppointmentClaim } from '../models/interoperable-claims/appointment-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+export function appointmentFlatToFhirR4(claims) {
+    return {
+        resourceType: 'Appointment',
+        identifier: claims[AppointmentClaim.Identifier] ? [{ value: claims[AppointmentClaim.Identifier] }] : undefined,
+        status: claims[AppointmentClaim.Status],
+        serviceCategory: claims[AppointmentClaim.ServiceCategory] ? [{ coding: codingFromValue(claims[AppointmentClaim.ServiceCategory]) }] : undefined,
+        serviceType: claims[AppointmentClaim.ServiceType] ? [{ coding: codingFromValue(claims[AppointmentClaim.ServiceType]) }] : undefined,
+        specialty: claims[AppointmentClaim.Specialty] ? [{ coding: codingFromValue(claims[AppointmentClaim.Specialty]) }] : undefined,
+        appointmentType: claims[AppointmentClaim.AppointmentType] ? { coding: codingFromValue(claims[AppointmentClaim.AppointmentType]) } : undefined,
+        reasonCode: claims[AppointmentClaim.ReasonCode] ? [{ coding: codingFromValue(claims[AppointmentClaim.ReasonCode]) }] : undefined,
+        reasonReference: claims[AppointmentClaim.ReasonReference] ? claims[AppointmentClaim.ReasonReference].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        description: claims[AppointmentClaim.Description],
+        start: claims[AppointmentClaim.Start],
+        end: claims[AppointmentClaim.End],
+        minutesDuration: claims[AppointmentClaim.MinutesDuration] ? Number(claims[AppointmentClaim.MinutesDuration]) : undefined,
+        created: claims[AppointmentClaim.Created],
+        note: claims[AppointmentClaim.NoteText] ? [{ text: claims[AppointmentClaim.NoteText] }] : undefined,
+        patientInstruction: claims[AppointmentClaim.PatientInstruction],
+        basedOn: claims[AppointmentClaim.BasedOn] ? claims[AppointmentClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        participant: claims[AppointmentClaim.ParticipantActor]
+            ? claims[AppointmentClaim.ParticipantActor].split(',').map((reference) => ({
+                actor: { reference: reference.trim() },
+                status: claims[AppointmentClaim.ParticipantStatus],
+                type: claims[AppointmentClaim.ParticipantType] ? [{ coding: codingFromValue(claims[AppointmentClaim.ParticipantType]) }] : undefined,
+            }))
+            : undefined,
+    };
+}
+export function appointmentFhirR4ToFlat(resource) {
+    const participant = Array.isArray(resource.participant) ? resource.participant[0] : undefined;
+    return {
+        [AppointmentClaim.Identifier]: resource.identifier?.[0]?.value,
+        [AppointmentClaim.Status]: resource.status,
+        [AppointmentClaim.ServiceCategory]: codingToValue(resource.serviceCategory?.[0]?.coding?.[0]),
+        [AppointmentClaim.ServiceType]: codingToValue(resource.serviceType?.[0]?.coding?.[0]),
+        [AppointmentClaim.Specialty]: codingToValue(resource.specialty?.[0]?.coding?.[0]),
+        [AppointmentClaim.AppointmentType]: codingToValue(resource.appointmentType?.coding?.[0]),
+        [AppointmentClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
+        [AppointmentClaim.ReasonReference]: referenceListToCsv(resource.reasonReference),
+        [AppointmentClaim.Description]: resource.description,
+        [AppointmentClaim.Start]: resource.start,
+        [AppointmentClaim.End]: resource.end,
+        [AppointmentClaim.MinutesDuration]: resource.minutesDuration === undefined ? undefined : String(resource.minutesDuration),
+        [AppointmentClaim.Created]: resource.created,
+        [AppointmentClaim.NoteText]: resource.note?.[0]?.text,
+        [AppointmentClaim.PatientInstruction]: resource.patientInstruction,
+        [AppointmentClaim.BasedOn]: referenceListToCsv(resource.basedOn),
+        [AppointmentClaim.ParticipantActor]: Array.isArray(resource.participant)
+            ? resource.participant
+                .map((item) => referenceToValue(item?.actor))
+                .filter((item) => Boolean(item))
+                .join(',')
+            : undefined,
+        [AppointmentClaim.ParticipantStatus]: participant?.status,
+        [AppointmentClaim.ParticipantType]: codingToValue(participant?.type?.[0]?.coding?.[0]),
+    };
+}

package/dist/convert/convert-care-plan.d.ts

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

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

@@ -0,0 +1,58 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-care-plan.ts
+import { CarePlanClaim } from '../models/interoperable-claims/care-plan-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+export function carePlanFlatToFhirR4(claims) {
+    const subject = claims[CarePlanClaim.Subject] ?? claims[CarePlanClaim.Patient];
+    return {
+        resourceType: 'CarePlan',
+        identifier: claims[CarePlanClaim.Identifier] ? [{ value: claims[CarePlanClaim.Identifier] }] : undefined,
+        status: claims[CarePlanClaim.Status],
+        intent: claims[CarePlanClaim.Intent],
+        subject: subject ? { reference: subject } : undefined,
+        category: claims[CarePlanClaim.Category] ? [{ coding: codingFromValue(claims[CarePlanClaim.Category]) }] : undefined,
+        created: claims[CarePlanClaim.Date],
+        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,
+        addresses: claims[CarePlanClaim.Condition] ? claims[CarePlanClaim.Condition].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        encounter: claims[CarePlanClaim.Encounter] ? { reference: claims[CarePlanClaim.Encounter] } : undefined,
+        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]) ? [{
+                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,
+                },
+            }] : undefined,
+    };
+}
+export function carePlanFhirR4ToFlat(resource) {
+    const activity = Array.isArray(resource.activity) ? resource.activity[0] : undefined;
+    const detail = activity?.detail;
+    const period = resource.period;
+    return {
+        [CarePlanClaim.ActivityCode]: codingToValue(detail?.code?.coding?.[0]),
+        [CarePlanClaim.ActivityDate]: detail?.scheduledString,
+        [CarePlanClaim.ActivityReference]: referenceToValue(activity?.reference),
+        [CarePlanClaim.BasedOn]: referenceListToCsv(resource.basedOn),
+        [CarePlanClaim.CareTeam]: referenceListToCsv(resource.careTeam),
+        [CarePlanClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [CarePlanClaim.Condition]: referenceListToCsv(resource.addresses),
+        [CarePlanClaim.Date]: resource.created || period?.start,
+        [CarePlanClaim.Encounter]: referenceToValue(resource.encounter),
+        [CarePlanClaim.Goal]: referenceListToCsv(resource.goal),
+        [CarePlanClaim.Identifier]: resource.identifier?.[0]?.value,
+        [CarePlanClaim.Intent]: resource.intent,
+        [CarePlanClaim.PartOf]: referenceListToCsv(resource.partOf),
+        [CarePlanClaim.Patient]: referenceToValue(resource.subject),
+        [CarePlanClaim.Performer]: referenceListToCsv(detail?.performer),
+        [CarePlanClaim.Replaces]: referenceListToCsv(resource.replaces),
+        [CarePlanClaim.Status]: resource.status,
+        [CarePlanClaim.Subject]: referenceToValue(resource.subject),
+        [CarePlanClaim.Note]: resource.note?.[0]?.text,
+    };
+}

package/dist/convert/convert-clinical-impression.d.ts

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

package/dist/convert/convert-clinical-impression.js

@@ -0,0 +1,42 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-clinical-impression.ts
+import { ClinicalImpressionClaim } from '../models/interoperable-claims/clinical-impression-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+export function clinicalImpressionFlatToFhirR4(claims) {
+    return {
+        resourceType: 'ClinicalImpression',
+        identifier: claims[ClinicalImpressionClaim.Identifier] ? [{ value: claims[ClinicalImpressionClaim.Identifier] }] : undefined,
+        status: claims[ClinicalImpressionClaim.Status],
+        description: claims[ClinicalImpressionClaim.Description],
+        subject: claims[ClinicalImpressionClaim.Subject] ? { reference: claims[ClinicalImpressionClaim.Subject] } : undefined,
+        encounter: claims[ClinicalImpressionClaim.Encounter] ? { reference: claims[ClinicalImpressionClaim.Encounter] } : undefined,
+        effectiveDateTime: claims[ClinicalImpressionClaim.EffectiveDateTime],
+        date: claims[ClinicalImpressionClaim.Date],
+        assessor: claims[ClinicalImpressionClaim.Assessor] ? { reference: claims[ClinicalImpressionClaim.Assessor] } : undefined,
+        problem: claims[ClinicalImpressionClaim.Problem] ? claims[ClinicalImpressionClaim.Problem].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        finding: claims[ClinicalImpressionClaim.Finding] ? claims[ClinicalImpressionClaim.Finding].split(',').map((reference) => ({ itemReference: { reference: reference.trim() } })) : undefined,
+        prognosisCodeableConcept: claims[ClinicalImpressionClaim.PrognosisCode] ? [{ coding: codingFromValue(claims[ClinicalImpressionClaim.PrognosisCode]) }] : undefined,
+        summary: claims[ClinicalImpressionClaim.Summary],
+    };
+}
+export function clinicalImpressionFhirR4ToFlat(resource) {
+    return {
+        [ClinicalImpressionClaim.Identifier]: resource.identifier?.[0]?.value,
+        [ClinicalImpressionClaim.Status]: resource.status,
+        [ClinicalImpressionClaim.Description]: resource.description,
+        [ClinicalImpressionClaim.Subject]: referenceToValue(resource.subject),
+        [ClinicalImpressionClaim.Encounter]: referenceToValue(resource.encounter),
+        [ClinicalImpressionClaim.EffectiveDateTime]: resource.effectiveDateTime,
+        [ClinicalImpressionClaim.Date]: resource.date,
+        [ClinicalImpressionClaim.Assessor]: referenceToValue(resource.assessor),
+        [ClinicalImpressionClaim.Problem]: referenceListToCsv(resource.problem),
+        [ClinicalImpressionClaim.Finding]: Array.isArray(resource.finding)
+            ? resource.finding
+                .map((item) => referenceToValue(item?.itemReference))
+                .filter((item) => Boolean(item))
+                .join(',')
+            : undefined,
+        [ClinicalImpressionClaim.PrognosisCode]: codingToValue(resource.prognosisCodeableConcept?.[0]?.coding?.[0]),
+        [ClinicalImpressionClaim.Summary]: resource.summary,
+    };
+}

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

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

package/dist/convert/convert-composition.js

@@ -0,0 +1,35 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-composition.ts
+import { CompositionClaim } from '../models/interoperable-claims/composition-claims.js';
+import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
+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,
+        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 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.Date]: resource.date,
+        [CompositionClaim.Entry]: undefined,
+        [CompositionClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [CompositionClaim.Identifier]: resource.identifier?.value,
+        [CompositionClaim.Title]: resource.title,
+    };
+}

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

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

package/dist/convert/convert-condition.js

@@ -0,0 +1,24 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-condition.ts
+import { ConditionClaim } from '../models/interoperable-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]) } : undefined,
+        clinicalStatus: claims[ConditionClaim.ClinicalStatus] ? { coding: [{ code: claims[ConditionClaim.ClinicalStatus] }] } : undefined,
+        verificationStatus: claims[ConditionClaim.VerificationStatus] ? { coding: [{ code: claims[ConditionClaim.VerificationStatus] }] } : undefined,
+    };
+}
+export function conditionFhirR4ToFlat(resource) {
+    return {
+        [ConditionClaim.Identifier]: resource.identifier?.[0]?.value,
+        [ConditionClaim.Subject]: resource.subject?.reference,
+        [ConditionClaim.Code]: codingToValue(resource.code?.coding?.[0]),
+        [ConditionClaim.ClinicalStatus]: resource.clinicalStatus?.coding?.[0]?.code,
+        [ConditionClaim.VerificationStatus]: resource.verificationStatus?.coding?.[0]?.code,
+    };
+}

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

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

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

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

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

@@ -0,0 +1,28 @@
+// 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 '../models/interoperable-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 },
+        status,
+        recordedOn: claims[DeviceUseStatementClaim.RecordedOn],
+        timingDateTime: claims[DeviceUseStatementClaim.TimingDateTime],
+    };
+}
+export function deviceUseStatementFhirR4ToFlat(resource) {
+    return {
+        [DeviceUseStatementClaim.Identifier]: resource.identifier?.[0]?.value,
+        [DeviceUseStatementClaim.Subject]: resource.subject?.reference,
+        [DeviceUseStatementClaim.Device]: resource.device?.reference,
+        [DeviceUseStatementClaim.Status]: resource.status,
+        [DeviceUseStatementClaim.RecordedOn]: resource.recordedOn,
+        [DeviceUseStatementClaim.TimingDateTime]: resource.timingDateTime,
+    };
+}

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

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

package/dist/convert/convert-device.js

@@ -0,0 +1,37 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/convert-device.ts
+import { DeviceClaim } from '../models/interoperable-claims/device-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function deviceFlatToFhirR4(claims) {
+    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] ? { coding: codingFromValue(claims[DeviceClaim.Type]) } : 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.UdiCarrier]: resource.udiCarrier?.[0]?.carrierHRF,
+        [DeviceClaim.Url]: resource.url,
+    };
+}

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

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

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

@@ -0,0 +1,55 @@
+// 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 '../models/interoperable-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]) } : 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.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/convert/convert-document-reference.d.ts

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