fhir-data-utils-ts 0.2.4 → 0.3.1

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

@@ -0,0 +1,162 @@
+/**
+ * Canonical FHIR R4 `resourceType` names shared across GW and SDK packages.
+ *
+ * Use these constants instead of inline strings such as `"Observation"`
+ * or `"DocumentReference"` when building bundles, filters, or SDK facades.
+ */
+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 Group: "Group";
+    readonly ImagingStudy: "ImagingStudy";
+    readonly Immunization: "Immunization";
+    readonly ImmunizationRecommendation: "ImmunizationRecommendation";
+    readonly Invoice: "Invoice";
+    readonly Location: "Location";
+    readonly Medication: "Medication";
+    readonly MedicationAdministration: "MedicationAdministration";
+    readonly MedicationDispense: "MedicationDispense";
+    readonly MedicationRequest: "MedicationRequest";
+    readonly MedicationStatement: "MedicationStatement";
+    readonly Observation: "Observation";
+    readonly OperationOutcome: "OperationOutcome";
+    readonly Organization: "Organization";
+    readonly Parameters: "Parameters";
+    readonly Patient: "Patient";
+    readonly Person: "Person";
+    readonly Practitioner: "Practitioner";
+    readonly PractitionerRole: "PractitionerRole";
+    readonly Procedure: "Procedure";
+    readonly RelatedPerson: "RelatedPerson";
+    readonly ResearchStudy: "ResearchStudy";
+    readonly ResearchSubject: "ResearchSubject";
+    readonly Specimen: "Specimen";
+    readonly ServiceRequest: "ServiceRequest";
+    readonly Task: "Task";
+    readonly DetectedIssue: "DetectedIssue";
+}>;
+/** One canonical FHIR R4 `resourceType` value. */
+export type ResourceTypeFhirR4 = typeof ResourceTypesFhirR4[keyof typeof ResourceTypesFhirR4];
+/**
+ * Backwards-compatible alias for the former generic name.
+ *
+ * Prefer `ResourceTypesFhirR4` in new code so later R5/R6 catalogs can coexist
+ * without ambiguity.
+ */
+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 Group: "Group";
+    readonly ImagingStudy: "ImagingStudy";
+    readonly Immunization: "Immunization";
+    readonly ImmunizationRecommendation: "ImmunizationRecommendation";
+    readonly Invoice: "Invoice";
+    readonly Location: "Location";
+    readonly Medication: "Medication";
+    readonly MedicationAdministration: "MedicationAdministration";
+    readonly MedicationDispense: "MedicationDispense";
+    readonly MedicationRequest: "MedicationRequest";
+    readonly MedicationStatement: "MedicationStatement";
+    readonly Observation: "Observation";
+    readonly OperationOutcome: "OperationOutcome";
+    readonly Organization: "Organization";
+    readonly Parameters: "Parameters";
+    readonly Patient: "Patient";
+    readonly Person: "Person";
+    readonly Practitioner: "Practitioner";
+    readonly PractitionerRole: "PractitionerRole";
+    readonly Procedure: "Procedure";
+    readonly RelatedPerson: "RelatedPerson";
+    readonly ResearchStudy: "ResearchStudy";
+    readonly ResearchSubject: "ResearchSubject";
+    readonly Specimen: "Specimen";
+    readonly ServiceRequest: "ServiceRequest";
+    readonly Task: "Task";
+    readonly DetectedIssue: "DetectedIssue";
+}>;
+/** FHIR R5-only resources currently emitted by shared subscription contracts. */
+export declare const ResourceTypesFhirR5: Readonly<{
+    readonly SubscriptionStatus: "SubscriptionStatus";
+    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 Group: "Group";
+    readonly ImagingStudy: "ImagingStudy";
+    readonly Immunization: "Immunization";
+    readonly ImmunizationRecommendation: "ImmunizationRecommendation";
+    readonly Invoice: "Invoice";
+    readonly Location: "Location";
+    readonly Medication: "Medication";
+    readonly MedicationAdministration: "MedicationAdministration";
+    readonly MedicationDispense: "MedicationDispense";
+    readonly MedicationRequest: "MedicationRequest";
+    readonly MedicationStatement: "MedicationStatement";
+    readonly Observation: "Observation";
+    readonly OperationOutcome: "OperationOutcome";
+    readonly Organization: "Organization";
+    readonly Parameters: "Parameters";
+    readonly Patient: "Patient";
+    readonly Person: "Person";
+    readonly Practitioner: "Practitioner";
+    readonly PractitionerRole: "PractitionerRole";
+    readonly Procedure: "Procedure";
+    readonly RelatedPerson: "RelatedPerson";
+    readonly ResearchStudy: "ResearchStudy";
+    readonly ResearchSubject: "ResearchSubject";
+    readonly Specimen: "Specimen";
+    readonly ServiceRequest: "ServiceRequest";
+    readonly Task: "Task";
+    readonly DetectedIssue: "DetectedIssue";
+}>;
+/** FHIR complex datatypes used as discriminators inside claims-first payloads. */
+export declare const FhirDataTypes: Readonly<{
+    readonly Annotation: "Annotation";
+    readonly Attachment: "Attachment";
+}>;

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

