fhir-data-utils-ts 0.4.0 → 0.6.1

package/dist/converters/convert-encounter-history.js

@@ -0,0 +1,83 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { EncounterHistoryClaim } from '../claims/encounter-history-claims.js';
+import { EncounterStatusR5 } from '../claims/encounter-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+const R5_STATUSES = new Set(Object.values(EncounterStatusR5));
+/** Materializes canonical EncounterHistory claims as native FHIR R5. */
+export function encounterHistoryFlatToFhirR5(claims) {
+    const status = claims[EncounterHistoryClaim.Status];
+    if (!status || !R5_STATUSES.has(status))
+        throw new TypeError('encounter_history_r5_status_invalid');
+    const klass = claims[EncounterHistoryClaim.Class];
+    if (!klass)
+        throw new TypeError('encounter_history_r5_class_required');
+    return {
+        resourceType: 'EncounterHistory',
+        identifier: claims[EncounterHistoryClaim.Identifier] ? [{ value: claims[EncounterHistoryClaim.Identifier] }] : undefined,
+        encounter: claims[EncounterHistoryClaim.Encounter] ? { reference: claims[EncounterHistoryClaim.Encounter] } : undefined,
+        status,
+        class: { coding: codingFromValue(klass) },
+        type: concepts(claims[EncounterHistoryClaim.Type]),
+        serviceType: codeableReferences(claims[EncounterHistoryClaim.ServiceType]),
+        subject: claims[EncounterHistoryClaim.Subject] ? { reference: claims[EncounterHistoryClaim.Subject] } : undefined,
+        subjectStatus: claims[EncounterHistoryClaim.SubjectStatus] ? { coding: codingFromValue(claims[EncounterHistoryClaim.SubjectStatus]) } : undefined,
+        actualPeriod: period(claims[EncounterHistoryClaim.ActualPeriodStart], claims[EncounterHistoryClaim.ActualPeriodEnd]),
+        plannedStartDate: claims[EncounterHistoryClaim.PlannedStartDate],
+        plannedEndDate: claims[EncounterHistoryClaim.PlannedEndDate],
+        location: locations(claims[EncounterHistoryClaim.Location], claims[EncounterHistoryClaim.LocationForm]),
+    };
+}
+/** Extracts supported native FHIR R5 EncounterHistory fields into flat claims. */
+export function encounterHistoryFhirR5ToFlat(resource) {
+    const klass = resource.class;
+    const actualPeriod = resource.actualPeriod;
+    const location = resource.location?.[0];
+    return {
+        [EncounterHistoryClaim.Identifier]: resource.identifier?.[0]?.value,
+        [EncounterHistoryClaim.Encounter]: referenceToValue(resource.encounter),
+        [EncounterHistoryClaim.Status]: resource.status,
+        [EncounterHistoryClaim.Class]: codingToValue(klass?.coding?.[0]),
+        [EncounterHistoryClaim.Type]: conceptsToCsv(resource.type),
+        [EncounterHistoryClaim.ServiceType]: codeableReferencesToCsv(resource.serviceType),
+        [EncounterHistoryClaim.Subject]: referenceToValue(resource.subject),
+        [EncounterHistoryClaim.SubjectStatus]: codingToValue(resource.subjectStatus?.coding?.[0]),
+        [EncounterHistoryClaim.ActualPeriodStart]: actualPeriod?.start,
+        [EncounterHistoryClaim.ActualPeriodEnd]: actualPeriod?.end,
+        [EncounterHistoryClaim.PlannedStartDate]: resource.plannedStartDate,
+        [EncounterHistoryClaim.PlannedEndDate]: resource.plannedEndDate,
+        [EncounterHistoryClaim.Location]: location?.location?.reference,
+        [EncounterHistoryClaim.LocationForm]: codingToValue(location?.form?.coding?.[0]),
+    };
+}
+function period(start, end) {
+    return start || end ? { start, end } : undefined;
+}
+function concepts(value) {
+    const values = value?.split(',').map(item => item.trim()).filter(Boolean) ?? [];
+    return values.length ? values.map(item => ({ coding: codingFromValue(item) })) : undefined;
+}
+function conceptsToCsv(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const values = value.map(item => codingToValue(item?.coding?.[0])).filter(Boolean);
+    return values.length ? values.join(',') : undefined;
+}
+function codeableReferences(value) {
+    const values = value?.split(',').map(item => item.trim()).filter(Boolean) ?? [];
+    return values.length ? values.map(reference => ({ reference: { reference } })) : undefined;
+}
+function codeableReferencesToCsv(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const values = value.map(item => referenceToValue(item?.reference)).filter(Boolean);
+    return values.length ? values.join(',') : undefined;
+}
+function locations(locationValue, formValue) {
+    const values = locationValue?.split(',').map(item => item.trim()).filter(Boolean) ?? [];
+    if (!values.length)
+        return undefined;
+    return values.map((reference, index) => ({
+        location: { reference },
+        form: index === 0 && formValue ? { coding: codingFromValue(formValue) } : undefined,
+    }));
+}

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

