gdc-common-utils-ts 2.0.12 → 2.0.14

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

@@ -1,55 +0,0 @@
-// 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/utils/convert-document-reference.d.ts

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

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

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

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

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

package/dist/utils/convert-encounter.js

@@ -1,68 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-encounter.ts
-import { EncounterClaim } from '../models/interoperable-claims/encounter-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
-export function encounterFlatToFhirR4(claims) {
-    const subject = claims[EncounterClaim.Subject] ?? claims[EncounterClaim.Patient];
-    return {
-        resourceType: 'Encounter',
-        identifier: claims[EncounterClaim.Identifier] ? [{ value: claims[EncounterClaim.Identifier] }] : undefined,
-        status: claims[EncounterClaim.Status],
-        class: claims[EncounterClaim.Class]
-            ? (() => {
-                const [system, code] = claims[EncounterClaim.Class].split('|');
-                return code ? { system, code } : { code: system };
-            })()
-            : undefined,
-        type: claims[EncounterClaim.Type] ? [{ coding: codingFromValue(claims[EncounterClaim.Type]) }] : undefined,
-        subject: subject ? { reference: subject } : undefined,
-        participant: claims[EncounterClaim.Participant]
-            ? claims[EncounterClaim.Participant].split(',').map((reference) => ({ individual: { reference: reference.trim() } }))
-            : undefined,
-        serviceProvider: claims[EncounterClaim.ServiceProvider] ? { reference: claims[EncounterClaim.ServiceProvider] } : undefined,
-        period: (claims[EncounterClaim.PeriodStart] || claims[EncounterClaim.PeriodEnd]) ? {
-            start: claims[EncounterClaim.PeriodStart],
-            end: claims[EncounterClaim.PeriodEnd],
-        } : undefined,
-        reasonCode: claims[EncounterClaim.ReasonCode] ? [{ coding: codingFromValue(claims[EncounterClaim.ReasonCode]) }] : undefined,
-        diagnosis: claims[EncounterClaim.Diagnosis]
-            ? claims[EncounterClaim.Diagnosis].split(',').map((reference) => ({ condition: { reference: reference.trim() } }))
-            : undefined,
-        location: claims[EncounterClaim.Location]
-            ? claims[EncounterClaim.Location].split(',').map((reference) => ({ location: { reference: reference.trim() } }))
-            : undefined,
-    };
-}
-export function encounterFhirR4ToFlat(resource) {
-    const klass = resource.class;
-    return {
-        [EncounterClaim.Identifier]: resource.identifier?.[0]?.value,
-        [EncounterClaim.Status]: resource.status,
-        [EncounterClaim.Class]: klass?.code ? (klass.system ? `${klass.system}|${klass.code}` : klass.code) : undefined,
-        [EncounterClaim.Type]: codingToValue(resource.type?.[0]?.coding?.[0]),
-        [EncounterClaim.Subject]: referenceToValue(resource.subject),
-        [EncounterClaim.Patient]: referenceToValue(resource.subject),
-        [EncounterClaim.Participant]: Array.isArray(resource.participant)
-            ? resource.participant
-                .map((item) => referenceToValue(item?.individual))
-                .filter((item) => Boolean(item))
-                .join(',')
-            : undefined,
-        [EncounterClaim.ServiceProvider]: referenceToValue(resource.serviceProvider),
-        [EncounterClaim.PeriodStart]: resource.period?.start,
-        [EncounterClaim.PeriodEnd]: resource.period?.end,
-        [EncounterClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
-        [EncounterClaim.Diagnosis]: Array.isArray(resource.diagnosis)
-            ? resource.diagnosis
-                .map((item) => referenceToValue(item?.condition))
-                .filter((item) => Boolean(item))
-                .join(',')
-            : undefined,
-        [EncounterClaim.Location]: Array.isArray(resource.location)
-            ? resource.location
-                .map((item) => referenceToValue(item?.location))
-                .filter((item) => Boolean(item))
-                .join(',')
-            : undefined,
-    };
-}

package/dist/utils/convert-flag.d.ts

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

package/dist/utils/convert-flag.js

@@ -1,34 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-flag.ts
-import { FlagClaim } from '../models/interoperable-claims/flag-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
-export function flagFlatToFhirR4(claims) {
-    const subject = claims[FlagClaim.Subject] ?? claims[FlagClaim.Patient];
-    return {
-        resourceType: 'Flag',
-        identifier: claims[FlagClaim.Identifier] ? [{ value: claims[FlagClaim.Identifier] }] : undefined,
-        status: claims[FlagClaim.Status],
-        category: claims[FlagClaim.Category] ? { coding: codingFromValue(claims[FlagClaim.Category]) } : undefined,
-        code: claims[FlagClaim.Code] ? { coding: codingFromValue(claims[FlagClaim.Code]) } : undefined,
-        subject: subject ? { reference: subject } : undefined,
-        author: claims[FlagClaim.Author] ? { reference: claims[FlagClaim.Author] } : undefined,
-        encounter: claims[FlagClaim.Encounter] ? { reference: claims[FlagClaim.Encounter] } : undefined,
-        period: (claims[FlagClaim.PeriodStart] || claims[FlagClaim.PeriodEnd]) ? { start: claims[FlagClaim.PeriodStart], end: claims[FlagClaim.PeriodEnd] } : undefined,
-    };
-}
-export function flagFhirR4ToFlat(resource) {
-    const period = resource.period;
-    return {
-        [FlagClaim.Author]: referenceToValue(resource.author),
-        [FlagClaim.Date]: undefined,
-        [FlagClaim.Encounter]: referenceToValue(resource.encounter),
-        [FlagClaim.Identifier]: resource.identifier?.[0]?.value,
-        [FlagClaim.Patient]: referenceToValue(resource.subject),
-        [FlagClaim.Subject]: referenceToValue(resource.subject),
-        [FlagClaim.Status]: resource.status,
-        [FlagClaim.Category]: codingToValue(resource.category?.coding?.[0]),
-        [FlagClaim.Code]: codingToValue(resource.code?.coding?.[0]),
-        [FlagClaim.PeriodStart]: period?.start,
-        [FlagClaim.PeriodEnd]: period?.end,
-    };
-}

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

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

package/dist/utils/convert-immunization.js

@@ -1,56 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-immunization.ts
-import { ImmunizationClaim } from '../models/interoperable-claims/immunization-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
-export function immunizationFlatToFhirR4(claims) {
-    const subject = claims[ImmunizationClaim.Subject] ?? claims[ImmunizationClaim.Patient];
-    return {
-        resourceType: 'Immunization',
-        identifier: claims[ImmunizationClaim.Identifier] ? [{ value: claims[ImmunizationClaim.Identifier] }] : undefined,
-        status: claims[ImmunizationClaim.Status],
-        vaccineCode: claims[ImmunizationClaim.VaccineCode] ? { coding: codingFromValue(claims[ImmunizationClaim.VaccineCode]) } : undefined,
-        patient: subject ? { reference: subject } : undefined,
-        occurrenceDateTime: claims[ImmunizationClaim.Date],
-        location: claims[ImmunizationClaim.Location] ? { reference: claims[ImmunizationClaim.Location] } : undefined,
-        manufacturer: claims[ImmunizationClaim.Manufacturer] ? { reference: claims[ImmunizationClaim.Manufacturer] } : undefined,
-        lotNumber: claims[ImmunizationClaim.LotNumber],
-        performer: claims[ImmunizationClaim.Performer] ? claims[ImmunizationClaim.Performer].split(',').map((reference) => ({ actor: { reference: reference.trim() } })) : undefined,
-        reasonCode: claims[ImmunizationClaim.ReasonCode] ? [{ coding: codingFromValue(claims[ImmunizationClaim.ReasonCode]) }] : undefined,
-        reasonReference: claims[ImmunizationClaim.ReasonReference] ? [{ reference: claims[ImmunizationClaim.ReasonReference] }] : undefined,
-        statusReason: claims[ImmunizationClaim.StatusReason] ? { coding: codingFromValue(claims[ImmunizationClaim.StatusReason]) } : undefined,
-        note: claims[ImmunizationClaim.Note] ? [{ text: claims[ImmunizationClaim.Note] }] : undefined,
-        protocolApplied: (claims[ImmunizationClaim.Series] || claims[ImmunizationClaim.TargetDisease] || claims[ImmunizationClaim.DoseSequence]) ? [{
-                series: claims[ImmunizationClaim.Series],
-                targetDisease: claims[ImmunizationClaim.TargetDisease] ? [{ coding: codingFromValue(claims[ImmunizationClaim.TargetDisease]) }] : undefined,
-                doseNumberString: claims[ImmunizationClaim.DoseSequence],
-            }] : undefined,
-        reaction: claims[ImmunizationClaim.ReactionDate] ? [{ date: claims[ImmunizationClaim.ReactionDate] }] : undefined,
-    };
-}
-export function immunizationFhirR4ToFlat(resource) {
-    const reaction = Array.isArray(resource.reaction) ? resource.reaction[0] : undefined;
-    const protocolApplied = Array.isArray(resource.protocolApplied) ? resource.protocolApplied[0] : undefined;
-    const performer = Array.isArray(resource.performer)
-        ? resource.performer.map((item) => referenceToValue(item?.actor)).filter((item) => Boolean(item))
-        : [];
-    return {
-        [ImmunizationClaim.Identifier]: resource.identifier?.[0]?.value,
-        [ImmunizationClaim.Date]: resource.occurrenceDateTime,
-        [ImmunizationClaim.Location]: referenceToValue(resource.location),
-        [ImmunizationClaim.LotNumber]: resource.lotNumber,
-        [ImmunizationClaim.Manufacturer]: referenceToValue(resource.manufacturer),
-        [ImmunizationClaim.Patient]: referenceToValue(resource.patient),
-        [ImmunizationClaim.Performer]: performer.length ? performer.join(',') : undefined,
-        [ImmunizationClaim.ReactionDate]: reaction?.date,
-        [ImmunizationClaim.ReasonCode]: codingToValue(resource.reasonCode?.[0]?.coding?.[0]),
-        [ImmunizationClaim.ReasonReference]: referenceToValue(resource.reasonReference?.[0]),
-        [ImmunizationClaim.Series]: protocolApplied?.series,
-        [ImmunizationClaim.Status]: resource.status,
-        [ImmunizationClaim.StatusReason]: codingToValue(resource.statusReason?.coding?.[0]),
-        [ImmunizationClaim.TargetDisease]: codingToValue(protocolApplied?.targetDisease?.[0]?.coding?.[0]),
-        [ImmunizationClaim.VaccineCode]: codingToValue(resource.vaccineCode?.coding?.[0]),
-        [ImmunizationClaim.DoseSequence]: protocolApplied?.doseNumberString,
-        [ImmunizationClaim.Subject]: referenceToValue(resource.patient),
-        [ImmunizationClaim.Note]: resource.note?.[0]?.text,
-    };
-}

package/dist/utils/convert-medication-statement.d.ts

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

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

@@ -1,64 +0,0 @@
-// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
-// File: src/utils/convert-medication-statement.ts
-import { MedicationStatementClaim } from '../models/interoperable-claims/medication-statement-claims.js';
-import { codingFromValue, codingToValue, requireClaim } from './convert-shared.js';
-export function medicationStatementFlatToFhirR4(claims) {
-    const subject = requireClaim(claims, MedicationStatementClaim.Subject);
-    const status = requireClaim(claims, MedicationStatementClaim.Status);
-    const effectiveDateTime = claims[MedicationStatementClaim.Effective];
-    const medicationText = claims[MedicationStatementClaim.MedicationText];
-    const medicationIdentifier = claims[MedicationStatementClaim.MedicationIdentifier];
-    const medicationSerialNumber = claims[MedicationStatementClaim.MedicationSerialNumber];
-    const medicationExpirationDate = claims[MedicationStatementClaim.MedicationExpirationDate];
-    const hasContainedMedication = Boolean(medicationIdentifier) || Boolean(medicationSerialNumber) || Boolean(medicationExpirationDate) || Boolean(medicationText);
-    const containedMedicationId = 'medication-contained-1';
-    const containedMedication = hasContainedMedication ? {
-        resourceType: 'Medication',
-        id: containedMedicationId,
-        identifier: medicationIdentifier ? [{ value: medicationIdentifier }] : undefined,
-        code: medicationText ? { text: medicationText } : undefined,
-        batch: medicationSerialNumber || medicationExpirationDate ? {
-            lotNumber: medicationSerialNumber,
-            expirationDate: medicationExpirationDate,
-        } : undefined,
-    } : undefined;
-    return {
-        resourceType: 'MedicationStatement',
-        identifier: claims[MedicationStatementClaim.Identifier] ? [{ value: claims[MedicationStatementClaim.Identifier] }] : undefined,
-        status,
-        subject: { reference: subject },
-        effectiveDateTime,
-        medicationCodeableConcept: claims[MedicationStatementClaim.Code]
-            ? { coding: codingFromValue(claims[MedicationStatementClaim.Code]) }
-            : (!hasContainedMedication && medicationText ? { text: medicationText } : undefined),
-        medicationReference: hasContainedMedication ? { reference: `#${containedMedicationId}` } : undefined,
-        contained: containedMedication ? [containedMedication] : undefined,
-        dosage: claims[MedicationStatementClaim.DosageInstruction] ? [{ text: claims[MedicationStatementClaim.DosageInstruction] }] : undefined,
-        note: claims[MedicationStatementClaim.Note] ? [{ text: claims[MedicationStatementClaim.Note] }] : undefined,
-    };
-}
-export function medicationStatementFhirR4ToFlat(resource) {
-    const medicationReference = resource.medicationReference?.reference;
-    const containedResources = Array.isArray(resource.contained) ? resource.contained : [];
-    const containedMedication = medicationReference?.startsWith('#')
-        ? containedResources.find((item) => item?.resourceType === 'Medication' && String(item?.id || '') === medicationReference.slice(1))
-        : containedResources.find((item) => item?.resourceType === 'Medication');
-    const containedMedicationIdentifier = containedMedication?.identifier?.[0]?.value;
-    const containedMedicationText = containedMedication?.code?.text;
-    const batch = containedMedication?.batch;
-    const medicationCode = codingToValue(resource.medicationCodeableConcept?.coding?.[0]);
-    const medicationText = containedMedicationText || resource.medicationCodeableConcept?.text || undefined;
-    return {
-        [MedicationStatementClaim.Identifier]: resource.identifier?.[0]?.value,
-        [MedicationStatementClaim.Subject]: resource.subject?.reference,
-        [MedicationStatementClaim.Status]: resource.status,
-        [MedicationStatementClaim.Effective]: resource.effectiveDateTime,
-        [MedicationStatementClaim.Code]: medicationCode,
-        [MedicationStatementClaim.MedicationText]: medicationText,
-        [MedicationStatementClaim.Note]: resource.note?.[0]?.text,
-        [MedicationStatementClaim.DosageInstruction]: resource.dosage?.[0]?.text,
-        [MedicationStatementClaim.MedicationIdentifier]: containedMedicationIdentifier,
-        [MedicationStatementClaim.MedicationSerialNumber]: batch?.lotNumber,
-        [MedicationStatementClaim.MedicationExpirationDate]: batch?.expirationDate,
-    };
-}

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

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

package/dist/utils/convert-observation.js

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

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

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

package/dist/utils/convert-procedure.js

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

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

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

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

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

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

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