fhir-data-utils-ts 0.4.0 → 0.6.1

package/dist/claims/location-claims.js

@@ -18,6 +18,9 @@ export const LocationClaim = {
     PhysicalType: 'Location.physical-type',
     ManagingOrganization: 'Location.managing-organization',
     PartOf: 'Location.part-of',
+    PositionLongitude: 'Location.position-longitude',
+    PositionLatitude: 'Location.position-latitude',
+    PositionAltitude: 'Location.position-altitude',
 };
 export const LocationClaimSpecs = [
     { key: LocationClaim.Identifier, meaning: 'Business identifier.', example: 'room-201' },
@@ -31,4 +34,7 @@ export const LocationClaimSpecs = [
     { key: LocationClaim.PhysicalType, meaning: 'Physical type token.', example: 'http://terminology.hl7.org/CodeSystem/location-physical-type|ro' },
     { key: LocationClaim.ManagingOrganization, meaning: 'Managing organization reference.', example: 'Organization/dept-cardiology-001' },
     { key: LocationClaim.PartOf, meaning: 'Parent location reference.', example: 'Location/building-a' },
+    { key: LocationClaim.PositionLongitude, meaning: 'WGS84 longitude in decimal degrees.', example: '-123.1207' },
+    { key: LocationClaim.PositionLatitude, meaning: 'WGS84 latitude in decimal degrees.', example: '49.2827' },
+    { key: LocationClaim.PositionAltitude, meaning: 'Altitude in metres.', example: '12.5' },
 ];

package/dist/claims/organization-claims.d.ts

@@ -2,13 +2,15 @@ import type { ClaimSpec } from './claim-types.js';
 /**
  * Flat claim keys for `Organization`.
  *
- * Use this resource for departments, services, clinics, or legal entities.
+ * Use this resource for legal entities, suborganizations and departments.
+ * A service offered by one of them is a separate `HealthcareService`.
  */
 export declare const OrganizationClaim: {
     readonly Identifier: "Organization.identifier";
     readonly Active: "Organization.active";
     readonly Type: "Organization.type";
     readonly Name: "Organization.name";
+    readonly Description: "Organization.description";
     readonly Alias: "Organization.alias";
     readonly PartOf: "Organization.part-of";
     readonly Telecom: "Organization.telecom";

package/dist/claims/organization-claims.js

@@ -3,13 +3,15 @@
 /**
  * Flat claim keys for `Organization`.
  *
- * Use this resource for departments, services, clinics, or legal entities.
+ * Use this resource for legal entities, suborganizations and departments.
+ * A service offered by one of them is a separate `HealthcareService`.
  */
 export const OrganizationClaim = {
     Identifier: 'Organization.identifier',
     Active: 'Organization.active',
     Type: 'Organization.type',
     Name: 'Organization.name',
+    Description: 'Organization.description',
     Alias: 'Organization.alias',
     PartOf: 'Organization.part-of',
     Telecom: 'Organization.telecom',
@@ -20,6 +22,7 @@ export const OrganizationClaimSpecs = [
     { key: OrganizationClaim.Active, meaning: 'Active flag.', example: 'true' },
     { key: OrganizationClaim.Type, meaning: 'Organization type token.', example: 'http://terminology.hl7.org/CodeSystem/organization-type|dept' },
     { key: OrganizationClaim.Name, meaning: 'Display name.', example: 'Cardiology Department' },
+    { key: OrganizationClaim.Description, meaning: 'Consumer-facing department description materialized in FHIR R5.', example: 'Specialist cardiovascular care.' },
     { key: OrganizationClaim.Alias, meaning: 'Alternate names as CSV.', example: 'Cardiology,Heart Clinic' },
     { key: OrganizationClaim.PartOf, meaning: 'Parent organization reference.', example: 'Organization/hospital-1' },
     { key: OrganizationClaim.Telecom, meaning: 'Contact values as CSV.', example: 'tel:+16045550101,mailto:cardiology@example.org' },

package/dist/claims/procedure-claims.d.ts

@@ -7,6 +7,7 @@ export declare const ProcedureClaim: {
     readonly CodeDisplay: "Procedure.code-display";
     readonly Date: "Procedure.date";
     readonly Encounter: "Procedure.encounter";
+    readonly FocalDevice: "Procedure.focal-device";
     readonly Identifier: "Procedure.identifier";
     readonly InstantiatesCanonical: "Procedure.instantiates-canonical";
     readonly InstantiatesUri: "Procedure.instantiates-uri";
@@ -16,6 +17,7 @@ export declare const ProcedureClaim: {
     readonly Performer: "Procedure.performer";
     readonly ReasonCode: "Procedure.reason-code";
     readonly ReasonReference: "Procedure.reason-reference";
+    readonly Report: "Procedure.report";
     readonly Status: "Procedure.status";
     readonly Subject: "Procedure.subject";
     readonly Note: "Procedure.note";

package/dist/claims/procedure-claims.js

@@ -8,6 +8,7 @@ export const ProcedureClaim = {
     CodeDisplay: 'Procedure.code-display',
     Date: 'Procedure.date',
     Encounter: 'Procedure.encounter',
+    FocalDevice: 'Procedure.focal-device',
     Identifier: 'Procedure.identifier',
     InstantiatesCanonical: 'Procedure.instantiates-canonical',
     InstantiatesUri: 'Procedure.instantiates-uri',
@@ -17,6 +18,7 @@ export const ProcedureClaim = {
     Performer: 'Procedure.performer',
     ReasonCode: 'Procedure.reason-code',
     ReasonReference: 'Procedure.reason-reference',
+    Report: 'Procedure.report',
     Status: 'Procedure.status',
     Subject: 'Procedure.subject',
     Note: 'Procedure.note',
@@ -29,6 +31,7 @@ export const ProcedureClaimSpecs = [
     { key: ProcedureClaim.CodeDisplay, meaning: 'Canonical/international procedure display label.', example: 'Appendectomy' },
     { key: ProcedureClaim.Date, meaning: 'Performed date/time.', example: '2026-06-01T10:00:00Z' },
     { key: ProcedureClaim.Encounter, meaning: 'Encounter reference.', example: 'Encounter/enc-1' },
+    { key: ProcedureClaim.FocalDevice, meaning: 'Device manipulated, calibrated, installed or otherwise changed by the procedure.', example: 'Device/device-1' },
     { key: ProcedureClaim.Identifier, meaning: 'Business identifier.', example: 'procedure-001' },
     { key: ProcedureClaim.InstantiatesCanonical, meaning: 'Instantiated canonical plan/protocol.', example: 'http://example.org/PlanDefinition/appendectomy' },
     { key: ProcedureClaim.InstantiatesUri, meaning: 'Instantiated URI.', example: 'urn:procedure-protocol:appendectomy' },
@@ -38,6 +41,7 @@ export const ProcedureClaimSpecs = [
     { key: ProcedureClaim.Performer, meaning: 'Performer references (CSV).', example: 'Practitioner/prac-1' },
     { key: ProcedureClaim.ReasonCode, meaning: 'Reason code token.', example: 'http://snomed.info/sct|233604007' },
     { key: ProcedureClaim.ReasonReference, meaning: 'Reason reference.', example: 'Condition/cond-1' },
+    { key: ProcedureClaim.Report, meaning: 'Resulting report or evidence references.', example: 'DocumentReference/report-1' },
     { key: ProcedureClaim.Status, meaning: 'Procedure status.', example: 'completed' },
     { key: ProcedureClaim.Subject, meaning: 'Canonical subject reference.', example: 'did:web:patient.example.org' },
     { key: ProcedureClaim.Note, meaning: 'Clinical note text.', example: 'Procedure tolerated well.' },

package/dist/claims/regulated-authorization-claims.d.ts

@@ -0,0 +1,17 @@
+import type { ClaimSpec } from './claim-types.js';
+/** Canonical flat claims for the FHIR R5 RegulatedAuthorization resource. */
+export declare const RegulatedAuthorizationClaim: {
+    readonly Identifier: "RegulatedAuthorization.identifier";
+    readonly Subject: "RegulatedAuthorization.subject";
+    readonly Type: "RegulatedAuthorization.type";
+    readonly Region: "RegulatedAuthorization.region";
+    readonly Status: "RegulatedAuthorization.status";
+    readonly StatusDate: "RegulatedAuthorization.status-date";
+    readonly ValidityStart: "RegulatedAuthorization.validity-start";
+    readonly ValidityEnd: "RegulatedAuthorization.validity-end";
+    readonly Basis: "RegulatedAuthorization.basis";
+    readonly Holder: "RegulatedAuthorization.holder";
+    readonly Regulator: "RegulatedAuthorization.regulator";
+};
+export type RegulatedAuthorizationClaimKey = typeof RegulatedAuthorizationClaim[keyof typeof RegulatedAuthorizationClaim];
+export declare const RegulatedAuthorizationClaimSpecs: readonly ClaimSpec[];

package/dist/claims/regulated-authorization-claims.js

@@ -0,0 +1,27 @@
+/** Canonical flat claims for the FHIR R5 RegulatedAuthorization resource. */
+export const RegulatedAuthorizationClaim = {
+    Identifier: 'RegulatedAuthorization.identifier',
+    Subject: 'RegulatedAuthorization.subject',
+    Type: 'RegulatedAuthorization.type',
+    Region: 'RegulatedAuthorization.region',
+    Status: 'RegulatedAuthorization.status',
+    StatusDate: 'RegulatedAuthorization.status-date',
+    ValidityStart: 'RegulatedAuthorization.validity-start',
+    ValidityEnd: 'RegulatedAuthorization.validity-end',
+    Basis: 'RegulatedAuthorization.basis',
+    Holder: 'RegulatedAuthorization.holder',
+    Regulator: 'RegulatedAuthorization.regulator',
+};
+export const RegulatedAuthorizationClaimSpecs = Object.freeze([
+    { key: RegulatedAuthorizationClaim.Identifier, meaning: 'Identifier assigned by the authorizing body.', example: 'authorization-1' },
+    { key: RegulatedAuthorizationClaim.Subject, meaning: 'Authorized product type, facility or activity reference.', example: 'Location/location-1' },
+    { key: RegulatedAuthorizationClaim.Type, meaning: 'Authorization type coding token.', example: 'https://example.invalid/codes|operation' },
+    { key: RegulatedAuthorizationClaim.Region, meaning: 'Jurisdiction coding token.', example: 'urn:iso:std:iso:3166|CA' },
+    { key: RegulatedAuthorizationClaim.Status, meaning: 'Authorization publication status.', example: 'active' },
+    { key: RegulatedAuthorizationClaim.StatusDate, meaning: 'Date the status was assigned.', example: '2026-09-29T16:00:00Z' },
+    { key: RegulatedAuthorizationClaim.ValidityStart, meaning: 'Authorization validity start.', example: '2026-09-29' },
+    { key: RegulatedAuthorizationClaim.ValidityEnd, meaning: 'Authorization validity end.', example: '2027-09-29' },
+    { key: RegulatedAuthorizationClaim.Basis, meaning: 'Regulatory basis coding token.', example: 'https://example.invalid/codes|installed-device' },
+    { key: RegulatedAuthorizationClaim.Holder, meaning: 'Organization granted the authorization.', example: 'Organization/holder-1' },
+    { key: RegulatedAuthorizationClaim.Regulator, meaning: 'Regulatory authority granting the authorization.', example: 'Organization/regulator-1' },
+]);

package/dist/claims/schedule-slot-claims.d.ts

@@ -0,0 +1,45 @@
+import type { ClaimSpec } from './claim-types.js';
+/** Canonical flat claims for the official FHIR R5 Schedule search surface. */
+export declare const ScheduleClaim: Readonly<{
+    readonly Active: "Schedule.active";
+    readonly Actor: "Schedule.actor";
+    readonly Date: "Schedule.date";
+    readonly Identifier: "Schedule.identifier";
+    readonly Name: "Schedule.name";
+    readonly ServiceCategory: "Schedule.service-category";
+    readonly ServiceType: "Schedule.service-type";
+    readonly ServiceTypeReference: "Schedule.service-type-reference";
+    readonly Specialty: "Schedule.specialty";
+    readonly PlanningHorizonStart: "Schedule.planning-horizon-start";
+    readonly PlanningHorizonEnd: "Schedule.planning-horizon-end";
+    readonly Comment: "Schedule.comment";
+}>;
+/** Canonical flat claims for the official FHIR R5 Slot search surface. */
+export declare const SlotClaim: Readonly<{
+    readonly AppointmentType: "Slot.appointment-type";
+    readonly Identifier: "Slot.identifier";
+    readonly Schedule: "Slot.schedule";
+    readonly ServiceCategory: "Slot.service-category";
+    readonly ServiceType: "Slot.service-type";
+    readonly ServiceTypeReference: "Slot.service-type-reference";
+    readonly Specialty: "Slot.specialty";
+    readonly Start: "Slot.start";
+    readonly Status: "Slot.status";
+    readonly End: "Slot.end";
+    readonly Overbooked: "Slot.overbooked";
+    readonly Comment: "Slot.comment";
+}>;
+export declare const ScheduleR5SearchParameterCatalog: readonly Readonly<{
+    claim: `${string}.${string}`;
+    resourceType: string;
+    elementPath: string;
+    type: import("../search-parameters.js").FlatSearchParameterType;
+}>[];
+export declare const SlotR5SearchParameterCatalog: readonly Readonly<{
+    claim: `${string}.${string}`;
+    resourceType: string;
+    elementPath: string;
+    type: import("../search-parameters.js").FlatSearchParameterType;
+}>[];
+export declare const ScheduleClaimSpecs: readonly ClaimSpec[];
+export declare const SlotClaimSpecs: readonly ClaimSpec[];

package/dist/claims/schedule-slot-claims.js

@@ -0,0 +1,70 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { defineFlatSearchParameter } from '../search-parameters.js';
+/** Canonical flat claims for the official FHIR R5 Schedule search surface. */
+export const ScheduleClaim = Object.freeze({
+    Active: 'Schedule.active',
+    Actor: 'Schedule.actor',
+    Date: 'Schedule.date',
+    Identifier: 'Schedule.identifier',
+    Name: 'Schedule.name',
+    ServiceCategory: 'Schedule.service-category',
+    ServiceType: 'Schedule.service-type',
+    ServiceTypeReference: 'Schedule.service-type-reference',
+    Specialty: 'Schedule.specialty',
+    PlanningHorizonStart: 'Schedule.planning-horizon-start',
+    PlanningHorizonEnd: 'Schedule.planning-horizon-end',
+    Comment: 'Schedule.comment',
+});
+/** Canonical flat claims for the official FHIR R5 Slot search surface. */
+export const SlotClaim = Object.freeze({
+    AppointmentType: 'Slot.appointment-type',
+    Identifier: 'Slot.identifier',
+    Schedule: 'Slot.schedule',
+    ServiceCategory: 'Slot.service-category',
+    ServiceType: 'Slot.service-type',
+    ServiceTypeReference: 'Slot.service-type-reference',
+    Specialty: 'Slot.specialty',
+    Start: 'Slot.start',
+    Status: 'Slot.status',
+    End: 'Slot.end',
+    Overbooked: 'Slot.overbooked',
+    Comment: 'Slot.comment',
+});
+export const ScheduleR5SearchParameterCatalog = Object.freeze([
+    defineFlatSearchParameter({ claim: ScheduleClaim.Active, resourceType: 'Schedule', elementPath: 'Schedule.active', type: 'token' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.Actor, resourceType: 'Schedule', elementPath: 'Schedule.actor', type: 'reference' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.Date, resourceType: 'Schedule', elementPath: 'Schedule.planningHorizon', type: 'date' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.Identifier, resourceType: 'Schedule', elementPath: 'Schedule.identifier', type: 'token' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.Name, resourceType: 'Schedule', elementPath: 'Schedule.name', type: 'string' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.ServiceCategory, resourceType: 'Schedule', elementPath: 'Schedule.serviceCategory', type: 'token' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.ServiceType, resourceType: 'Schedule', elementPath: 'Schedule.serviceType.concept', type: 'token' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.ServiceTypeReference, resourceType: 'Schedule', elementPath: 'Schedule.serviceType.reference', type: 'reference' }),
+    defineFlatSearchParameter({ claim: ScheduleClaim.Specialty, resourceType: 'Schedule', elementPath: 'Schedule.specialty', type: 'token' }),
+]);
+export const SlotR5SearchParameterCatalog = Object.freeze([
+    defineFlatSearchParameter({ claim: SlotClaim.AppointmentType, resourceType: 'Slot', elementPath: 'Slot.appointmentType', type: 'token' }),
+    defineFlatSearchParameter({ claim: SlotClaim.Identifier, resourceType: 'Slot', elementPath: 'Slot.identifier', type: 'token' }),
+    defineFlatSearchParameter({ claim: SlotClaim.Schedule, resourceType: 'Slot', elementPath: 'Slot.schedule', type: 'reference' }),
+    defineFlatSearchParameter({ claim: SlotClaim.ServiceCategory, resourceType: 'Slot', elementPath: 'Slot.serviceCategory', type: 'token' }),
+    defineFlatSearchParameter({ claim: SlotClaim.ServiceType, resourceType: 'Slot', elementPath: 'Slot.serviceType.concept', type: 'token' }),
+    defineFlatSearchParameter({ claim: SlotClaim.ServiceTypeReference, resourceType: 'Slot', elementPath: 'Slot.serviceType.reference', type: 'reference' }),
+    defineFlatSearchParameter({ claim: SlotClaim.Specialty, resourceType: 'Slot', elementPath: 'Slot.specialty', type: 'token' }),
+    defineFlatSearchParameter({ claim: SlotClaim.Start, resourceType: 'Slot', elementPath: 'Slot.start', type: 'date' }),
+    defineFlatSearchParameter({ claim: SlotClaim.Status, resourceType: 'Slot', elementPath: 'Slot.status', type: 'token' }),
+]);
+export const ScheduleClaimSpecs = Object.freeze([
+    { key: ScheduleClaim.Identifier, meaning: 'Logical schedule identifier.', example: 'urn:uuid:blood-donation-weekday' },
+    { key: ScheduleClaim.Active, meaning: 'Whether this schedule is in active use.', example: 'true' },
+    { key: ScheduleClaim.Actor, meaning: 'Repeatable independently schedulable actors as CSV references.', example: 'HealthcareService/blood-donation,Location/blood-donation-room' },
+    { key: ScheduleClaim.ServiceType, meaning: 'Repeatable service-type concept tokens as CSV.', example: 'http://terminology.hl7.org/CodeSystem/service-type|117' },
+    { key: ScheduleClaim.ServiceTypeReference, meaning: 'Repeatable HealthcareService references corresponding to service-type concepts.', example: 'HealthcareService/blood-donation' },
+    { key: ScheduleClaim.PlanningHorizonStart, meaning: 'Start of the period covered by this schedule.', example: '2026-10-01' },
+    { key: ScheduleClaim.PlanningHorizonEnd, meaning: 'End of the period covered by this schedule.', example: '2026-10-31' },
+]);
+export const SlotClaimSpecs = Object.freeze([
+    { key: SlotClaim.Identifier, meaning: 'Logical slot identifier.', example: 'urn:uuid:blood-20261001-0900' },
+    { key: SlotClaim.Schedule, meaning: 'The Schedule that owns this independent slot.', example: 'Schedule/blood-donation-weekday' },
+    { key: SlotClaim.Status, meaning: 'FHIR Slot status.', example: 'free' },
+    { key: SlotClaim.Start, meaning: 'Start instant.', example: '2026-10-01T09:00:00Z' },
+    { key: SlotClaim.End, meaning: 'End instant; duration is derived from start and end.', example: '2026-10-01T09:15:00Z' },
+]);

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

@@ -25,6 +25,7 @@ export declare const ResourceTypesFhirR4: Readonly<{
     readonly Encounter: "Encounter";
     readonly Flag: "Flag";
     readonly Group: "Group";
+    readonly HealthcareService: "HealthcareService";
     readonly ImagingStudy: "ImagingStudy";
     readonly Immunization: "Immunization";
     readonly ImmunizationRecommendation: "ImmunizationRecommendation";
@@ -47,7 +48,9 @@ export declare const ResourceTypesFhirR4: Readonly<{
     readonly RelatedPerson: "RelatedPerson";
     readonly ResearchStudy: "ResearchStudy";
     readonly ResearchSubject: "ResearchSubject";
+    readonly Schedule: "Schedule";
     readonly Specimen: "Specimen";
+    readonly Slot: "Slot";
     readonly ServiceRequest: "ServiceRequest";
     readonly Task: "Task";
     readonly DetectedIssue: "DetectedIssue";
@@ -81,6 +84,7 @@ export declare const FhirResourceTypes: Readonly<{
     readonly Encounter: "Encounter";
     readonly Flag: "Flag";
     readonly Group: "Group";
+    readonly HealthcareService: "HealthcareService";
     readonly ImagingStudy: "ImagingStudy";
     readonly Immunization: "Immunization";
     readonly ImmunizationRecommendation: "ImmunizationRecommendation";
@@ -103,13 +107,16 @@ export declare const FhirResourceTypes: Readonly<{
     readonly RelatedPerson: "RelatedPerson";
     readonly ResearchStudy: "ResearchStudy";
     readonly ResearchSubject: "ResearchSubject";
+    readonly Schedule: "Schedule";
     readonly Specimen: "Specimen";
+    readonly Slot: "Slot";
     readonly ServiceRequest: "ServiceRequest";
     readonly Task: "Task";
     readonly DetectedIssue: "DetectedIssue";
 }>;
 /** FHIR R5-only resources currently emitted by shared subscription contracts. */
 export declare const ResourceTypesFhirR5: Readonly<{
+    readonly EncounterHistory: "EncounterHistory";
     readonly Subscription: "Subscription";
     readonly SubscriptionTopic: "SubscriptionTopic";
     readonly SubscriptionStatus: "SubscriptionStatus";
@@ -133,6 +140,7 @@ export declare const ResourceTypesFhirR5: Readonly<{
     readonly Encounter: "Encounter";
     readonly Flag: "Flag";
     readonly Group: "Group";
+    readonly HealthcareService: "HealthcareService";
     readonly ImagingStudy: "ImagingStudy";
     readonly Immunization: "Immunization";
     readonly ImmunizationRecommendation: "ImmunizationRecommendation";
@@ -155,7 +163,9 @@ export declare const ResourceTypesFhirR5: Readonly<{
     readonly RelatedPerson: "RelatedPerson";
     readonly ResearchStudy: "ResearchStudy";
     readonly ResearchSubject: "ResearchSubject";
+    readonly Schedule: "Schedule";
     readonly Specimen: "Specimen";
+    readonly Slot: "Slot";
     readonly ServiceRequest: "ServiceRequest";
     readonly Task: "Task";
     readonly DetectedIssue: "DetectedIssue";

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

@@ -25,6 +25,7 @@ export const ResourceTypesFhirR4 = Object.freeze({
     Encounter: 'Encounter',
     Flag: 'Flag',
     Group: 'Group',
+    HealthcareService: 'HealthcareService',
     ImagingStudy: 'ImagingStudy',
     Immunization: 'Immunization',
     ImmunizationRecommendation: 'ImmunizationRecommendation',
@@ -47,7 +48,9 @@ export const ResourceTypesFhirR4 = Object.freeze({
     RelatedPerson: 'RelatedPerson',
     ResearchStudy: 'ResearchStudy',
     ResearchSubject: 'ResearchSubject',
+    Schedule: 'Schedule',
     Specimen: 'Specimen',
+    Slot: 'Slot',
     ServiceRequest: 'ServiceRequest',
     Task: 'Task',
     DetectedIssue: 'DetectedIssue',
@@ -62,6 +65,7 @@ export const FhirResourceTypes = ResourceTypesFhirR4;
 /** FHIR R5-only resources currently emitted by shared subscription contracts. */
 export const ResourceTypesFhirR5 = Object.freeze({
     ...ResourceTypesFhirR4,
+    EncounterHistory: 'EncounterHistory',
     Subscription: 'Subscription',
     SubscriptionTopic: 'SubscriptionTopic',
     SubscriptionStatus: 'SubscriptionStatus',

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

@@ -0,0 +1,14 @@
+import { type FlatClaimResourceEntry } from '../flat-claim-resource-graph.js';
+export type SupportedAppointmentFhirRelease = 'r4' | 'r5';
+export type AppointmentCommunicationFlatGraph = Readonly<{
+    communications: readonly FlatClaimResourceEntry[];
+    appointments: readonly FlatClaimResourceEntry[];
+    documentReferences: readonly FlatClaimResourceEntry[];
+    entries: readonly FlatClaimResourceEntry[];
+}>;
+/**
+ * Projects a validated appointment exchange into independently persisted flat
+ * claim resources. Transport parsing is delegated to the shared Bundle Reader;
+ * native FHIR remains an adapter input and is never persisted beside claims.
+ */
+export declare function projectAppointmentCommunicationBatchToFlatGraph(input: unknown, release: SupportedAppointmentFhirRelease): AppointmentCommunicationFlatGraph;

package/dist/converters/convert-appointment-communication.js

@@ -0,0 +1,97 @@
+import { AppointmentClaim } from '../claims/appointment-claims.js';
+import { CommunicationClaim } from '../claims/communication-claims.js';
+import { DocumentReferenceClaim } from '../claims/document-reference-claims.js';
+import { readBundleResources, readCommunicationBundlePayloads } from '../fhir-bundle.js';
+import { buildFlatClaimResourceEntry } from '../flat-claim-resource-graph.js';
+import { appointmentFhirR4ToFlat } from './convert-appointment.js';
+import { documentReferenceFhirR4ToFlat } from './convert-document-reference.js';
+/**
+ * Projects a validated appointment exchange into independently persisted flat
+ * claim resources. Transport parsing is delegated to the shared Bundle Reader;
+ * native FHIR remains an adapter input and is never persisted beside claims.
+ */
+export function projectAppointmentCommunicationBatchToFlatGraph(input, release) {
+    if (release !== 'r4' && release !== 'r5')
+        throw new TypeError('fhir_release_unsupported');
+    const communications = [];
+    const appointments = [];
+    const documentReferences = [];
+    for (const { communication, attachment, bundle } of readCommunicationBundlePayloads(input)) {
+        const communicationId = resourceId(communication, 'communication_identifier_required');
+        communications.push(buildFlatClaimResourceEntry({
+            entryId: communicationId,
+            resourceType: 'Communication',
+            claims: compactClaims({
+                [CommunicationClaim.Identifier]: communicationId,
+                [CommunicationClaim.Status]: stringValue(communication.status),
+                [CommunicationClaim.Subject]: referenceValue(communication.subject),
+                [CommunicationClaim.Recipient]: referenceList(communication.recipient),
+                [CommunicationClaim.Sender]: referenceValue(communication.sender),
+                [CommunicationClaim.Sent]: stringValue(communication.sent),
+                [CommunicationClaim.ContentAttachmentType]: attachment.contentType,
+                [CommunicationClaim.ContentAttachmentData]: attachment.data,
+                [CommunicationClaim.ContentAttachmentTitle]: attachment.title,
+            }),
+        }));
+        for (const child of readBundleResources(bundle)) {
+            if (child.resourceType === 'Appointment') {
+                const entryId = resourceId(child, 'appointment_identifier_required');
+                const structural = appointmentFhirR4ToFlat(child);
+                appointments.push(buildFlatClaimResourceEntry({
+                    entryId,
+                    resourceType: 'Appointment',
+                    claims: compactClaims({
+                        ...structural,
+                        [AppointmentClaim.Identifier]: structural[AppointmentClaim.Identifier] || entryId,
+                    }),
+                }));
+            }
+            else if (child.resourceType === 'DocumentReference') {
+                const entryId = resourceId(child, 'document_reference_identifier_required');
+                const structural = documentReferenceFhirR4ToFlat(child);
+                documentReferences.push(buildFlatClaimResourceEntry({
+                    entryId,
+                    resourceType: 'DocumentReference',
+                    claims: compactClaims({
+                        ...structural,
+                        [DocumentReferenceClaim.Identifier]: structural[DocumentReferenceClaim.Identifier] || entryId,
+                    }),
+                }));
+            }
+        }
+    }
+    return Object.freeze({
+        communications: Object.freeze(communications),
+        appointments: Object.freeze(appointments),
+        documentReferences: Object.freeze(documentReferences),
+        entries: Object.freeze([...communications, ...appointments, ...documentReferences]),
+    });
+}
+function resourceId(resource, error) {
+    const identifier = Array.isArray(resource.identifier)
+        ? resource.identifier.find(item => typeof item?.value === 'string')?.value
+        : undefined;
+    const value = String(resource.id || identifier || '').trim();
+    if (!value)
+        throw new TypeError(error);
+    return value;
+}
+function compactClaims(input) {
+    return Object.freeze(Object.fromEntries(Object.entries(input)
+        .filter((entry) => entry[1] !== undefined && entry[1] !== null && String(entry[1]).trim() !== '')
+        .map(([name, value]) => [name, String(value).trim()])));
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function referenceValue(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return stringValue(value.reference);
+}
+function referenceList(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const references = value.map(referenceValue).filter((item) => Boolean(item));
+    return references.length ? [...new Set(references)].join(',') : undefined;
+}

package/dist/converters/convert-appointment.js

@@ -21,6 +21,8 @@ export function appointmentFlatToFhirR4(claims) {
         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,
+        slot: claims[AppointmentClaim.Slot] ? claims[AppointmentClaim.Slot].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
+        supportingInformation: claims[AppointmentClaim.SupportingInfo] ? claims[AppointmentClaim.SupportingInfo].split(',').map((reference) => ({ reference: reference.trim() })) : undefined,
         participant: claims[AppointmentClaim.ParticipantActor]
             ? claims[AppointmentClaim.ParticipantActor].split(',').map((reference) => ({
                 actor: { reference: reference.trim() },
@@ -32,11 +34,17 @@ export function appointmentFlatToFhirR4(claims) {
 }
 export function appointmentFhirR4ToFlat(resource) {
     const participant = Array.isArray(resource.participant) ? resource.participant[0] : undefined;
+    const actorReferences = Array.isArray(resource.participant)
+        ? resource.participant
+            .map((item) => referenceToValue(item?.actor))
+            .filter((item) => Boolean(item))
+        : [];
+    const serviceType = resource.serviceType?.[0];
     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.ServiceType]: codingToValue(serviceType?.concept?.coding?.[0] ?? serviceType?.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]),
@@ -49,13 +57,14 @@ export function appointmentFhirR4ToFlat(resource) {
         [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.ParticipantActor]: actorReferences.length ? actorReferences.join(',') : undefined,
         [AppointmentClaim.ParticipantStatus]: participant?.status,
         [AppointmentClaim.ParticipantType]: codingToValue(participant?.type?.[0]?.coding?.[0]),
+        [AppointmentClaim.Date]: resource.start,
+        [AppointmentClaim.Location]: actorReferences.filter(reference => reference.startsWith('Location/')).join(',') || undefined,
+        [AppointmentClaim.Patient]: actorReferences.filter(reference => reference.startsWith('Patient/')).join(',') || undefined,
+        [AppointmentClaim.Practitioner]: actorReferences.filter(reference => reference.startsWith('Practitioner/') || reference.startsWith('PractitionerRole/')).join(',') || undefined,
+        [AppointmentClaim.Slot]: referenceListToCsv(resource.slot),
+        [AppointmentClaim.SupportingInfo]: referenceListToCsv(resource.supportingInformation),
     };
 }

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

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

package/dist/converters/convert-device-metric.js

@@ -0,0 +1,37 @@
+import { DeviceMetricClaim } from '../claims/device-metric-claims.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+export function deviceMetricFlatToFhirR5(claims) {
+    const calibration = claims[DeviceMetricClaim.CalibrationType]
+        || claims[DeviceMetricClaim.CalibrationState]
+        || claims[DeviceMetricClaim.CalibrationTime]
+        ? [{
+                type: claims[DeviceMetricClaim.CalibrationType],
+                state: claims[DeviceMetricClaim.CalibrationState],
+                time: claims[DeviceMetricClaim.CalibrationTime],
+            }]
+        : undefined;
+    return {
+        resourceType: 'DeviceMetric',
+        identifier: claims[DeviceMetricClaim.Identifier] ? [{ value: claims[DeviceMetricClaim.Identifier] }] : undefined,
+        type: { coding: codingFromValue(claims[DeviceMetricClaim.Type]) },
+        unit: claims[DeviceMetricClaim.Unit] ? { coding: codingFromValue(claims[DeviceMetricClaim.Unit]) } : undefined,
+        device: claims[DeviceMetricClaim.Device] ? { reference: claims[DeviceMetricClaim.Device] } : undefined,
+        operationalStatus: claims[DeviceMetricClaim.OperationalStatus],
+        category: claims[DeviceMetricClaim.Category],
+        calibration,
+    };
+}
+export function deviceMetricFhirR5ToFlat(resource) {
+    const calibration = resource.calibration?.[0];
+    return {
+        [DeviceMetricClaim.Identifier]: resource.identifier?.[0]?.value,
+        [DeviceMetricClaim.Type]: codingToValue(resource.type?.coding?.[0]),
+        [DeviceMetricClaim.Unit]: codingToValue(resource.unit?.coding?.[0]),
+        [DeviceMetricClaim.Device]: referenceToValue(resource.device),
+        [DeviceMetricClaim.OperationalStatus]: resource.operationalStatus,
+        [DeviceMetricClaim.Category]: resource.category,
+        [DeviceMetricClaim.CalibrationType]: calibration?.type,
+        [DeviceMetricClaim.CalibrationState]: calibration?.state,
+        [DeviceMetricClaim.CalibrationTime]: calibration?.time,
+    };
+}

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

@@ -25,6 +25,9 @@ export function documentReferenceFlatToFhirR4(claims) {
             }
             : undefined,
         date: claims[DocumentReferenceClaim.Date],
+        context: claims[DocumentReferenceClaim.EventReference]
+            ? { related: claims[DocumentReferenceClaim.EventReference].split(',').map((reference) => ({ reference: reference.trim() })) }
+            : undefined,
         content: [{ attachment: {
                     contentType: claims[DocumentReferenceClaim.ContentType],
                     data: claims[DocumentReferenceClaim.ContentData],
@@ -45,6 +48,8 @@ export function documentReferenceFhirR4ToFlat(resource) {
         [DocumentReferenceClaim.TypeText]: resource.type?.text,
         [DocumentReferenceClaim.TypeDisplay]: resource.type?.coding?.[0]?.display,
         [DocumentReferenceClaim.Date]: resource.date,
+        [DocumentReferenceClaim.EventReference]: resource.context
+            ?.related?.map((related) => related.reference).filter((reference) => Boolean(reference)).join(',') || undefined,
         [DocumentReferenceClaim.ContentType]: attachment?.contentType,
         [DocumentReferenceClaim.ContentData]: attachment?.data,
         [DocumentReferenceClaim.Location]: attachment?.url,

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

@@ -0,0 +1,5 @@
+import type { FhirResource, FlatClaims } from './convert-shared.js';
+/** Materializes canonical EncounterHistory claims as native FHIR R5. */
+export declare function encounterHistoryFlatToFhirR5(claims: FlatClaims): FhirResource;
+/** Extracts supported native FHIR R5 EncounterHistory fields into flat claims. */
+export declare function encounterHistoryFhirR5ToFlat(resource: FhirResource): FlatClaims;