fhir-data-utils-ts 0.4.0 → 0.6.1

package/dist/builders/service-schedule-graph.d.ts

@@ -0,0 +1,58 @@
+export type ScheduleSlotGraphResource = Readonly<{
+    resourceType: 'Schedule' | 'Slot';
+    id: string;
+    meta: Readonly<{
+        claims: Readonly<Record<string, string | readonly string[]>>;
+    }>;
+}>;
+export type ServiceScheduleFlatGraphInput = Readonly<{
+    scheduleId: string;
+    scheduleIdentifier: string;
+    name: string;
+    healthcareServiceReference: string;
+    resourceActorReferences: readonly string[];
+    serviceType: string;
+    planningHorizon: Readonly<{
+        start: string;
+        end: string;
+    }>;
+    slots: readonly Readonly<{
+        slotId: string;
+        slotIdentifier: string;
+        status: 'busy' | 'free' | 'busy-unavailable' | 'busy-tentative' | 'entered-in-error';
+        start: string;
+        end: string;
+        overbooked?: boolean;
+        comment?: string;
+    }>[];
+}>;
+export type SchedulableLocationFlatResource = Readonly<{
+    resourceType: 'Location';
+    id: string;
+    meta: Readonly<{
+        claims: Readonly<Record<string, string>>;
+    }>;
+}>;
+/** Builds one claims-first Schedule and its independent Slot resources. */
+export declare function buildServiceScheduleFlatGraph(input: ServiceScheduleFlatGraphInput): readonly ScheduleSlotGraphResource[];
+/**
+ * Builds one reservable child place such as a room, booth, chair or bed.
+ *
+ * R4 projects `Location.physicalType`; R5 projects the same governed coding as
+ * `Location.form`. Equipment such as an apheresis machine remains a Device and
+ * is added independently to the Schedule actor list.
+ */
+export declare function buildSchedulableLocationFlatResource(input: Readonly<{
+    locationId: string;
+    locationIdentifier: string;
+    name: string;
+    status?: 'active' | 'suspended' | 'inactive';
+    form: string;
+    managingOrganizationReference: string;
+    parentLocationReference: string;
+    position?: Readonly<{
+        longitude: number;
+        latitude: number;
+        altitude?: number;
+    }>;
+}>): SchedulableLocationFlatResource;

package/dist/builders/service-schedule-graph.js