@@ -0,0 +1,70 @@
+/**
+ * Canonical FHIR R4 `resourceType` names shared across GW and SDK packages.
+ *
+ * Use these constants instead of inline strings such as `"Observation"`
+ * or `"DocumentReference"` when building bundles, filters, or SDK facades.
+ */
+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',
+    Group: 'Group',
+    ImagingStudy: 'ImagingStudy',
+    Immunization: 'Immunization',
+    ImmunizationRecommendation: 'ImmunizationRecommendation',
+    Invoice: 'Invoice',
+    Location: 'Location',
+    Medication: 'Medication',
+    MedicationAdministration: 'MedicationAdministration',
+    MedicationDispense: 'MedicationDispense',
+    MedicationRequest: 'MedicationRequest',
+    MedicationStatement: 'MedicationStatement',
+    Observation: 'Observation',
+    OperationOutcome: 'OperationOutcome',
+    Organization: 'Organization',
+    Parameters: 'Parameters',
+    Patient: 'Patient',
+    Person: 'Person',
+    Practitioner: 'Practitioner',
+    PractitionerRole: 'PractitionerRole',
+    Procedure: 'Procedure',
+    RelatedPerson: 'RelatedPerson',
+    ResearchStudy: 'ResearchStudy',
+    ResearchSubject: 'ResearchSubject',
+    Specimen: 'Specimen',
+    ServiceRequest: 'ServiceRequest',
+    Task: 'Task',
+    DetectedIssue: 'DetectedIssue',
+});
+/**
+ * Backwards-compatible alias for the former generic name.
+ *
+ * Prefer `ResourceTypesFhirR4` in new code so later R5/R6 catalogs can coexist
+ * without ambiguity.
+ */
+export const FhirResourceTypes = ResourceTypesFhirR4;
+/** FHIR R5-only resources currently emitted by shared subscription contracts. */
+export const ResourceTypesFhirR5 = Object.freeze({
+    ...ResourceTypesFhirR4,
+    SubscriptionStatus: 'SubscriptionStatus',
+});
+/** FHIR complex datatypes used as discriminators inside claims-first payloads. */
+export const FhirDataTypes = Object.freeze({
+    Annotation: 'Annotation',
+    Attachment: 'Attachment',
+});

package/dist/constants/fhir-versions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical FHIR version labels shared across GW and SDK packages.
+ *
+ * Use these constants instead of inline strings such as `"4.0"` or `"5.0"`.
+ */
+export declare const FhirVersions: Readonly<{
+    readonly R4: "4.0";
+    readonly R401: "4.0.1";
+    readonly R5: "5.0";
+}>;