@@ -1,3 +1,7 @@
 import type { FhirResource, FlatClaims } from './convert-shared.js';
 export declare function encounterFlatToFhirR4(claims: FlatClaims): FhirResource;
 export declare function encounterFhirR4ToFlat(resource: FhirResource): FlatClaims;
+/** Materializes canonical Encounter claims as native FHIR R5. */
+export declare function encounterFlatToFhirR5(claims: FlatClaims): FhirResource;
+/** Extracts the supported R5 Encounter fields into canonical flat claims. */
+export declare function encounterFhirR5ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-encounter.js

@@ -1,6 +1,6 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 // File: src/utils/convert-encounter.ts
-import { EncounterClaim } from '../claims/encounter-claims.js';
+import { EncounterClaim, EncounterStatusR5 } from '../claims/encounter-claims.js';
 import { codingFromValue, codingToValue, referenceListToCsv, referenceToValue } from './convert-shared.js';
 export function encounterFlatToFhirR4(claims) {
     const subject = claims[EncounterClaim.Subject] ?? claims[EncounterClaim.Patient];
@@ -72,3 +72,75 @@ export function encounterFhirR4ToFlat(resource) {
         [EncounterClaim.PartOf]: referenceToValue(resource.partOf),
     };
 }
+const R5_STATUSES = new Set(Object.values(EncounterStatusR5));
+/** Materializes canonical Encounter claims as native FHIR R5. */
+export function encounterFlatToFhirR5(claims) {
+    const status = claims[EncounterClaim.Status];
+    if (status && !R5_STATUSES.has(status))
+        throw new TypeError('encounter_r5_status_invalid');
+    const subject = claims[EncounterClaim.Subject] ?? claims[EncounterClaim.Patient];
+    const actualPeriodStart = claims[EncounterClaim.ActualPeriodStart] ?? claims[EncounterClaim.PeriodStart];
+    const actualPeriodEnd = claims[EncounterClaim.ActualPeriodEnd] ?? claims[EncounterClaim.PeriodEnd];
+    return {
+        resourceType: 'Encounter',
+        identifier: claims[EncounterClaim.Identifier] ? [{ value: claims[EncounterClaim.Identifier] }] : undefined,
+        appointment: referenceList(claims[EncounterClaim.Appointment]),
+        status,
+        class: claims[EncounterClaim.Class] ? { coding: codingFromValue(claims[EncounterClaim.Class]) } : undefined,
+        type: claims[EncounterClaim.Type] ? [{ coding: codingFromValue(claims[EncounterClaim.Type]) }] : undefined,
+        serviceType: codeableReferenceList(claims[EncounterClaim.ServiceType]),
+        subject: subject ? { reference: subject } : undefined,
+        participant: claims[EncounterClaim.Participant]
+            ? claims[EncounterClaim.Participant].split(',').map(reference => ({ actor: { reference: reference.trim() } }))
+            : undefined,
+        serviceProvider: claims[EncounterClaim.ServiceProvider] ? { reference: claims[EncounterClaim.ServiceProvider] } : undefined,
+        actualPeriod: (actualPeriodStart || actualPeriodEnd) ? { start: actualPeriodStart, end: actualPeriodEnd } : undefined,
+        location: claims[EncounterClaim.Location]
+            ? claims[EncounterClaim.Location].split(',').map(reference => ({ location: { reference: reference.trim() } }))
+            : undefined,
+        partOf: claims[EncounterClaim.PartOf] ? { reference: claims[EncounterClaim.PartOf] } : undefined,
+    };
+}
+/** Extracts the supported R5 Encounter fields into canonical flat claims. */
+export function encounterFhirR5ToFlat(resource) {
+    const klass = resource.class;
+    const actualPeriod = resource.actualPeriod;
+    return {
+        [EncounterClaim.Identifier]: resource.identifier?.[0]?.value,
+        [EncounterClaim.Appointment]: referenceListToCsv(resource.appointment),
+        [EncounterClaim.Status]: resource.status,
+        [EncounterClaim.Class]: codingToValue(klass?.coding?.[0]),
+        [EncounterClaim.Type]: codingToValue(resource.type?.[0]?.coding?.[0]),
+        [EncounterClaim.ServiceType]: codeableReferencesToCsv(resource.serviceType),
+        [EncounterClaim.Subject]: referenceToValue(resource.subject),
+        [EncounterClaim.Patient]: referenceToValue(resource.subject),
+        [EncounterClaim.Participant]: Array.isArray(resource.participant)
+            ? resource.participant.map(item => item.actor?.reference).filter(Boolean).join(',') || undefined
+            : undefined,
+        [EncounterClaim.ServiceProvider]: referenceToValue(resource.serviceProvider),
+        [EncounterClaim.ActualPeriodStart]: actualPeriod?.start,
+        [EncounterClaim.ActualPeriodEnd]: actualPeriod?.end,
+        [EncounterClaim.Location]: Array.isArray(resource.location)
+            ? resource.location.map(item => item.location?.reference).filter(Boolean).join(',') || undefined
+            : undefined,
+        [EncounterClaim.PartOf]: referenceToValue(resource.partOf),
+    };
+}
+function referenceList(value) {
+    const references = value?.split(',').map(reference => reference.trim()).filter(Boolean) ?? [];
+    return references.length ? references.map(reference => ({ reference })) : undefined;
+}
+function codeableReferenceList(value) {
+    const references = referenceList(value);
+    return references?.map(reference => ({ reference }));
+}
+function codeableReferencesToCsv(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const references = value.map(item => {
+        if (!item || typeof item !== 'object')
+            return undefined;
+        return referenceToValue(item.reference);
+    }).filter((item) => Boolean(item));
+    return references.length ? references.join(',') : undefined;
+}