@@ -0,0 +1,149 @@
+import { ScheduleClaim, SlotClaim } from '../claims/schedule-slot-claims.js';
+import { LocationClaim } from '../claims/location-claims.js';
+const required = (value, error) => {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        throw new TypeError(error);
+    return normalized;
+};
+const id = (value) => {
+    const normalized = required(value, 'schedule_slot_id_required');
+    if (!/^[A-Za-z0-9.-]{1,64}$/.test(normalized))
+        throw new TypeError('schedule_slot_id_invalid');
+    return normalized;
+};
+const reference = (value, resourceType, error) => {
+    const normalized = required(value, error);
+    if (!normalized.startsWith(`${resourceType}/`) || normalized.length === resourceType.length + 1)
+        throw new TypeError(error);
+    return normalized;
+};
+const scheduleActorReference = (value) => {
+    const normalized = required(value, 'schedule_actor_reference_invalid');
+    if (!/^(?:Patient|Practitioner|PractitionerRole|CareTeam|RelatedPerson|Device|Location)\/[A-Za-z0-9.-]+$/.test(normalized)) {
+        throw new TypeError('schedule_actor_reference_invalid');
+    }
+    return normalized;
+};
+const token = (value) => {
+    const normalized = required(value, 'schedule_service_type_invalid');
+    const separator = normalized.lastIndexOf('|');
+    if (separator < 1 || separator === normalized.length - 1)
+        throw new TypeError('schedule_service_type_invalid');
+    return normalized;
+};
+const instant = (value, error) => {
+    const normalized = required(value, error);
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(normalized))
+        throw new TypeError(error);
+    return normalized;
+};
+const periodBoundary = (value, end) => {
+    const normalized = required(value, 'schedule_planning_horizon_invalid');
+    const timestamp = Date.parse(/^\d{4}-\d{2}-\d{2}$/.test(normalized)
+        ? `${normalized}T${end ? '23:59:59.999' : '00:00:00.000'}Z`
+        : normalized);
+    if (!Number.isFinite(timestamp))
+        throw new TypeError('schedule_planning_horizon_invalid');
+    return timestamp;
+};
+/** Builds one claims-first Schedule and its independent Slot resources. */
+export function buildServiceScheduleFlatGraph(input) {
+    const scheduleId = id(input.scheduleId);
+    const healthcareServiceReference = reference(input.healthcareServiceReference, 'HealthcareService', 'schedule_healthcare_service_reference_invalid');
+    const resourceActorReferences = [...new Set(input.resourceActorReferences.map(scheduleActorReference))];
+    if (!resourceActorReferences.length)
+        throw new TypeError('schedule_resource_actor_required');
+    const serviceType = token(input.serviceType);
+    const horizonStart = periodBoundary(input.planningHorizon.start, false);
+    const horizonEnd = periodBoundary(input.planningHorizon.end, true);
+    if (horizonEnd < horizonStart)
+        throw new TypeError('schedule_planning_horizon_invalid');
+    const scheduleReference = `Schedule/${scheduleId}`;
+    const seenSlotIds = new Set();
+    const slots = input.slots.map(slot => {
+        const slotId = id(slot.slotId);
+        if (seenSlotIds.has(slotId))
+            throw new TypeError('schedule_slot_id_duplicate');
+        seenSlotIds.add(slotId);
+        const start = instant(slot.start, 'slot_start_invalid');
+        const end = instant(slot.end, 'slot_end_invalid');
+        const startTime = Date.parse(start);
+        const endTime = Date.parse(end);
+        if (endTime <= startTime)
+            throw new TypeError('slot_interval_invalid');
+        if (startTime < horizonStart || endTime > horizonEnd)
+            throw new TypeError('slot_outside_planning_horizon');
+        return Object.freeze({
+            resourceType: 'Slot',
+            id: slotId,
+            meta: Object.freeze({ claims: Object.freeze({
+                    [SlotClaim.Identifier]: required(slot.slotIdentifier, 'slot_identifier_required'),
+                    [SlotClaim.Schedule]: scheduleReference,
+                    [SlotClaim.ServiceType]: serviceType,
+                    [SlotClaim.ServiceTypeReference]: healthcareServiceReference,
+                    [SlotClaim.Status]: slot.status,
+                    [SlotClaim.Start]: start,
+                    [SlotClaim.End]: end,
+                    ...(slot.overbooked === undefined ? {} : { [SlotClaim.Overbooked]: String(slot.overbooked) }),
+                    ...(slot.comment?.trim() ? { [SlotClaim.Comment]: slot.comment.trim() } : {}),
+                }) }),
+        });
+    });
+    return Object.freeze([
+        Object.freeze({
+            resourceType: 'Schedule',
+            id: scheduleId,
+            meta: Object.freeze({ claims: Object.freeze({
+                    [ScheduleClaim.Identifier]: required(input.scheduleIdentifier, 'schedule_identifier_required'),
+                    [ScheduleClaim.Active]: 'true',
+                    [ScheduleClaim.Name]: required(input.name, 'schedule_name_required'),
+                    [ScheduleClaim.ServiceType]: serviceType,
+                    [ScheduleClaim.ServiceTypeReference]: healthcareServiceReference,
+                    [ScheduleClaim.Actor]: Object.freeze([healthcareServiceReference, ...resourceActorReferences]),
+                    [ScheduleClaim.PlanningHorizonStart]: input.planningHorizon.start,
+                    [ScheduleClaim.PlanningHorizonEnd]: input.planningHorizon.end,
+                }) }),
+        }),
+        ...slots,
+    ]);
+}
+/**
+ * Builds one reservable child place such as a room, booth, chair or bed.
+ *
+ * R4 projects `Location.physicalType`; R5 projects the same governed coding as
+ * `Location.form`. Equipment such as an apheresis machine remains a Device and
+ * is added independently to the Schedule actor list.
+ */
+export function buildSchedulableLocationFlatResource(input) {
+    const locationId = id(input.locationId);
+    const form = token(input.form);
+    const managingOrganizationReference = reference(input.managingOrganizationReference, 'Organization', 'schedulable_location_managing_organization_invalid');
+    const parentLocationReference = reference(input.parentLocationReference, 'Location', 'schedulable_location_parent_invalid');
+    if (parentLocationReference === `Location/${locationId}`)
+        throw new TypeError('schedulable_location_parent_invalid');
+    const position = input.position;
+    if (position && (!Number.isFinite(position.longitude) || position.longitude < -180 || position.longitude > 180
+        || !Number.isFinite(position.latitude) || position.latitude < -90 || position.latitude > 90
+        || (position.altitude !== undefined && !Number.isFinite(position.altitude)))) {
+        throw new TypeError('schedulable_location_position_invalid');
+    }
+    return Object.freeze({
+        resourceType: 'Location',
+        id: locationId,
+        meta: Object.freeze({ claims: Object.freeze({
+                [LocationClaim.Identifier]: required(input.locationIdentifier, 'schedulable_location_identifier_required'),
+                [LocationClaim.Status]: input.status ?? 'active',
+                [LocationClaim.Mode]: 'instance',
+                [LocationClaim.Name]: required(input.name, 'schedulable_location_name_required'),
+                [LocationClaim.PhysicalType]: form,
+                [LocationClaim.ManagingOrganization]: managingOrganizationReference,
+                [LocationClaim.PartOf]: parentLocationReference,
+                ...(position ? {
+                    [LocationClaim.PositionLongitude]: String(position.longitude),
+                    [LocationClaim.PositionLatitude]: String(position.latitude),
+                    ...(position.altitude === undefined ? {} : { [LocationClaim.PositionAltitude]: String(position.altitude) }),
+                } : {}),
+            }) }),
+    });
+}