package/dist/constants/fhir-versions.js

@@ -0,0 +1,10 @@
+/**
+ * Canonical FHIR version labels shared across GW and SDK packages.
+ *
+ * Use these constants instead of inline strings such as `"4.0"` or `"5.0"`.
+ */
+export const FhirVersions = Object.freeze({
+    R4: '4.0',
+    R401: '4.0.1',
+    R5: '5.0',
+});

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fhir-code-systems.js';
+export * from './fhir-resource-types.js';
+export * from './fhir-versions.js';
+export * from './clinical-statuses.js';

package/dist/constants/index.js

@@ -0,0 +1,4 @@
+export * from './fhir-code-systems.js';
+export * from './fhir-resource-types.js';
+export * from './fhir-versions.js';
+export * from './clinical-statuses.js';

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

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

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

@@ -0,0 +1,85 @@
+// 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 '../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];
+    const manifestation = claims[AllergyIntoleranceClaim.Manifestation];
+    const severity = claims[AllergyIntoleranceClaim.Severity];
+    const reactionOnset = claims[AllergyIntoleranceClaim.Onset];
+    const route = claims[AllergyIntoleranceClaim.Route];
+    if (!patient)
+        throw new Error(`Missing required claim: ${AllergyIntoleranceClaim.Subject}`);
+    if ((severity || reactionOnset || route) && !manifestation) {
+        throw new Error(`${severity ? AllergyIntoleranceClaim.Severity : reactionOnset ? AllergyIntoleranceClaim.Onset : AllergyIntoleranceClaim.Route} requires ${AllergyIntoleranceClaim.Manifestation}`);
+    }
+    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])?.map((coding) => ({
+                    ...coding,
+                    ...(claims[AllergyIntoleranceClaim.CodeDisplay]
+                        ? { display: claims[AllergyIntoleranceClaim.CodeDisplay] }
+                        : {}),
+                })),
+                ...(claims[AllergyIntoleranceClaim.CodeText]
+                    ? { text: claims[AllergyIntoleranceClaim.CodeText] }
+                    : {}),
+            }
+            : undefined,
+        clinicalStatus: claims[AllergyIntoleranceClaim.ClinicalStatus] ? { coding: [{ code: claims[AllergyIntoleranceClaim.ClinicalStatus] }] } : undefined,
+        verificationStatus: claims[AllergyIntoleranceClaim.VerificationStatus] ? { coding: [{ code: claims[AllergyIntoleranceClaim.VerificationStatus] }] } : undefined,
+        category: claims[AllergyIntoleranceClaim.Category] ? [claims[AllergyIntoleranceClaim.Category]] : undefined,
+        criticality: claims[AllergyIntoleranceClaim.Criticality],
+        type: claims[AllergyIntoleranceClaim.Type],
+        onsetDateTime: claims[AllergyIntoleranceClaim.OnsetDateTime],
+        recordedDate: claims[AllergyIntoleranceClaim.RecordedDate],
+        lastOccurrence: claims[AllergyIntoleranceClaim.LastOccurrence],
+        asserter: claims[AllergyIntoleranceClaim.Asserter]
+            ? { reference: claims[AllergyIntoleranceClaim.Asserter] }
+            : undefined,
+        recorder: recorder ? { reference: recorder } : undefined,
+        reaction: manifestation ? [{
+                manifestation: [{ coding: codingFromValue(manifestation) }],
+                onset: reactionOnset,
+                severity,
+                exposureRoute: route ? { coding: codingFromValue(route) } : undefined,
+            }] : undefined,
+    };
+}
+export function allergyIntoleranceFhirR4ToFlat(resource) {
+    const subject = resource.patient?.reference;
+    const code = resource.code;
+    const reaction = resource.reaction?.[0];
+    const manifestation = reaction?.manifestation?.[0];
+    const exposureRoute = reaction?.exposureRoute;
+    return {
+        [AllergyIntoleranceClaim.Identifier]: resource.identifier?.[0]?.value,
+        [AllergyIntoleranceClaim.Subject]: subject,
+        [AllergyIntoleranceClaim.Patient]: subject,
+        [AllergyIntoleranceClaim.Code]: codingToValue(code?.coding?.[0]) || code?.text,
+        [AllergyIntoleranceClaim.CodeText]: code?.text,
+        [AllergyIntoleranceClaim.CodeDisplay]: code?.coding?.[0]?.display,
+        [AllergyIntoleranceClaim.ClinicalStatus]: resource.clinicalStatus?.coding?.[0]?.code,
+        [AllergyIntoleranceClaim.VerificationStatus]: resource.verificationStatus?.coding?.[0]?.code,
+        [AllergyIntoleranceClaim.Category]: resource.category?.[0],
+        [AllergyIntoleranceClaim.Criticality]: resource.criticality,
+        [AllergyIntoleranceClaim.Type]: resource.type,
+        [AllergyIntoleranceClaim.OnsetDateTime]: resource.onsetDateTime,
+        [AllergyIntoleranceClaim.RecordedDate]: resource.recordedDate,
+        [AllergyIntoleranceClaim.LastOccurrence]: resource.lastOccurrence,
+        [AllergyIntoleranceClaim.Asserter]: resource.asserter?.reference,
+        [AllergyIntoleranceClaim.Manifestation]: codingToValue(manifestation?.coding?.[0]),
+        [AllergyIntoleranceClaim.Onset]: reaction?.onset,
+        [AllergyIntoleranceClaim.Route]: codingToValue(exposureRoute?.coding?.[0]),
+        [AllergyIntoleranceClaim.Severity]: reaction?.severity,
+        [AllergyIntoleranceClaim.Recorder]: resource.recorder?.reference,
+    };
+}

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

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