package/dist/converters/convert-healthcare-service.d.ts

@@ -0,0 +1,7 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+/** Materializes canonical HealthcareService claims as native FHIR R4. */
+export declare function healthcareServiceFlatToFhirR4(claims: FlatClaims): FhirResource;
+/** Extracts only official R4 HealthcareService SearchParameters into flat claims. */
+export declare function healthcareServiceFhirR4ToFlat(resource: FhirResource): FlatClaims;
+/** Materializes canonical HealthcareService claims as native FHIR R5. */
+export declare const healthcareServiceFlatToFhirR5: typeof healthcareServiceFlatToFhirR4;

package/dist/converters/convert-healthcare-service.js

@@ -0,0 +1,60 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { HealthcareServiceClaim } from '../claims/healthcare-service-claims.js';
+import { codingListFromCsv, codingListToCsv, identifierFromValue, identifierToValue, referenceListToCsv, referenceToValue, } from './convert-shared.js';
+const conceptsFromCsv = (value) => {
+    const coding = codingListFromCsv(value);
+    return coding?.map(item => ({ coding: [item] }));
+};
+const conceptsToCsv = (value) => codingListToCsv((Array.isArray(value) ? value : [])
+    .flatMap(item => item && typeof item === 'object' && Array.isArray(item.coding)
+    ? item.coding ?? []
+    : []));
+const referencesFromCsv = (value) => {
+    const references = String(value || '').split(',').map(item => item.trim()).filter(Boolean);
+    return references.length ? references.map(reference => ({ reference })) : undefined;
+};
+/** Materializes canonical HealthcareService claims as native FHIR R4. */
+export function healthcareServiceFlatToFhirR4(claims) {
+    return {
+        resourceType: 'HealthcareService',
+        identifier: claims[HealthcareServiceClaim.Identifier]
+            ? [identifierFromValue(claims[HealthcareServiceClaim.Identifier])]
+            : undefined,
+        active: claims[HealthcareServiceClaim.Active] === undefined
+            ? undefined
+            : claims[HealthcareServiceClaim.Active] === 'true',
+        providedBy: claims[HealthcareServiceClaim.Organization]
+            ? { reference: claims[HealthcareServiceClaim.Organization] }
+            : undefined,
+        category: conceptsFromCsv(claims[HealthcareServiceClaim.ServiceCategory]),
+        type: conceptsFromCsv(claims[HealthcareServiceClaim.ServiceType]),
+        specialty: conceptsFromCsv(claims[HealthcareServiceClaim.Specialty]),
+        location: referencesFromCsv(claims[HealthcareServiceClaim.Location]),
+        name: claims[HealthcareServiceClaim.Name],
+        comment: claims[HealthcareServiceClaim.Comment],
+        coverageArea: referencesFromCsv(claims[HealthcareServiceClaim.CoverageArea]),
+        program: conceptsFromCsv(claims[HealthcareServiceClaim.Program]),
+        characteristic: conceptsFromCsv(claims[HealthcareServiceClaim.Characteristic]),
+        endpoint: referencesFromCsv(claims[HealthcareServiceClaim.Endpoint]),
+    };
+}
+/** Extracts only official R4 HealthcareService SearchParameters into flat claims. */
+export function healthcareServiceFhirR4ToFlat(resource) {
+    return {
+        [HealthcareServiceClaim.Active]: resource.active === undefined ? undefined : String(resource.active),
+        [HealthcareServiceClaim.Characteristic]: conceptsToCsv(resource.characteristic),
+        [HealthcareServiceClaim.CoverageArea]: referenceListToCsv(resource.coverageArea),
+        [HealthcareServiceClaim.Endpoint]: referenceListToCsv(resource.endpoint),
+        [HealthcareServiceClaim.Identifier]: identifierToValue(resource.identifier?.[0]),
+        [HealthcareServiceClaim.Location]: referenceListToCsv(resource.location),
+        [HealthcareServiceClaim.Name]: resource.name,
+        [HealthcareServiceClaim.Comment]: resource.comment,
+        [HealthcareServiceClaim.Organization]: referenceToValue(resource.providedBy),
+        [HealthcareServiceClaim.Program]: conceptsToCsv(resource.program),
+        [HealthcareServiceClaim.ServiceCategory]: conceptsToCsv(resource.category),
+        [HealthcareServiceClaim.ServiceType]: conceptsToCsv(resource.type),
+        [HealthcareServiceClaim.Specialty]: conceptsToCsv(resource.specialty),
+    };
+}
+/** Materializes canonical HealthcareService claims as native FHIR R5. */
+export const healthcareServiceFlatToFhirR5 = healthcareServiceFlatToFhirR4;

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