package/dist/care-emergency-alert.d.ts

@@ -1,3 +1,4 @@
+import { EncounterStatusR5 } from './claims/index.js';
 import { type FlatClaimResourceEntry } from './flat-claim-resource-graph.js';
 export type ClinicalCoding = Readonly<{
     system: string;
@@ -14,6 +15,23 @@ export type EncounterJourneyNode = Readonly<{
     locationReference: string;
     type?: ClinicalCoding;
 }>;
+/** Builds one FHIR R5 EncounterHistory milestone from canonical flat claims. */
+export declare function buildEncounterHistoryR5FlatEntry(input: Readonly<{
+    entryId: string;
+    identifier: string;
+    encounterReference: string;
+    status: EncounterStatusR5;
+    class: ClinicalCoding;
+    serviceReference?: string;
+    subjectReference?: string;
+    subjectStatus?: ClinicalCoding;
+    actualPeriodStart?: string;
+    actualPeriodEnd?: string;
+    plannedStartDate?: string;
+    plannedEndDate?: string;
+    locationReference?: string;
+    locationForm?: ClinicalCoding;
+}>): FlatClaimResourceEntry;
 /**
  * Builds one actual-care Encounter graph from an originating Appointment.
  * Child service/location encounters inherit subject and provider and reference

package/dist/care-emergency-alert.js

@@ -1,5 +1,33 @@
-import { CommunicationRequestClaim, EncounterClaim, ServiceRequestClaim, TaskClaim, } from './claims/index.js';
+import { CommunicationRequestClaim, EncounterClaim, EncounterHistoryClaim, ServiceRequestClaim, TaskClaim, } from './claims/index.js';
 import { buildFlatClaimResourceEntry } from './flat-claim-resource-graph.js';
+/** Builds one FHIR R5 EncounterHistory milestone from canonical flat claims. */
+export function buildEncounterHistoryR5FlatEntry(input) {
+    const claims = {
+        [EncounterHistoryClaim.Identifier]: required(input.identifier, 'encounter_history_identifier_required'),
+        [EncounterHistoryClaim.Encounter]: reference(input.encounterReference, 'encounter_history_encounter_invalid'),
+        [EncounterHistoryClaim.Status]: input.status,
+        [EncounterHistoryClaim.Class]: coding(input.class, 'encounter_history_class_invalid'),
+    };
+    if (input.serviceReference)
+        claims[EncounterHistoryClaim.ServiceType] = reference(input.serviceReference, 'encounter_history_service_invalid');
+    if (input.subjectReference)
+        claims[EncounterHistoryClaim.Subject] = reference(input.subjectReference, 'encounter_history_subject_invalid');
+    if (input.subjectStatus)
+        claims[EncounterHistoryClaim.SubjectStatus] = coding(input.subjectStatus, 'encounter_history_subject_status_invalid');
+    if (input.actualPeriodStart)
+        claims[EncounterHistoryClaim.ActualPeriodStart] = dateTime(input.actualPeriodStart, 'encounter_history_actual_start_invalid');
+    if (input.actualPeriodEnd)
+        claims[EncounterHistoryClaim.ActualPeriodEnd] = dateTime(input.actualPeriodEnd, 'encounter_history_actual_end_invalid');
+    if (input.plannedStartDate)
+        claims[EncounterHistoryClaim.PlannedStartDate] = dateTime(input.plannedStartDate, 'encounter_history_planned_start_invalid');
+    if (input.plannedEndDate)
+        claims[EncounterHistoryClaim.PlannedEndDate] = dateTime(input.plannedEndDate, 'encounter_history_planned_end_invalid');
+    if (input.locationReference)
+        claims[EncounterHistoryClaim.Location] = reference(input.locationReference, 'encounter_history_location_invalid');
+    if (input.locationForm)
+        claims[EncounterHistoryClaim.LocationForm] = coding(input.locationForm, 'encounter_history_location_form_invalid');
+    return buildFlatClaimResourceEntry({ entryId: input.entryId, resourceType: 'EncounterHistory', claims });
+}
 /**
  * Builds one actual-care Encounter graph from an originating Appointment.
  * Child service/location encounters inherit subject and provider and reference

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

@@ -184,6 +184,12 @@ export declare const AppointmentClaim: {
     readonly ParticipantActor: "Appointment.actor";
     readonly ParticipantStatus: "Appointment.part-status";
     readonly ParticipantType: "Appointment.participant-type";
+    readonly Date: "Appointment.date";
+    readonly Location: "Appointment.location";
+    readonly Patient: "Appointment.patient";
+    readonly Practitioner: "Appointment.practitioner";
+    readonly Slot: "Appointment.slot";
+    readonly SupportingInfo: "Appointment.supporting-info";
 };
 export type AppointmentClaimKey = typeof AppointmentClaim[keyof typeof AppointmentClaim];
 /**

package/dist/claims/appointment-claims.js

@@ -173,6 +173,12 @@ export const AppointmentClaim = {
     ParticipantActor: 'Appointment.actor',
     ParticipantStatus: 'Appointment.part-status',
     ParticipantType: 'Appointment.participant-type',
+    Date: 'Appointment.date',
+    Location: 'Appointment.location',
+    Patient: 'Appointment.patient',
+    Practitioner: 'Appointment.practitioner',
+    Slot: 'Appointment.slot',
+    SupportingInfo: 'Appointment.supporting-info',
 };
 // src/models/fhir/Appointment.values.ts
 /**

package/dist/claims/device-metric-claims.d.ts

@@ -0,0 +1,16 @@
+import type { ClaimSpec } from './claim-types.js';
+/** Canonical flat claims for FHIR R5 DeviceMetric, including its calibration backbone. */
+export declare const DeviceMetricClaim: {
+    readonly Identifier: "DeviceMetric.identifier";
+    readonly Type: "DeviceMetric.type";
+    readonly Unit: "DeviceMetric.unit";
+    readonly Device: "DeviceMetric.device";
+    readonly OperationalStatus: "DeviceMetric.operational-status";
+    readonly Category: "DeviceMetric.category";
+    readonly MeasurementFrequency: "DeviceMetric.measurement-frequency";
+    readonly CalibrationType: "DeviceMetric.calibration-type";
+    readonly CalibrationState: "DeviceMetric.calibration-state";
+    readonly CalibrationTime: "DeviceMetric.calibration-time";
+};
+export type DeviceMetricClaimKey = typeof DeviceMetricClaim[keyof typeof DeviceMetricClaim];
+export declare const DeviceMetricClaimSpecs: readonly ClaimSpec[];

package/dist/claims/device-metric-claims.js

@@ -0,0 +1,25 @@
+/** Canonical flat claims for FHIR R5 DeviceMetric, including its calibration backbone. */
+export const DeviceMetricClaim = {
+    Identifier: 'DeviceMetric.identifier',
+    Type: 'DeviceMetric.type',
+    Unit: 'DeviceMetric.unit',
+    Device: 'DeviceMetric.device',
+    OperationalStatus: 'DeviceMetric.operational-status',
+    Category: 'DeviceMetric.category',
+    MeasurementFrequency: 'DeviceMetric.measurement-frequency',
+    CalibrationType: 'DeviceMetric.calibration-type',
+    CalibrationState: 'DeviceMetric.calibration-state',
+    CalibrationTime: 'DeviceMetric.calibration-time',
+};
+export const DeviceMetricClaimSpecs = Object.freeze([
+    { key: DeviceMetricClaim.Identifier, meaning: 'Business identifier for the metric.', example: 'metric-1' },
+    { key: DeviceMetricClaim.Type, meaning: 'Metric type coding token.', example: 'http://loinc.org|11850-8' },
+    { key: DeviceMetricClaim.Unit, meaning: 'Metric unit coding token.', example: 'http://unitsofmeasure.org|mL/min' },
+    { key: DeviceMetricClaim.Device, meaning: 'Parent Device reference.', example: 'Device/device-1' },
+    { key: DeviceMetricClaim.OperationalStatus, meaning: 'Current operational status.', example: 'on' },
+    { key: DeviceMetricClaim.Category, meaning: 'Metric category.', example: 'measurement' },
+    { key: DeviceMetricClaim.MeasurementFrequency, meaning: 'Measurement frequency quantity token.', example: '1|Hz' },
+    { key: DeviceMetricClaim.CalibrationType, meaning: 'FHIR calibration method.', example: 'two-point' },
+    { key: DeviceMetricClaim.CalibrationState, meaning: 'FHIR calibration state.', example: 'calibrated' },
+    { key: DeviceMetricClaim.CalibrationTime, meaning: 'Time of the calibration represented by this row.', example: '2026-09-29T15:00:00Z' },
+]);

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

@@ -8,9 +8,12 @@ export declare const EncounterClaim: {
     readonly Subject: "Encounter.subject";
     readonly Patient: "Encounter.patient";
     readonly Participant: "Encounter.participant";
+    readonly ServiceType: "Encounter.service-type";
     readonly ServiceProvider: "Encounter.service-provider";
     readonly PeriodStart: "Encounter.period-start";
     readonly PeriodEnd: "Encounter.period-end";
+    readonly ActualPeriodStart: "Encounter.actual-period-start";
+    readonly ActualPeriodEnd: "Encounter.actual-period-end";
     readonly ReasonCode: "Encounter.reason-code";
     readonly Diagnosis: "Encounter.diagnosis";
     readonly Location: "Encounter.location";
@@ -28,5 +31,17 @@ export declare enum EncounterStatus {
     EnteredInError = "entered-in-error",
     Unknown = "unknown"
 }
+/** Canonical FHIR R5 Encounter lifecycle codes. */
+export declare enum EncounterStatusR5 {
+    Planned = "planned",
+    InProgress = "in-progress",
+    OnHold = "on-hold",
+    Discharged = "discharged",
+    Completed = "completed",
+    Cancelled = "cancelled",
+    Discontinued = "discontinued",
+    EnteredInError = "entered-in-error",
+    Unknown = "unknown"
+}
 export type EncounterClaimKey = typeof EncounterClaim[keyof typeof EncounterClaim];
 export declare const EncounterClaimSpecs: ClaimSpec[];

package/dist/claims/encounter-claims.js

@@ -9,9 +9,12 @@ export const EncounterClaim = {
     Subject: 'Encounter.subject',
     Patient: 'Encounter.patient',
     Participant: 'Encounter.participant',
+    ServiceType: 'Encounter.service-type',
     ServiceProvider: 'Encounter.service-provider',
     PeriodStart: 'Encounter.period-start',
     PeriodEnd: 'Encounter.period-end',
+    ActualPeriodStart: 'Encounter.actual-period-start',
+    ActualPeriodEnd: 'Encounter.actual-period-end',
     ReasonCode: 'Encounter.reason-code',
     Diagnosis: 'Encounter.diagnosis',
     Location: 'Encounter.location',
@@ -30,6 +33,19 @@ export var EncounterStatus;
     EncounterStatus["EnteredInError"] = "entered-in-error";
     EncounterStatus["Unknown"] = "unknown";
 })(EncounterStatus || (EncounterStatus = {}));
+/** Canonical FHIR R5 Encounter lifecycle codes. */
+export var EncounterStatusR5;
+(function (EncounterStatusR5) {
+    EncounterStatusR5["Planned"] = "planned";
+    EncounterStatusR5["InProgress"] = "in-progress";
+    EncounterStatusR5["OnHold"] = "on-hold";
+    EncounterStatusR5["Discharged"] = "discharged";
+    EncounterStatusR5["Completed"] = "completed";
+    EncounterStatusR5["Cancelled"] = "cancelled";
+    EncounterStatusR5["Discontinued"] = "discontinued";
+    EncounterStatusR5["EnteredInError"] = "entered-in-error";
+    EncounterStatusR5["Unknown"] = "unknown";
+})(EncounterStatusR5 || (EncounterStatusR5 = {}));
 export const EncounterClaimSpecs = [
     { key: EncounterClaim.Identifier, meaning: 'Business identifier.', example: 'enc-001' },
     { key: EncounterClaim.Appointment, meaning: 'Originating appointment references (CSV).', example: 'Appointment/appointment-1' },
@@ -39,9 +55,12 @@ export const EncounterClaimSpecs = [
     { key: EncounterClaim.Subject, meaning: 'Canonical subject reference.', example: 'did:web:patient.example.org' },
     { key: EncounterClaim.Patient, meaning: 'Patient alias reference.', example: 'did:web:patient.example.org' },
     { key: EncounterClaim.Participant, meaning: 'Participant references (CSV).', example: 'Practitioner/prac-1' },
+    { key: EncounterClaim.ServiceType, meaning: 'HealthcareService references (CSV in R5).', example: 'HealthcareService/emergency-department-1' },
     { key: EncounterClaim.ServiceProvider, meaning: 'Service provider reference.', example: 'Organization/org-1' },
     { key: EncounterClaim.PeriodStart, meaning: 'Encounter start.', example: '2026-06-01T10:00:00Z' },
     { key: EncounterClaim.PeriodEnd, meaning: 'Encounter end.', example: '2026-06-01T10:30:00Z' },
+    { key: EncounterClaim.ActualPeriodStart, meaning: 'R5 actual encounter start.', example: '2026-06-01T10:00:00Z' },
+    { key: EncounterClaim.ActualPeriodEnd, meaning: 'R5 actual encounter end.', example: '2026-06-01T10:30:00Z' },
     { key: EncounterClaim.ReasonCode, meaning: 'Reason code token.', example: 'http://snomed.info/sct|65363002' },
     { key: EncounterClaim.Diagnosis, meaning: 'Diagnosis references (CSV).', example: 'Condition/cond-1' },
     { key: EncounterClaim.Location, meaning: 'Location references (CSV).', example: 'Location/loc-1' },

package/dist/claims/encounter-history-claims.d.ts

@@ -0,0 +1,20 @@
+import type { ClaimSpec } from './claim-types.js';
+/** Canonical flat claims for the FHIR R5 EncounterHistory resource. */
+export declare const EncounterHistoryClaim: {
+    readonly Identifier: "EncounterHistory.identifier";
+    readonly Encounter: "EncounterHistory.encounter";
+    readonly Status: "EncounterHistory.status";
+    readonly Class: "EncounterHistory.class";
+    readonly Type: "EncounterHistory.type";
+    readonly ServiceType: "EncounterHistory.service-type";
+    readonly Subject: "EncounterHistory.subject";
+    readonly SubjectStatus: "EncounterHistory.subject-status";
+    readonly ActualPeriodStart: "EncounterHistory.actual-period-start";
+    readonly ActualPeriodEnd: "EncounterHistory.actual-period-end";
+    readonly PlannedStartDate: "EncounterHistory.planned-start-date";
+    readonly PlannedEndDate: "EncounterHistory.planned-end-date";
+    readonly Location: "EncounterHistory.location";
+    readonly LocationForm: "EncounterHistory.location-form";
+};
+export type EncounterHistoryClaimKey = typeof EncounterHistoryClaim[keyof typeof EncounterHistoryClaim];
+export declare const EncounterHistoryClaimSpecs: ClaimSpec[];

package/dist/claims/encounter-history-claims.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+/** Canonical flat claims for the FHIR R5 EncounterHistory resource. */
+export const EncounterHistoryClaim = {
+    Identifier: 'EncounterHistory.identifier',
+    Encounter: 'EncounterHistory.encounter',
+    Status: 'EncounterHistory.status',
+    Class: 'EncounterHistory.class',
+    Type: 'EncounterHistory.type',
+    ServiceType: 'EncounterHistory.service-type',
+    Subject: 'EncounterHistory.subject',
+    SubjectStatus: 'EncounterHistory.subject-status',
+    ActualPeriodStart: 'EncounterHistory.actual-period-start',
+    ActualPeriodEnd: 'EncounterHistory.actual-period-end',
+    PlannedStartDate: 'EncounterHistory.planned-start-date',
+    PlannedEndDate: 'EncounterHistory.planned-end-date',
+    Location: 'EncounterHistory.location',
+    LocationForm: 'EncounterHistory.location-form',
+};
+export const EncounterHistoryClaimSpecs = [
+    { key: EncounterHistoryClaim.Identifier, meaning: 'Business identifier.', example: 'urn:uuid:encounter-history-1' },
+    { key: EncounterHistoryClaim.Encounter, meaning: 'Encounter whose milestone is recorded.', example: 'Encounter/encounter-1' },
+    { key: EncounterHistoryClaim.Status, meaning: 'FHIR R5 Encounter status at this milestone.', example: 'on-hold' },
+    { key: EncounterHistoryClaim.Class, meaning: 'Encounter class token.', example: 'http://terminology.hl7.org/CodeSystem/v3-ActCode|EMER' },
+    { key: EncounterHistoryClaim.Type, meaning: 'Encounter type tokens (CSV).', example: 'http://snomed.info/sct|50849002' },
+    { key: EncounterHistoryClaim.ServiceType, meaning: 'HealthcareService references (CSV).', example: 'HealthcareService/emergency-1' },
+    { key: EncounterHistoryClaim.Subject, meaning: 'Patient or Group reference.', example: 'Patient/patient-1' },
+    { key: EncounterHistoryClaim.SubjectStatus, meaning: 'Subject status token.', example: 'departed' },
+    { key: EncounterHistoryClaim.ActualPeriodStart, meaning: 'Milestone period start.', example: '2026-09-29T08:00:00Z' },
+    { key: EncounterHistoryClaim.ActualPeriodEnd, meaning: 'Milestone period end.', example: '2026-09-29T08:30:00Z' },
+    { key: EncounterHistoryClaim.PlannedStartDate, meaning: 'Planned start.', example: '2026-09-29T08:00:00Z' },
+    { key: EncounterHistoryClaim.PlannedEndDate, meaning: 'Planned end.', example: '2026-09-29T08:30:00Z' },
+    { key: EncounterHistoryClaim.Location, meaning: 'Location references (CSV).', example: 'Location/emergency-box-1' },
+    { key: EncounterHistoryClaim.LocationForm, meaning: 'Location form token.', example: 'http://terminology.hl7.org/CodeSystem/location-physical-type|ro' },
+];

package/dist/claims/healthcare-service-claims.d.ts

@@ -0,0 +1,32 @@
+import type { ClaimSpec } from './claim-types.js';
+/**
+ * Canonical flat claims for the official FHIR R4 HealthcareService search
+ * surface. The providing Organization may be a department/suborganization;
+ * it is not the service itself.
+ *
+ * @see https://hl7.org/fhir/R4/healthcareservice.html#search
+ */
+export declare const HealthcareServiceClaim: Readonly<{
+    readonly Active: "HealthcareService.active";
+    readonly Characteristic: "HealthcareService.characteristic";
+    readonly CoverageArea: "HealthcareService.coverage-area";
+    readonly Endpoint: "HealthcareService.endpoint";
+    readonly Identifier: "HealthcareService.identifier";
+    readonly Location: "HealthcareService.location";
+    readonly Name: "HealthcareService.name";
+    readonly Comment: "HealthcareService.comment";
+    readonly Organization: "HealthcareService.organization";
+    readonly Program: "HealthcareService.program";
+    readonly ServiceCategory: "HealthcareService.service-category";
+    readonly ServiceType: "HealthcareService.service-type";
+    readonly Specialty: "HealthcareService.specialty";
+}>;
+export type HealthcareServiceClaimKey = typeof HealthcareServiceClaim[keyof typeof HealthcareServiceClaim];
+/** Exact resource-specific SearchParameters published by FHIR R4 4.0.1. */
+export declare const HealthcareServiceR4SearchParameterCatalog: readonly Readonly<{
+    claim: `${string}.${string}`;
+    resourceType: string;
+    elementPath: string;
+    type: import("../search-parameters.js").FlatSearchParameterType;
+}>[];
+export declare const HealthcareServiceClaimSpecs: readonly ClaimSpec[];

package/dist/claims/healthcare-service-claims.js

@@ -0,0 +1,54 @@
+// 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 R4 HealthcareService search
+ * surface. The providing Organization may be a department/suborganization;
+ * it is not the service itself.
+ *
+ * @see https://hl7.org/fhir/R4/healthcareservice.html#search
+ */
+export const HealthcareServiceClaim = Object.freeze({
+    Active: 'HealthcareService.active',
+    Characteristic: 'HealthcareService.characteristic',
+    CoverageArea: 'HealthcareService.coverage-area',
+    Endpoint: 'HealthcareService.endpoint',
+    Identifier: 'HealthcareService.identifier',
+    Location: 'HealthcareService.location',
+    Name: 'HealthcareService.name',
+    Comment: 'HealthcareService.comment',
+    Organization: 'HealthcareService.organization',
+    Program: 'HealthcareService.program',
+    ServiceCategory: 'HealthcareService.service-category',
+    ServiceType: 'HealthcareService.service-type',
+    Specialty: 'HealthcareService.specialty',
+});
+/** Exact resource-specific SearchParameters published by FHIR R4 4.0.1. */
+export const HealthcareServiceR4SearchParameterCatalog = Object.freeze([
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Active, resourceType: 'HealthcareService', elementPath: 'HealthcareService.active', type: 'token' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Characteristic, resourceType: 'HealthcareService', elementPath: 'HealthcareService.characteristic', type: 'token' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.CoverageArea, resourceType: 'HealthcareService', elementPath: 'HealthcareService.coverageArea', type: 'reference' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Endpoint, resourceType: 'HealthcareService', elementPath: 'HealthcareService.endpoint', type: 'reference' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Identifier, resourceType: 'HealthcareService', elementPath: 'HealthcareService.identifier', type: 'token' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Location, resourceType: 'HealthcareService', elementPath: 'HealthcareService.location', type: 'reference' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Name, resourceType: 'HealthcareService', elementPath: 'HealthcareService.name', type: 'string' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Organization, resourceType: 'HealthcareService', elementPath: 'HealthcareService.providedBy', type: 'reference' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Program, resourceType: 'HealthcareService', elementPath: 'HealthcareService.program', type: 'token' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.ServiceCategory, resourceType: 'HealthcareService', elementPath: 'HealthcareService.category', type: 'token' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.ServiceType, resourceType: 'HealthcareService', elementPath: 'HealthcareService.type', type: 'token' }),
+    defineFlatSearchParameter({ claim: HealthcareServiceClaim.Specialty, resourceType: 'HealthcareService', elementPath: 'HealthcareService.specialty', type: 'token' }),
+]);
+export const HealthcareServiceClaimSpecs = Object.freeze([
+    { key: HealthcareServiceClaim.Active, meaning: 'Whether the service is active.', example: 'true' },
+    { key: HealthcareServiceClaim.Characteristic, meaning: 'Repeatable service characteristic tokens as CSV.', example: 'https://example.org/CodeSystem/service-characteristic|24-hours' },
+    { key: HealthcareServiceClaim.CoverageArea, meaning: 'Repeatable intended coverage Location references as CSV.', example: 'Location/british-columbia' },
+    { key: HealthcareServiceClaim.Endpoint, meaning: 'Repeatable technical Endpoint references as CSV.', example: 'Endpoint/emergency-group-inbox' },
+    { key: HealthcareServiceClaim.Identifier, meaning: 'Logical service identifier.', example: 'urn:uuid:healthcare-service-1' },
+    { key: HealthcareServiceClaim.Location, meaning: 'Repeatable Places where the service is provided as Location references.', example: 'Location/emergency-room-1' },
+    { key: HealthcareServiceClaim.Name, meaning: 'Consumer-facing service name.', example: 'Veterinary emergency care' },
+    { key: HealthcareServiceClaim.Comment, meaning: 'Consumer-facing service description; this is a materialized field, not a SearchParameter.', example: 'Emergency assessment and stabilization.' },
+    { key: HealthcareServiceClaim.Organization, meaning: 'Organization or department that provides the service.', example: 'Organization/emergency-department-1' },
+    { key: HealthcareServiceClaim.Program, meaning: 'Repeatable program tokens as CSV.', example: 'https://example.org/CodeSystem/program|lost-animal-emergency' },
+    { key: HealthcareServiceClaim.ServiceCategory, meaning: 'Repeatable broad service category tokens as CSV.', example: 'http://terminology.hl7.org/CodeSystem/service-category|1' },
+    { key: HealthcareServiceClaim.ServiceType, meaning: 'Repeatable service type tokens as CSV.', example: 'http://terminology.hl7.org/CodeSystem/service-type|117' },
+    { key: HealthcareServiceClaim.Specialty, meaning: 'Repeatable clinical specialty tokens as CSV.', example: 'http://loinc.org|LP172940-1' },
+]);

package/dist/claims/index.d.ts

@@ -11,16 +11,19 @@ export * from './consent-claims.js';
 export * from './condition-claims.js';
 export * from './coverage-claims.js';
 export * from './device-claims.js';
+export * from './device-metric-claims.js';
 export * from './device-use-statement-claims.js';
 export * from './diagnostic-report-claims.js';
 export * from './document-reference-claims.js';
 export * from './encounter-claims.js';
+export * from './encounter-history-claims.js';
 export * from './flag-claims.js';
 export * from './immunization-claims.js';
 export * from './immunization-recommendation-claims.js';
 export * from './imaging-study-claims.js';
 export * from './invoice-claims.js';
 export * from './location-claims.js';
+export * from './healthcare-service-claims.js';
 export * from './medication-statement-claims.js';
 export * from './medication-claims.js';
 export * from './organization-claims.js';
@@ -28,5 +31,7 @@ export * from './practitioner-role-claims.js';
 export * from './procedure-claims.js';
 export * from './related-person-claims.js';
 export * from './research-subject-claims.js';
+export * from './regulated-authorization-claims.js';
 export * from './service-request-claims.js';
+export * from './schedule-slot-claims.js';
 export * from './task-claims.js';

package/dist/claims/index.js

@@ -11,16 +11,19 @@ export * from './consent-claims.js';
 export * from './condition-claims.js';
 export * from './coverage-claims.js';
 export * from './device-claims.js';
+export * from './device-metric-claims.js';
 export * from './device-use-statement-claims.js';
 export * from './diagnostic-report-claims.js';
 export * from './document-reference-claims.js';
 export * from './encounter-claims.js';
+export * from './encounter-history-claims.js';
 export * from './flag-claims.js';
 export * from './immunization-claims.js';
 export * from './immunization-recommendation-claims.js';
 export * from './imaging-study-claims.js';
 export * from './invoice-claims.js';
 export * from './location-claims.js';
+export * from './healthcare-service-claims.js';
 export * from './medication-statement-claims.js';
 export * from './medication-claims.js';
 export * from './organization-claims.js';
@@ -28,5 +31,7 @@ export * from './practitioner-role-claims.js';
 export * from './procedure-claims.js';
 export * from './related-person-claims.js';
 export * from './research-subject-claims.js';
+export * from './regulated-authorization-claims.js';
 export * from './service-request-claims.js';
+export * from './schedule-slot-claims.js';
 export * from './task-claims.js';

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

@@ -17,6 +17,9 @@ export declare const LocationClaim: {
     readonly PhysicalType: "Location.physical-type";
     readonly ManagingOrganization: "Location.managing-organization";
     readonly PartOf: "Location.part-of";
+    readonly PositionLongitude: "Location.position-longitude";
+    readonly PositionLatitude: "Location.position-latitude";
+    readonly PositionAltitude: "Location.position-altitude";
 };
 export type LocationClaimKey = typeof LocationClaim[keyof typeof LocationClaim];
 export declare const LocationClaimSpecs: ClaimSpec[];