fhir-data-utils-ts 0.3.7 → 0.6.0

package/dist/builders/index.js

@@ -1,3 +1,6 @@
 export * from './diagnostic-report-graph.js';
+export * from './department-service-graph.js';
+export * from './service-schedule-graph.js';
+export * from './device-compliance-graph.js';
 export * from './immunization-graph.js';
 export * from './immunization-reminders.js';

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/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/composition-claims.d.ts

@@ -1,4 +1,5 @@
 export declare const CompositionClaim: {
+    readonly Status: "Composition.status";
     readonly Subject: "Composition.subject";
     readonly Section: "Composition.section";
     readonly Author: "Composition.author";

package/dist/claims/composition-claims.js

@@ -1,6 +1,7 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 // File: src/models/interoperable-claims/composition-claims.ts
 export const CompositionClaim = {
+    Status: 'Composition.status',
     Subject: 'Composition.subject',
     Section: 'Composition.section',
     Author: 'Composition.author',

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/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,6 +11,7 @@ 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';
@@ -21,6 +22,7 @@ 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 +30,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,6 +11,7 @@ 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';
@@ -21,6 +22,7 @@ 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 +30,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[];

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' },
+]);