package/dist/converters/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 '../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/converters/convert-appointment.d.ts

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

package/dist/converters/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 '../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/converters/convert-care-plan.d.ts

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

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

@@ -0,0 +1,93 @@
+// 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 '../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];
+    const categoryCoding = codingFromValue(claims[CarePlanClaim.Category])?.map((coding) => ({
+        ...coding,
+        ...(claims[CarePlanClaim.CategoryDisplay] ? { display: claims[CarePlanClaim.CategoryDisplay] } : {}),
+    }));
+    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] || claims[CarePlanClaim.CategoryText] || claims[CarePlanClaim.CategoryDisplay]
+            ? [{
+                    ...(categoryCoding ? { coding: categoryCoding } : {}),
+                    ...(claims[CarePlanClaim.CategoryText] ? { text: claims[CarePlanClaim.CategoryText] } : {}),
+                }]
+            : undefined,
+        created: claims[CarePlanClaim.Date],
+        description: claims[CarePlanClaim.Description],
+        period: claims[CarePlanClaim.PeriodStart] || claims[CarePlanClaim.PeriodEnd] ? { start: claims[CarePlanClaim.PeriodStart], end: claims[CarePlanClaim.PeriodEnd] } : undefined,
+        note: claims[CarePlanClaim.Note] ? [{ text: claims[CarePlanClaim.Note] }] : undefined,
+        basedOn: claims[CarePlanClaim.BasedOn] ? claims[CarePlanClaim.BasedOn].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        careTeam: claims[CarePlanClaim.CareTeam] ? claims[CarePlanClaim.CareTeam].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        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] || claims[CarePlanClaim.ActivityStatus]) ? [{
+                outcomeCodeableConcept: claims[CarePlanClaim.ActivityOutcome] ? [{ coding: codingFromValue(claims[CarePlanClaim.ActivityOutcome]) }] : undefined,
+                reference: claims[CarePlanClaim.ActivityReference] ? { reference: claims[CarePlanClaim.ActivityReference] } : undefined,
+                detail: {
+                    code: claims[CarePlanClaim.ActivityCode] ? { coding: codingFromValue(claims[CarePlanClaim.ActivityCode]) } : undefined,
+                    scheduledString: claims[CarePlanClaim.ActivityDate],
+                    performer: claims[CarePlanClaim.Performer] ? claims[CarePlanClaim.Performer].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+                    status: claims[CarePlanClaim.ActivityStatus],
+                    statusReason: claims[CarePlanClaim.ActivityStatusReason] ? { text: claims[CarePlanClaim.ActivityStatusReason] } : undefined,
+                    doNotPerform: claims[CarePlanClaim.ActivityDoNotPerform] === undefined ? undefined : claims[CarePlanClaim.ActivityDoNotPerform] === 'true',
+                    scheduledTiming: claims[CarePlanClaim.ActivityTimingFrequency] || claims[CarePlanClaim.ActivityTimingPeriod] ? { repeat: {
+                            frequency: claims[CarePlanClaim.ActivityTimingFrequency] ? Number(claims[CarePlanClaim.ActivityTimingFrequency]) : undefined,
+                            period: claims[CarePlanClaim.ActivityTimingPeriod] ? Number(claims[CarePlanClaim.ActivityTimingPeriod]) : undefined,
+                            periodUnit: claims[CarePlanClaim.ActivityTimingPeriodUnit],
+                        } } : undefined,
+                    location: claims[CarePlanClaim.ActivityLocationDisplay] ? { display: claims[CarePlanClaim.ActivityLocationDisplay] } : undefined,
+                },
+            }] : undefined,
+    };
+}
+export function carePlanFhirR4ToFlat(resource) {
+    const activity = Array.isArray(resource.activity) ? resource.activity[0] : undefined;
+    const detail = activity?.detail;
+    const period = resource.period;
+    const repeat = detail?.scheduledTiming?.repeat;
+    return {
+        [CarePlanClaim.ActivityCode]: codingToValue(detail?.code?.coding?.[0]),
+        [CarePlanClaim.ActivityDate]: detail?.scheduledString,
+        [CarePlanClaim.ActivityReference]: referenceToValue(activity?.reference),
+        [CarePlanClaim.BasedOn]: referenceListToCsv(resource.basedOn),
+        [CarePlanClaim.CareTeam]: referenceListToCsv(resource.careTeam),
+        [CarePlanClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [CarePlanClaim.CategoryText]: resource.category?.[0]?.text,
+        [CarePlanClaim.CategoryDisplay]: resource.category?.[0]?.coding?.[0]?.display,
+        [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,
+        [CarePlanClaim.Description]: resource.description,
+        [CarePlanClaim.PeriodStart]: period?.start,
+        [CarePlanClaim.PeriodEnd]: period?.end,
+        [CarePlanClaim.ActivityStatus]: detail?.status,
+        [CarePlanClaim.ActivityStatusReason]: detail?.statusReason?.text,
+        [CarePlanClaim.ActivityDoNotPerform]: detail?.doNotPerform === undefined ? undefined : String(detail.doNotPerform),
+        [CarePlanClaim.ActivityOutcome]: codingToValue(activity?.outcomeCodeableConcept?.[0]?.coding?.[0]),
+        [CarePlanClaim.ActivityLocationDisplay]: detail?.location?.display,
+        [CarePlanClaim.ActivityTimingFrequency]: repeat?.frequency === undefined ? undefined : String(repeat.frequency),
+        [CarePlanClaim.ActivityTimingPeriod]: repeat?.period === undefined ? undefined : String(repeat.period),
+        [CarePlanClaim.ActivityTimingPeriodUnit]: repeat?.periodUnit,
+    };
+}

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

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

package/dist/converters/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 '../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/converters/convert-composition.d.ts

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