gdc-common-utils-ts 1.14.9 → 1.14.13

package/dist/utils/communication-bundle-document-request.js

@@ -235,8 +235,8 @@ export function createSummaryOperationRequestParameters(subjectIdOrInput, filter
     ];
 }
 /**
- * Flattens semantic summary-operation parameters to the relative search path
- * currently stored in `Communication.content-reference`.
+ * Flattens semantic summary-operation parameters to the relative `Bundle/_search`
+ * path currently stored in `Communication.content-reference`.
  */
 export function createSummaryOperationRequestReferencePath(parameters) {
     const params = ['type=document'];
@@ -258,7 +258,7 @@ export function createSummaryOperationRequestReferencePath(parameters) {
             params.push(`composition.section=${String(parameter.value || '').trim()}`);
         }
     }
-    return `individual/org.hl7.fhir.r4/Bundle?${params.filter(Boolean).join('&')}`;
+    return `individual/org.hl7.fhir.r4/Bundle/_search?${params.filter(Boolean).join('&')}`;
 }
 /**
  * Resolves the full runtime URL to call GW CORE from the provider sector DID
@@ -323,8 +323,10 @@ export const communication = Object.freeze({
      */
     newIpsSummarySearchCommunication: createIpsSummarySearchCommunicationClaims,
     /**
-     * Frontend-facing IPS helper: creates the DIDComm-ready message to request
-     * an IPS summary/search using an already-generated reference path.
+     * Compatibility helper for current DIDComm transport flows.
+     *
+     * Prefer `newIpsSummarySearchCommunication(...)` in `common-utils` 101 docs.
+     * DIDComm/outbox orchestration belongs to the next SDK layer.
      */
     newIpsSummarySearchDidcommMessage: createIpsSummarySearchDidcommMessage,
     /**

package/dist/utils/communication-bundle-session.js

@@ -7,7 +7,7 @@ import { CommunicationClaim } from '../models/interoperable-claims/communication
 import { ConditionClaim } from '../models/interoperable-claims/condition-claims.js';
 import { DocumentReferenceClaim } from '../models/interoperable-claims/document-reference-claims.js';
 import { BundleQuery } from './bundle-query.js';
-import { addClaimValues } from './claim-list-helpers.js';
+import { addClaimValues } from '../claims/claim-list-helpers.js';
 import { MedicationStatementClaim, } from '../models/interoperable-claims/medication-statement-claims.js';
 /**
  * Communication editing session with bundle-in-memory as source of truth.

package/dist/utils/composition-claim-helpers.d.ts

@@ -0,0 +1,12 @@
+import { type GenericInteroperableClaims } from './claim-list-helpers.js';
+export type CompositionInteroperableClaims = GenericInteroperableClaims;
+export declare function getCompositionClaimList(claims: CompositionInteroperableClaims, claimKey: string): string[];
+export declare function setCompositionClaimList(claims: CompositionInteroperableClaims, claimKey: string, values: string | readonly string[]): CompositionInteroperableClaims;
+export declare function addCompositionClaimList(claims: CompositionInteroperableClaims, claimKey: string, values: string | readonly string[]): CompositionInteroperableClaims;
+export declare function removeCompositionClaimList(claims: CompositionInteroperableClaims, claimKey: string, values: string | readonly string[]): CompositionInteroperableClaims;
+export declare function getCompositionTypeList(claims: CompositionInteroperableClaims): string[];
+export declare function setCompositionTypeList(claims: CompositionInteroperableClaims, values: string | readonly string[]): CompositionInteroperableClaims;
+export declare function getCompositionSectionList(claims: CompositionInteroperableClaims): string[];
+export declare function setCompositionSectionList(claims: CompositionInteroperableClaims, values: string | readonly string[]): CompositionInteroperableClaims;
+export declare function getCompositionSubject(claims: CompositionInteroperableClaims): string;
+export declare function setCompositionSubject(claims: CompositionInteroperableClaims, value: string): CompositionInteroperableClaims;

package/dist/utils/composition-claim-helpers.js

@@ -0,0 +1,32 @@
+import { CompositionClaim } from '../models/interoperable-claims/composition-claims.js';
+import { addClaimValues, getClaimValues, normalizeClaimScalar, removeClaimValues, setClaimValues, } from './claim-list-helpers.js';
+export function getCompositionClaimList(claims, claimKey) {
+    return getClaimValues(claims, claimKey);
+}
+export function setCompositionClaimList(claims, claimKey, values) {
+    return setClaimValues(claims, claimKey, values);
+}
+export function addCompositionClaimList(claims, claimKey, values) {
+    return addClaimValues(claims, claimKey, values);
+}
+export function removeCompositionClaimList(claims, claimKey, values) {
+    return removeClaimValues(claims, claimKey, values);
+}
+export function getCompositionTypeList(claims) {
+    return getCompositionClaimList(claims, CompositionClaim.Type);
+}
+export function setCompositionTypeList(claims, values) {
+    return setCompositionClaimList(claims, CompositionClaim.Type, values);
+}
+export function getCompositionSectionList(claims) {
+    return getCompositionClaimList(claims, CompositionClaim.Section);
+}
+export function setCompositionSectionList(claims, values) {
+    return setCompositionClaimList(claims, CompositionClaim.Section, values);
+}
+export function getCompositionSubject(claims) {
+    return normalizeClaimScalar(claims[CompositionClaim.Subject]);
+}
+export function setCompositionSubject(claims, value) {
+    return { ...claims, [CompositionClaim.Subject]: normalizeClaimScalar(value) };
+}

package/dist/utils/consent-claim-helpers.d.ts

@@ -1,5 +1,5 @@
-export { addClaimValues, getClaimValues, removeClaimValues, setClaimValues, } from './claim-list-helpers.js';
-import { type GenericInteroperableClaims } from './claim-list-helpers.js';
+export { addClaimValues, getClaimValues, removeClaimValues, setClaimValues, } from '../claims/claim-list-helpers.js';
+import { type GenericInteroperableClaims } from '../claims/claim-list-helpers.js';
 export type InteroperableClaims = GenericInteroperableClaims;
 export declare function getActors(claims: InteroperableClaims): string[];
 /**

package/dist/utils/consent-claim-helpers.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { ClaimConsent } from '../models/consent-rule.js';
-export { addClaimValues, getClaimValues, removeClaimValues, setClaimValues, } from './claim-list-helpers.js';
-import { addClaimValues, getClaimValues, normalizeClaimScalar, removeClaimValues, setClaimValues, } from './claim-list-helpers.js';
+export { addClaimValues, getClaimValues, removeClaimValues, setClaimValues, } from '../claims/claim-list-helpers.js';
+import { addClaimValues, getClaimValues, normalizeClaimScalar, removeClaimValues, setClaimValues, } from '../claims/claim-list-helpers.js';
 export function getActors(claims) {
     return getClaimValues(claims, ClaimConsent.actorIdentifier);
 }

package/dist/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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/utils/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;