@@ -1,3 +1,7 @@
 import type { FhirResource, FlatClaims } from './convert-shared.js';
 export declare function locationFlatToFhirR4(claims: FlatClaims): FhirResource;
 export declare function locationFhirR4ToFlat(resource: FhirResource): FlatClaims;
+/** Materializes canonical Location claims as native FHIR R5 (`form`, not the removed R4 `physicalType`). */
+export declare function locationFlatToFhirR5(claims: FlatClaims): FhirResource;
+/** Extracts the version-neutral Location claims from native FHIR R5. */
+export declare function locationFhirR5ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-location.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 // File: src/convert/convert-location.ts
 import { LocationClaim } from '../claims/location-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+import { codingFromValue, codingToValue, identifierFromValue, identifierToValue, referenceToValue } from './convert-shared.js';
 function splitCsv(value) {
     return String(value || '')
         .split(',')
@@ -11,7 +11,7 @@ function splitCsv(value) {
 export function locationFlatToFhirR4(claims) {
     return {
         resourceType: 'Location',
-        identifier: claims[LocationClaim.Identifier] ? [{ value: claims[LocationClaim.Identifier] }] : undefined,
+        identifier: claims[LocationClaim.Identifier] ? [identifierFromValue(claims[LocationClaim.Identifier])] : undefined,
         status: claims[LocationClaim.Status],
         name: claims[LocationClaim.Name],
         description: claims[LocationClaim.Description],
@@ -22,6 +22,15 @@ export function locationFlatToFhirR4(claims) {
         physicalType: claims[LocationClaim.PhysicalType] ? { coding: codingFromValue(claims[LocationClaim.PhysicalType]) } : undefined,
         managingOrganization: claims[LocationClaim.ManagingOrganization] ? { reference: claims[LocationClaim.ManagingOrganization] } : undefined,
         partOf: claims[LocationClaim.PartOf] ? { reference: claims[LocationClaim.PartOf] } : undefined,
+        position: claims[LocationClaim.PositionLongitude] !== undefined && claims[LocationClaim.PositionLatitude] !== undefined
+            ? {
+                longitude: Number(claims[LocationClaim.PositionLongitude]),
+                latitude: Number(claims[LocationClaim.PositionLatitude]),
+                ...(claims[LocationClaim.PositionAltitude] !== undefined
+                    ? { altitude: Number(claims[LocationClaim.PositionAltitude]) }
+                    : {}),
+            }
+            : undefined,
     };
 }
 export function locationFhirR4ToFlat(resource) {
@@ -29,7 +38,7 @@ export function locationFhirR4ToFlat(resource) {
         ?.map((item) => item?.value)
         .filter((item) => Boolean(item));
     return {
-        [LocationClaim.Identifier]: resource.identifier?.[0]?.value,
+        [LocationClaim.Identifier]: identifierToValue(resource.identifier?.[0]),
         [LocationClaim.Status]: resource.status,
         [LocationClaim.Name]: resource.name,
         [LocationClaim.Description]: resource.description,
@@ -40,5 +49,34 @@ export function locationFhirR4ToFlat(resource) {
         [LocationClaim.PhysicalType]: codingToValue(resource.physicalType?.coding?.[0]),
         [LocationClaim.ManagingOrganization]: referenceToValue(resource.managingOrganization),
         [LocationClaim.PartOf]: referenceToValue(resource.partOf),
+        [LocationClaim.PositionLongitude]: resource.position?.longitude?.toString(),
+        [LocationClaim.PositionLatitude]: resource.position?.latitude?.toString(),
+        [LocationClaim.PositionAltitude]: resource.position?.altitude?.toString(),
+    };
+}
+/** Materializes canonical Location claims as native FHIR R5 (`form`, not the removed R4 `physicalType`). */
+export function locationFlatToFhirR5(claims) {
+    const r4 = locationFlatToFhirR4(claims);
+    const { physicalType: _physicalType, telecom: _telecom, ...common } = r4;
+    const telecom = _telecom;
+    return {
+        ...common,
+        contact: telecom?.length ? [{ telecom }] : undefined,
+        form: claims[LocationClaim.PhysicalType]
+            ? { coding: codingFromValue(claims[LocationClaim.PhysicalType]) }
+            : undefined,
+    };
+}
+/** Extracts the version-neutral Location claims from native FHIR R5. */
+export function locationFhirR5ToFlat(resource) {
+    const flat = locationFhirR4ToFlat(resource);
+    const telecom = resource.contact
+        ?.flatMap(contact => contact.telecom ?? [])
+        .map(point => point.value)
+        .filter((value) => Boolean(value));
+    return {
+        ...flat,
+        [LocationClaim.Telecom]: telecom?.length ? telecom.join(',') : undefined,
+        [LocationClaim.PhysicalType]: codingToValue(resource.form?.coding?.[0]),
     };
 }

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

@@ -1,3 +1,5 @@
 import type { FhirResource, FlatClaims } from './convert-shared.js';
 export declare function organizationFlatToFhirR4(claims: FlatClaims): FhirResource;
 export declare function organizationFhirR4ToFlat(resource: FhirResource): FlatClaims;
+/** Materializes canonical Organization claims as native FHIR R5. */
+export declare function organizationFlatToFhirR5(claims: FlatClaims): FhirResource;

package/dist/converters/convert-organization.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 // File: src/convert/convert-organization.ts
 import { OrganizationClaim } from '../claims/organization-claims.js';
-import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+import { codingFromValue, codingToValue, identifierFromValue, identifierToValue, referenceToValue } from './convert-shared.js';
 function splitCsv(value) {
     return String(value || '')
         .split(',')
@@ -11,7 +11,7 @@ function splitCsv(value) {
 export function organizationFlatToFhirR4(claims) {
     return {
         resourceType: 'Organization',
-        identifier: claims[OrganizationClaim.Identifier] ? [{ value: claims[OrganizationClaim.Identifier] }] : undefined,
+        identifier: claims[OrganizationClaim.Identifier] ? [identifierFromValue(claims[OrganizationClaim.Identifier])] : undefined,
         active: claims[OrganizationClaim.Active] === undefined ? undefined : claims[OrganizationClaim.Active] === 'true',
         type: claims[OrganizationClaim.Type] ? [{ coding: codingFromValue(claims[OrganizationClaim.Type]) }] : undefined,
         name: claims[OrganizationClaim.Name],
@@ -27,7 +27,7 @@ export function organizationFhirR4ToFlat(resource) {
         ?.map((item) => item?.value)
         .filter((item) => Boolean(item));
     return {
-        [OrganizationClaim.Identifier]: resource.identifier?.[0]?.value,
+        [OrganizationClaim.Identifier]: identifierToValue(resource.identifier?.[0]),
         [OrganizationClaim.Active]: resource.active === undefined ? undefined : String(resource.active),
         [OrganizationClaim.Type]: codingToValue(resource.type?.[0]?.coding?.[0]),
         [OrganizationClaim.Name]: resource.name,
@@ -37,3 +37,20 @@ export function organizationFhirR4ToFlat(resource) {
         [OrganizationClaim.Address]: resource.address?.[0]?.text,
     };
 }
+/** Materializes canonical Organization claims as native FHIR R5. */
+export function organizationFlatToFhirR5(claims) {
+    const identifier = identifierFromValue(claims[OrganizationClaim.Identifier]);
+    const telecom = splitCsv(claims[OrganizationClaim.Telecom]).map((value) => ({ value }));
+    const address = claims[OrganizationClaim.Address] ? [{ text: claims[OrganizationClaim.Address] }] : [];
+    return {
+        resourceType: 'Organization',
+        identifier: identifier ? [identifier] : undefined,
+        active: claims[OrganizationClaim.Active] === undefined ? undefined : claims[OrganizationClaim.Active] === 'true',
+        type: claims[OrganizationClaim.Type] ? [{ coding: codingFromValue(claims[OrganizationClaim.Type]) }] : undefined,
+        name: claims[OrganizationClaim.Name],
+        alias: splitCsv(claims[OrganizationClaim.Alias]),
+        description: claims[OrganizationClaim.Description],
+        partOf: claims[OrganizationClaim.PartOf] ? { reference: claims[OrganizationClaim.PartOf] } : undefined,
+        contact: telecom.length || address.length ? [{ telecom, address }] : undefined,
+    };
+}

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

@@ -1,3 +1,5 @@
 import type { FhirResource, FlatClaims } from './convert-shared.js';
 export declare function procedureFlatToFhirR4(claims: FlatClaims): FhirResource;
 export declare function procedureFhirR4ToFlat(resource: FhirResource): FlatClaims;
+/** Explicit FHIR R5 projection, including equipment calibration and inspection. */
+export declare function procedureFlatToFhirR5(claims: FlatClaims): FhirResource;

package/dist/converters/convert-procedure.js

@@ -62,3 +62,24 @@ export function procedureFhirR4ToFlat(resource) {
         [ProcedureClaim.Note]: resource.note?.[0]?.text,
     };
 }
+/** Explicit FHIR R5 projection, including equipment calibration and inspection. */
+export function procedureFlatToFhirR5(claims) {
+    const resource = procedureFlatToFhirR4(claims);
+    const { performedDateTime, reasonCode, reasonReference, ...common } = resource;
+    return {
+        ...common,
+        occurrenceDateTime: performedDateTime,
+        reason: reasonCode || reasonReference
+            ? [
+                ...(Array.isArray(reasonCode) ? reasonCode.map(concept => ({ concept })) : []),
+                ...(Array.isArray(reasonReference) ? reasonReference.map(reference => ({ reference })) : []),
+            ]
+            : undefined,
+        focalDevice: claims[ProcedureClaim.FocalDevice]
+            ? claims[ProcedureClaim.FocalDevice].split(',').map(reference => ({ manipulated: { reference: reference.trim() } }))
+            : undefined,
+        report: claims[ProcedureClaim.Report]
+            ? claims[ProcedureClaim.Report].split(',').map(reference => ({ reference: reference.trim() }))
+            : undefined,
+    };
+}

package/dist/converters/convert-regulated-authorization.d.ts

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

package/dist/converters/convert-regulated-authorization.js

@@ -0,0 +1,34 @@
+import { RegulatedAuthorizationClaim } from '../claims/regulated-authorization-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function regulatedAuthorizationFlatToFhirR5(claims) {
+    return {
+        resourceType: 'RegulatedAuthorization',
+        identifier: claims[RegulatedAuthorizationClaim.Identifier] ? [{ value: claims[RegulatedAuthorizationClaim.Identifier] }] : undefined,
+        subject: claims[RegulatedAuthorizationClaim.Subject] ? claims[RegulatedAuthorizationClaim.Subject].split(',').map(reference => ({ reference: reference.trim() })) : undefined,
+        type: claims[RegulatedAuthorizationClaim.Type] ? { coding: codingFromValue(claims[RegulatedAuthorizationClaim.Type]) } : undefined,
+        region: claims[RegulatedAuthorizationClaim.Region] ? [{ coding: codingFromValue(claims[RegulatedAuthorizationClaim.Region]) }] : undefined,
+        status: claims[RegulatedAuthorizationClaim.Status] ? { coding: [{ code: claims[RegulatedAuthorizationClaim.Status] }] } : undefined,
+        statusDate: claims[RegulatedAuthorizationClaim.StatusDate],
+        validityPeriod: claims[RegulatedAuthorizationClaim.ValidityStart] || claims[RegulatedAuthorizationClaim.ValidityEnd]
+            ? { start: claims[RegulatedAuthorizationClaim.ValidityStart], end: claims[RegulatedAuthorizationClaim.ValidityEnd] }
+            : undefined,
+        basis: claims[RegulatedAuthorizationClaim.Basis] ? [{ coding: codingFromValue(claims[RegulatedAuthorizationClaim.Basis]) }] : undefined,
+        holder: claims[RegulatedAuthorizationClaim.Holder] ? { reference: claims[RegulatedAuthorizationClaim.Holder] } : undefined,
+        regulator: claims[RegulatedAuthorizationClaim.Regulator] ? { reference: claims[RegulatedAuthorizationClaim.Regulator] } : undefined,
+    };
+}
+export function regulatedAuthorizationFhirR5ToFlat(resource) {
+    return {
+        [RegulatedAuthorizationClaim.Identifier]: resource.identifier?.[0]?.value,
+        [RegulatedAuthorizationClaim.Subject]: Array.isArray(resource.subject) ? resource.subject.map(item => item.reference).filter(Boolean).join(',') || undefined : undefined,
+        [RegulatedAuthorizationClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [RegulatedAuthorizationClaim.Region]: codingToValue(resource.region?.[0]?.coding?.[0]),
+        [RegulatedAuthorizationClaim.Status]: resource.status?.coding?.[0]?.code,
+        [RegulatedAuthorizationClaim.StatusDate]: resource.statusDate,
+        [RegulatedAuthorizationClaim.ValidityStart]: resource.validityPeriod?.start,
+        [RegulatedAuthorizationClaim.ValidityEnd]: resource.validityPeriod?.end,
+        [RegulatedAuthorizationClaim.Basis]: codingToValue(resource.basis?.[0]?.coding?.[0]),
+        [RegulatedAuthorizationClaim.Holder]: referenceToValue(resource.holder),
+        [RegulatedAuthorizationClaim.Regulator]: referenceToValue(resource.regulator),
+    };
+}

package/dist/converters/convert-schedule-slot.d.ts

@@ -0,0 +1,9 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+/** Materializes canonical Schedule claims as native FHIR R5. */
+export declare function scheduleFlatToFhirR5(claims: FlatClaims): FhirResource;
+/** Extracts official Schedule search claims plus required materialization fields. */
+export declare function scheduleFhirR5ToFlat(resource: FhirResource): FlatClaims;
+/** Materializes canonical Slot claims as native FHIR R5. */
+export declare function slotFlatToFhirR5(claims: FlatClaims): FhirResource;
+/** Extracts official Slot search claims plus required materialization fields. */
+export declare function slotFhirR5ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-schedule-slot.js

@@ -0,0 +1,96 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { ScheduleClaim, SlotClaim } from '../claims/schedule-slot-claims.js';
+import { codingListFromCsv, codingListToCsv, identifierFromValue, identifierToValue, referenceListToCsv, referenceToValue, } from './convert-shared.js';
+const splitCsv = (value) => String(value || '').split(',').map(item => item.trim()).filter(Boolean);
+const referencesFromCsv = (value) => {
+    const values = splitCsv(value);
+    return values.length ? values.map(reference => ({ reference })) : undefined;
+};
+const conceptsFromCsv = (value) => {
+    const codings = codingListFromCsv(value);
+    return codings?.map(coding => ({ coding: [coding] }));
+};
+const conceptsToCsv = (value) => codingListToCsv((Array.isArray(value) ? value : []).flatMap(item => item && typeof item === 'object' && Array.isArray(item.coding)
+    ? item.coding ?? []
+    : []));
+const codeableReferencesFromClaims = (concepts, references) => {
+    const conceptList = conceptsFromCsv(concepts) ?? [];
+    const referenceList = referencesFromCsv(references) ?? [];
+    const length = Math.max(conceptList.length, referenceList.length);
+    if (!length)
+        return undefined;
+    return Array.from({ length }, (_, index) => ({
+        ...(conceptList[index] ? { concept: conceptList[index] } : {}),
+        ...(referenceList[index] ? { reference: referenceList[index] } : {}),
+    }));
+};
+const conceptsFromCodeableReferences = (value) => conceptsToCsv((Array.isArray(value) ? value : []).map(item => item?.concept));
+const referencesFromCodeableReferences = (value) => referenceListToCsv((Array.isArray(value) ? value : []).map(item => item?.reference ?? {}));
+/** Materializes canonical Schedule claims as native FHIR R5. */
+export function scheduleFlatToFhirR5(claims) {
+    return {
+        resourceType: 'Schedule',
+        identifier: claims[ScheduleClaim.Identifier] ? [identifierFromValue(claims[ScheduleClaim.Identifier])] : undefined,
+        active: claims[ScheduleClaim.Active] === undefined ? undefined : claims[ScheduleClaim.Active] === 'true',
+        serviceCategory: conceptsFromCsv(claims[ScheduleClaim.ServiceCategory]),
+        serviceType: codeableReferencesFromClaims(claims[ScheduleClaim.ServiceType], claims[ScheduleClaim.ServiceTypeReference]),
+        specialty: conceptsFromCsv(claims[ScheduleClaim.Specialty]),
+        name: claims[ScheduleClaim.Name],
+        actor: referencesFromCsv(claims[ScheduleClaim.Actor]),
+        planningHorizon: claims[ScheduleClaim.PlanningHorizonStart] || claims[ScheduleClaim.PlanningHorizonEnd]
+            ? { start: claims[ScheduleClaim.PlanningHorizonStart], end: claims[ScheduleClaim.PlanningHorizonEnd] }
+            : undefined,
+        comment: claims[ScheduleClaim.Comment],
+    };
+}
+/** Extracts official Schedule search claims plus required materialization fields. */
+export function scheduleFhirR5ToFlat(resource) {
+    const planningHorizon = resource.planningHorizon;
+    return {
+        [ScheduleClaim.Identifier]: identifierToValue(resource.identifier?.[0]),
+        [ScheduleClaim.Active]: resource.active === undefined ? undefined : String(resource.active),
+        [ScheduleClaim.ServiceCategory]: conceptsToCsv(resource.serviceCategory),
+        [ScheduleClaim.ServiceType]: conceptsFromCodeableReferences(resource.serviceType),
+        [ScheduleClaim.ServiceTypeReference]: referencesFromCodeableReferences(resource.serviceType),
+        [ScheduleClaim.Specialty]: conceptsToCsv(resource.specialty),
+        [ScheduleClaim.Name]: resource.name,
+        [ScheduleClaim.Actor]: referenceListToCsv(resource.actor),
+        [ScheduleClaim.PlanningHorizonStart]: planningHorizon?.start,
+        [ScheduleClaim.PlanningHorizonEnd]: planningHorizon?.end,
+        [ScheduleClaim.Comment]: resource.comment,
+    };
+}
+/** Materializes canonical Slot claims as native FHIR R5. */
+export function slotFlatToFhirR5(claims) {
+    return {
+        resourceType: 'Slot',
+        identifier: claims[SlotClaim.Identifier] ? [identifierFromValue(claims[SlotClaim.Identifier])] : undefined,
+        serviceCategory: conceptsFromCsv(claims[SlotClaim.ServiceCategory]),
+        serviceType: codeableReferencesFromClaims(claims[SlotClaim.ServiceType], claims[SlotClaim.ServiceTypeReference]),
+        specialty: conceptsFromCsv(claims[SlotClaim.Specialty]),
+        appointmentType: conceptsFromCsv(claims[SlotClaim.AppointmentType]),
+        schedule: claims[SlotClaim.Schedule] ? { reference: claims[SlotClaim.Schedule] } : undefined,
+        status: claims[SlotClaim.Status],
+        start: claims[SlotClaim.Start],
+        end: claims[SlotClaim.End],
+        overbooked: claims[SlotClaim.Overbooked] === undefined ? undefined : claims[SlotClaim.Overbooked] === 'true',
+        comment: claims[SlotClaim.Comment],
+    };
+}
+/** Extracts official Slot search claims plus required materialization fields. */
+export function slotFhirR5ToFlat(resource) {
+    return {
+        [SlotClaim.Identifier]: identifierToValue(resource.identifier?.[0]),
+        [SlotClaim.ServiceCategory]: conceptsToCsv(resource.serviceCategory),
+        [SlotClaim.ServiceType]: conceptsFromCodeableReferences(resource.serviceType),
+        [SlotClaim.ServiceTypeReference]: referencesFromCodeableReferences(resource.serviceType),
+        [SlotClaim.Specialty]: conceptsToCsv(resource.specialty),
+        [SlotClaim.AppointmentType]: conceptsToCsv(resource.appointmentType),
+        [SlotClaim.Schedule]: referenceToValue(resource.schedule),
+        [SlotClaim.Status]: resource.status,
+        [SlotClaim.Start]: resource.start,
+        [SlotClaim.End]: resource.end,
+        [SlotClaim.Overbooked]: resource.overbooked === undefined ? undefined : String(resource.overbooked),
+        [SlotClaim.Comment]: resource.comment,
+    };
+}

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

@@ -15,6 +15,16 @@ export declare function codingToValue(coding?: {
     system?: string;
     code?: string;
 }): string | undefined;
+/** Materializes one canonical FHIR token as an Identifier without losing its system. */
+export declare function identifierFromValue(value?: string): {
+    system?: string;
+    value: string;
+} | undefined;
+/** Extracts one Identifier as the canonical `system|value` token used by search claims. */
+export declare function identifierToValue(identifier?: {
+    system?: string;
+    value?: string;
+}): string | undefined;
 export declare function referenceToValue(reference?: {
     reference?: string;
 }): string | undefined;

package/dist/converters/convert-shared.js

@@ -25,6 +25,25 @@ export function codingToValue(coding) {
         return undefined;
     return coding.system ? `${coding.system}|${coding.code}` : coding.code;
 }
+/** Materializes one canonical FHIR token as an Identifier without losing its system. */
+export function identifierFromValue(value) {
+    if (!value)
+        return undefined;
+    const separator = value.indexOf('|');
+    if (separator < 0)
+        return { value };
+    const system = value.slice(0, separator).trim();
+    const identifierValue = value.slice(separator + 1).trim();
+    if (!identifierValue)
+        return undefined;
+    return system ? { system, value: identifierValue } : { value: identifierValue };
+}
+/** Extracts one Identifier as the canonical `system|value` token used by search claims. */
+export function identifierToValue(identifier) {
+    if (!identifier?.value)
+        return undefined;
+    return identifier.system ? `${identifier.system}|${identifier.value}` : identifier.value;
+}
 export function referenceToValue(reference) {
     return reference?.reference;
 }

package/dist/converters/index.d.ts

@@ -2,6 +2,7 @@ export * from './convert-shared.js';
 export * from './convert-allergy-intolerance.js';
 export * from './convert-appointment-response.js';
 export * from './convert-appointment.js';
+export * from './convert-appointment-communication.js';
 export * from './convert-care-plan.js';
 export * from './convert-clinical-impression.js';
 export * from './convert-communication-request.js';
@@ -11,17 +12,23 @@ export * from './convert-condition.js';
 export * from './convert-coverage.js';
 export * from './convert-device-use-statement.js';
 export * from './convert-device.js';
+export * from './convert-device-metric.js';
 export * from './convert-diagnostic-report.js';
 export * from './convert-document-reference.js';
 export * from './convert-encounter.js';
+export * from './convert-encounter-history.js';
 export * from './convert-flag.js';
 export * from './convert-immunization.js';
 export * from './convert-imaging-study.js';
 export * from './convert-location.js';
+export * from './convert-healthcare-service.js';
 export * from './convert-medication-statement.js';
 export * from './convert-observation.js';
 export * from './convert-organization.js';
 export * from './convert-practitioner-role.js';
 export * from './convert-procedure.js';
+export * from './convert-regulated-authorization.js';
 export * from './convert-related-person.js';
 export * from './convert-service-request.js';
+export * from './convert-schedule-slot.js';
+export * from './materialize-claims-first-resource.js';