sos-sdk-core-ts 0.3.1 → 0.5.0

package/dist/communication-bundle.js

@@ -0,0 +1,312 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _CommunicationBundleEditor_instances, _CommunicationBundleEditor_messages, _CommunicationBundleEditor_committed, _CommunicationBundleEditor_commitCommunication, _CommunicationMessageEditor_parent, _CommunicationMessageEditor_status, _CommunicationMessageEditor_sender, _CommunicationMessageEditor_recipients, _CommunicationMessageEditor_sent, _CommunicationMessageEditor_attachmentTitle, _CommunicationBundleReader_communicationEntries, _CommunicationMessageReader_resource, _CommunicationMessageReader_claims;
+import { BundleEditor, BundleOperations, BundleTypes } from 'gdc-common-utils-ts/utils/bundle-editor';
+import { BundleReader } from 'gdc-common-utils-ts/utils/bundle-reader';
+import { CommunicationAttachedBundleSession, CommunicationClaimsContext, } from 'gdc-common-utils-ts/utils/communication-attached-bundle-session';
+import { decodeAttachedBundleFromCommunicationClaims } from 'gdc-common-utils-ts/utils/communication-didcomm-payload';
+import { CommunicationClaim } from 'gdc-common-utils-ts/models/interoperable-claims/communication-claims';
+import { AppointmentClaim, DocumentReferenceClaim } from 'fhir-data-utils-ts';
+/**
+ * SOS/Vet/UHC extension of the existing GDC BundleEditor.
+ *
+ * The inherited editor owns the canonical outer claims-first batch. Each
+ * staged message is a CommunicationAttachedBundleSession, so the existing
+ * attachment synchronization and Bundle lifecycle remain the source of truth.
+ * FHIR data utilities are used only at import/materialization boundaries.
+ */
+export class CommunicationBundleEditor extends BundleEditor {
+    constructor() {
+        super();
+        _CommunicationBundleEditor_instances.add(this);
+        _CommunicationBundleEditor_messages.set(this, []);
+        _CommunicationBundleEditor_committed.set(this, false);
+        this.setBundleOperation(BundleOperations.create)
+            .setBundleType(BundleTypes.batch)
+            .setAllowedResourceType('Communication');
+    }
+    newCommunication() {
+        if (__classPrivateFieldGet(this, _CommunicationBundleEditor_committed, "f"))
+            throw new TypeError('communication_bundle_already_built');
+        const message = new CommunicationMessageEditor(this);
+        __classPrivateFieldGet(this, _CommunicationBundleEditor_messages, "f").push(message);
+        return message;
+    }
+    /** Builds the inherited claims-first outer batch after validating every attached Bundle. */
+    build() {
+        if (!__classPrivateFieldGet(this, _CommunicationBundleEditor_messages, "f").length)
+            throw new TypeError('communication_required');
+        if (!__classPrivateFieldGet(this, _CommunicationBundleEditor_committed, "f")) {
+            for (const message of __classPrivateFieldGet(this, _CommunicationBundleEditor_messages, "f"))
+                __classPrivateFieldGet(this, _CommunicationBundleEditor_instances, "m", _CommunicationBundleEditor_commitCommunication).call(this, message);
+            __classPrivateFieldSet(this, _CommunicationBundleEditor_committed, true, "f");
+        }
+        return super.build();
+    }
+}
+_CommunicationBundleEditor_messages = new WeakMap(), _CommunicationBundleEditor_committed = new WeakMap(), _CommunicationBundleEditor_instances = new WeakSet(), _CommunicationBundleEditor_commitCommunication = function _CommunicationBundleEditor_commitCommunication(message) {
+    message.validateForBuild();
+    const claims = message.getCompleteCommunicationClaims();
+    const identifier = requireText(claims[CommunicationClaim.Identifier], 'communication_identifier_required');
+    const entry = this.newEntry(identifier);
+    for (const [claim, value] of Object.entries(claims))
+        entry.setClaim(claim, value);
+    entry.create();
+};
+/**
+ * Authors the standard FHIR Appointment delivery flow for every sector.
+ *
+ * Product SDKs use this class directly. They must not introduce human or
+ * veterinary Appointment wrappers unless they add a genuinely sector-owned
+ * rule that is absent from the FHIR and shared data contracts.
+ */
+export class AppointmentCommunicationBundleEditor extends CommunicationBundleEditor {
+    addAppointmentCommunication(input) {
+        if (input.appointment.resourceType !== 'Appointment')
+            throw new TypeError('fhir_appointment_required');
+        const appointment = normalizeAppointmentIdentifier(input.appointment);
+        const message = this.newCommunication()
+            .setIdentifier(input.communicationIdentifier)
+            .setStatus(input.status)
+            .setSubject(input.subjectReference)
+            .setSender(input.senderReference)
+            .setRecipients(input.recipientReferences)
+            .setAttachmentTitle('appointment-bundle.json')
+            .setInnerBundleType('collection')
+            .addResource(appointment);
+        if (input.category)
+            message.setCommunicationCategory(input.category);
+        if (input.topic)
+            message.setCommunicationTopic(input.topic);
+        if (input.text)
+            message.setCommunicationText(input.text);
+        if (input.sent)
+            message.setSent(input.sent);
+        if (input.calendarDocument) {
+            message.addAttachmentDocument({
+                ...input.calendarDocument,
+                subjectReference: input.subjectReference,
+                eventReferences: [`Appointment/${input.appointment.id}`],
+            });
+        }
+        message.doneCommunication();
+        return this;
+    }
+}
+/** Authors one standard Appointment delivery without a product-specific wrapper. */
+export function prepareAppointmentCommunicationBundle(input) {
+    return new AppointmentCommunicationBundleEditor()
+        .addAppointmentCommunication(input)
+        .build();
+}
+/** High-level message editor extending the established attached-Bundle session. */
+export class CommunicationMessageEditor extends CommunicationAttachedBundleSession {
+    constructor(parent) {
+        super({
+            communicationClaims: { '@context': CommunicationClaimsContext },
+            initialBundle: { resourceType: 'Bundle', type: 'batch', data: [] },
+        });
+        _CommunicationMessageEditor_parent.set(this, void 0);
+        _CommunicationMessageEditor_status.set(this, void 0);
+        _CommunicationMessageEditor_sender.set(this, void 0);
+        _CommunicationMessageEditor_recipients.set(this, []);
+        _CommunicationMessageEditor_sent.set(this, void 0);
+        _CommunicationMessageEditor_attachmentTitle.set(this, void 0);
+        __classPrivateFieldSet(this, _CommunicationMessageEditor_parent, parent, "f");
+    }
+    setIdentifier(value) { this.setCommunicationIdentifier(value); return this; }
+    getIdentifier() { return optionalText(this.getCommunicationIdentifier()); }
+    setStatus(value) { __classPrivateFieldSet(this, _CommunicationMessageEditor_status, requireText(value, 'communication_status_required'), "f"); return this; }
+    getStatus() { return __classPrivateFieldGet(this, _CommunicationMessageEditor_status, "f"); }
+    setSubject(value) { this.setCommunicationSubject(value); return this; }
+    getSubject() { return optionalText(this.getCommunicationSubject()); }
+    setSender(value) { __classPrivateFieldSet(this, _CommunicationMessageEditor_sender, requireText(value, 'communication_sender_required'), "f"); return this; }
+    getSender() { return __classPrivateFieldGet(this, _CommunicationMessageEditor_sender, "f"); }
+    setRecipients(values) { __classPrivateFieldSet(this, _CommunicationMessageEditor_recipients, uniqueReferences(values, 'communication_recipient_required'), "f"); return this; }
+    getRecipients() { return Object.freeze([...__classPrivateFieldGet(this, _CommunicationMessageEditor_recipients, "f")]); }
+    setSent(value) { __classPrivateFieldSet(this, _CommunicationMessageEditor_sent, requireText(value, 'communication_sent_required'), "f"); return this; }
+    getSent() { return __classPrivateFieldGet(this, _CommunicationMessageEditor_sent, "f"); }
+    setAttachmentTitle(value) { __classPrivateFieldSet(this, _CommunicationMessageEditor_attachmentTitle, requireText(value, 'communication_attachment_title_required'), "f"); return this; }
+    getAttachmentTitle() { return __classPrivateFieldGet(this, _CommunicationMessageEditor_attachmentTitle, "f"); }
+    setInnerBundleType(value) {
+        if (!['document', 'batch', 'collection'].includes(value))
+            throw new TypeError('fhir_inner_bundle_type_invalid');
+        this.setAttachedBundle({ ...this.getAttachedBundle(), type: value });
+        return this;
+    }
+    getInnerBundleType() { return this.getAttachedBundle().type; }
+    /** Adds one canonical claims-first resource to the existing attached-Bundle session. */
+    addResource(resource, request) {
+        const claims = claimsFromResource(resource);
+        const identifier = resourceIdentifier(resource, claims);
+        this.upsertActiveEntry({
+            resourceType: resource.resourceType,
+            claims,
+            fullUrl: `urn:uuid:${identifier}`,
+            ...(request ? { request } : {}),
+        }).saveAndReleaseActiveEntry();
+        return this;
+    }
+    /** Adds a PDF, image, audio or calendar file as an inner DocumentReference. */
+    addAttachmentDocument(input) {
+        const identifier = requireText(input.identifier, 'document_reference_identifier_required');
+        const subjectReference = requireText(input.subjectReference, 'document_reference_subject_required');
+        const contentType = requireText(input.contentType, 'document_reference_content_type_required');
+        if (!input.dataBase64 && !input.url)
+            throw new TypeError('document_reference_content_required');
+        const claims = compactClaims({
+            '@context': CommunicationClaimsContext,
+            [DocumentReferenceClaim.Identifier]: identifier,
+            [DocumentReferenceClaim.Subject]: subjectReference,
+            [DocumentReferenceClaim.ContentType]: contentType,
+            [DocumentReferenceClaim.ContentData]: input.dataBase64,
+            [DocumentReferenceClaim.Location]: input.url,
+            [DocumentReferenceClaim.Description]: input.description || input.title,
+            [DocumentReferenceClaim.Date]: input.date,
+            [DocumentReferenceClaim.Author]: input.authorReferences?.join(','),
+            [DocumentReferenceClaim.EventReference]: input.eventReferences?.join(','),
+        });
+        this.upsertActiveDocumentReferenceEntry({ claims, fullUrl: `urn:uuid:${identifier}` }).saveAndReleaseActiveEntry();
+        return this;
+    }
+    doneCommunication() { return __classPrivateFieldGet(this, _CommunicationMessageEditor_parent, "f"); }
+    /** @internal */
+    validateForBuild() {
+        requireText(this.getCommunicationIdentifier(), 'communication_identifier_required');
+        requireText(__classPrivateFieldGet(this, _CommunicationMessageEditor_status, "f"), 'communication_status_required');
+        requireText(this.getCommunicationSubject(), 'communication_subject_required');
+        validateAttachedBundle(this.getAttachedBundle());
+    }
+    /** @internal */
+    getCompleteCommunicationClaims() {
+        return compactClaims({
+            ...this.getCommunicationClaims(),
+            [CommunicationClaim.Status]: __classPrivateFieldGet(this, _CommunicationMessageEditor_status, "f"),
+            [CommunicationClaim.Sender]: __classPrivateFieldGet(this, _CommunicationMessageEditor_sender, "f"),
+            [CommunicationClaim.Recipient]: __classPrivateFieldGet(this, _CommunicationMessageEditor_recipients, "f").length ? __classPrivateFieldGet(this, _CommunicationMessageEditor_recipients, "f").join(',') : undefined,
+            [CommunicationClaim.Sent]: __classPrivateFieldGet(this, _CommunicationMessageEditor_sent, "f"),
+            [CommunicationClaim.ContentAttachmentTitle]: __classPrivateFieldGet(this, _CommunicationMessageEditor_attachmentTitle, "f"),
+        });
+    }
+}
+_CommunicationMessageEditor_parent = new WeakMap(), _CommunicationMessageEditor_status = new WeakMap(), _CommunicationMessageEditor_sender = new WeakMap(), _CommunicationMessageEditor_recipients = new WeakMap(), _CommunicationMessageEditor_sent = new WeakMap(), _CommunicationMessageEditor_attachmentTitle = new WeakMap();
+/** Read-only extension of the established BundleReader for an outer Communication batch. */
+export class CommunicationBundleReader extends BundleReader {
+    constructor(outerBatch) {
+        super(outerBatch);
+        _CommunicationBundleReader_communicationEntries.set(this, void 0);
+        if (this.getBundleType() !== 'batch')
+            throw new TypeError('fhir_batch_bundle_required');
+        __classPrivateFieldSet(this, _CommunicationBundleReader_communicationEntries, Object.freeze(this.getEntries().filter(entry => entry.resource?.resourceType === 'Communication')), "f");
+        if (!__classPrivateFieldGet(this, _CommunicationBundleReader_communicationEntries, "f").length)
+            throw new TypeError('fhir_communication_required');
+    }
+    getCommunicationCount() { return __classPrivateFieldGet(this, _CommunicationBundleReader_communicationEntries, "f").length; }
+    openCommunication(index) {
+        if (!Number.isInteger(index) || index < 0 || index >= __classPrivateFieldGet(this, _CommunicationBundleReader_communicationEntries, "f").length)
+            throw new RangeError('communication_index_invalid');
+        return new CommunicationMessageReader(__classPrivateFieldGet(this, _CommunicationBundleReader_communicationEntries, "f")[index]);
+    }
+}
+_CommunicationBundleReader_communicationEntries = new WeakMap();
+/** High-level getters over one claims-first Communication and its attached Bundle. */
+export class CommunicationMessageReader extends BundleReader {
+    constructor(entry) {
+        const resource = entry.resource;
+        if (resource?.resourceType !== 'Communication')
+            throw new TypeError('fhir_communication_required');
+        const claims = claimsFromResource(resource);
+        const attachedBundle = decodeAttachedBundleFromCommunicationClaims(claims);
+        super(attachedBundle);
+        _CommunicationMessageReader_resource.set(this, void 0);
+        _CommunicationMessageReader_claims.set(this, void 0);
+        validateAttachedBundle(attachedBundle);
+        __classPrivateFieldSet(this, _CommunicationMessageReader_resource, clone(resource), "f");
+        __classPrivateFieldSet(this, _CommunicationMessageReader_claims, clone(claims), "f");
+    }
+    getCommunication() { return clone(__classPrivateFieldGet(this, _CommunicationMessageReader_resource, "f")); }
+    getInnerBundle() { return clone(decodeAttachedBundleFromCommunicationClaims(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f"))); }
+    getIdentifier() { return requireText(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f")[CommunicationClaim.Identifier], 'communication_identifier_required'); }
+    getStatus() { return optionalText(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f")[CommunicationClaim.Status]); }
+    getSubject() { return optionalText(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f")[CommunicationClaim.Subject]); }
+    getSender() { return optionalText(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f")[CommunicationClaim.Sender]); }
+    getRecipients() { return csv(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f")[CommunicationClaim.Recipient]); }
+    getSent() { return optionalText(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f")[CommunicationClaim.Sent]); }
+    getAttachmentTitle() { return optionalText(__classPrivateFieldGet(this, _CommunicationMessageReader_claims, "f")[CommunicationClaim.ContentAttachmentTitle]); }
+    getInnerBundleType() { return this.getBundleType(); }
+    getResourcesByType(resourceType) {
+        return Object.freeze(this.getEntries().flatMap(entry => {
+            const resource = entry.resource;
+            return resource?.resourceType === resourceType ? [clone(resource)] : [];
+        }));
+    }
+    getAppointments() { return this.getResourcesByType('Appointment'); }
+    getDocumentReferences() { return this.getResourcesByType('DocumentReference'); }
+}
+_CommunicationMessageReader_resource = new WeakMap(), _CommunicationMessageReader_claims = new WeakMap();
+function claimsFromResource(resource) {
+    const meta = resource.meta;
+    const claims = meta && typeof meta === 'object' && !Array.isArray(meta) ? meta.claims : undefined;
+    if (!claims || typeof claims !== 'object' || Array.isArray(claims))
+        throw new TypeError('claims_first_resource_required');
+    return clone(claims);
+}
+function resourceIdentifier(resource, claims) {
+    return requireText(resource.id || claims[`${resource.resourceType}.identifier`], 'resource_identifier_required');
+}
+function normalizeAppointmentIdentifier(appointment) {
+    const meta = appointment.meta;
+    const claims = meta?.claims && typeof meta.claims === 'object' && !Array.isArray(meta.claims)
+        ? meta.claims
+        : undefined;
+    if (!claims)
+        throw new TypeError('claims_first_resource_required');
+    if (claims[AppointmentClaim.Identifier] !== undefined)
+        return appointment;
+    return {
+        ...appointment,
+        meta: {
+            ...meta,
+            claims: { ...claims, [AppointmentClaim.Identifier]: [appointment.id] },
+        },
+    };
+}
+function validateAttachedBundle(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError('fhir_bundle_required');
+    const bundle = value;
+    if (bundle.resourceType !== 'Bundle')
+        throw new TypeError('fhir_bundle_required');
+    const type = optionalText(bundle.type);
+    if (!type || !['document', 'batch', 'collection'].includes(type))
+        throw new TypeError('fhir_inner_bundle_type_invalid');
+    const entries = Array.isArray(bundle.data) ? bundle.data : [];
+    if (type === 'document' && entries[0]?.resource?.resourceType !== 'Composition')
+        throw new TypeError('fhir_document_composition_first_required');
+    if (type === 'batch' && entries.some(entry => {
+        const request = entry.request;
+        return !optionalText(request?.method) || !optionalText(request?.url);
+    }))
+        throw new TypeError('fhir_batch_request_required');
+}
+function csv(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(String).map(item => item.trim()).filter(Boolean));
+    const normalized = optionalText(value);
+    return Object.freeze(normalized ? normalized.split(',').map(item => item.trim()).filter(Boolean) : []);
+}
+function uniqueReferences(values, error) { return [...new Set(values.map(value => requireText(value, error)))]; }
+function compactClaims(input) { return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== '')); }
+function optionalText(value) { return typeof value === 'string' && value.trim() ? value.trim() : undefined; }
+function requireText(value, error) { const normalized = optionalText(value); if (!normalized)
+    throw new TypeError(error); return normalized; }
+function clone(value) { return JSON.parse(JSON.stringify(value)); }

package/dist/emergency-authorization.d.ts

@@ -1,4 +1,4 @@
-import type { EmergencyAuthorizationEvidence, EmergencyCapability, EvidenceDomain } from 'sos-data-utils-ts/emergency-evidence';
+import type { EmergencyAuthorizationEvidence, EmergencyCapability } from 'sos-data-utils-ts/emergency-evidence';
 export type { EmergencyAuthorizationEvidence, EmergencyCapability, EvidenceDomain, } from 'sos-data-utils-ts/emergency-evidence';
 /** Runtime-neutral endpoint selected after authorization succeeds. */
 export type EmergencyDeliveryTarget = Readonly<{
@@ -18,13 +18,3 @@ export declare function authorizeEmergencyAction(input: Readonly<{
     evidence: readonly EmergencyAuthorizationEvidence[];
     now?: string;
 }>): readonly string[];
-/** @deprecated Use `EmergencyDeliveryTarget`. */
-export type SoschainEmergencyDeliveryTarget = EmergencyDeliveryTarget;
-/** @deprecated Import `EmergencyAuthorizationEvidence` from this module. */
-export type SoschainEmergencyAuthorizationEvidence = EmergencyAuthorizationEvidence;
-/** @deprecated Import `EmergencyCapability` from this module. */
-export type SoschainEmergencyCapability = EmergencyCapability;
-/** @deprecated Import `EvidenceDomain` from this module. */
-export type SoschainEvidenceDomain = EvidenceDomain;
-/** @deprecated Use `authorizeEmergencyAction`. */
-export declare const authorizeSoschainEmergencyAction: typeof authorizeEmergencyAction;

package/dist/emergency-authorization.js

@@ -17,5 +17,3 @@ export function authorizeEmergencyAction(input) {
     }
     return [...evidenceIds];
 }
-/** @deprecated Use `authorizeEmergencyAction`. */
-export const authorizeSoschainEmergencyAction = authorizeEmergencyAction;

package/dist/encounter-transfer-communication.d.ts

@@ -0,0 +1,40 @@
+import { type ClinicalCoding, type FhirResource } from 'fhir-data-utils-ts';
+export type EncounterTransferSourceDisposition = 'returning' | 'not-returning';
+export type EncounterTransferProjectionInput = Readonly<{
+    communicationIdentifier: string;
+    subjectReference: string;
+    /** Department Organization that performed and communicates the transfer. */
+    departmentSenderReference: string;
+    /** Owning subject-index provider, not the emergency contact recipient. */
+    indexRecipientReferences: readonly string[];
+    occurredAt: string;
+    sourceDisposition: EncounterTransferSourceDisposition;
+    sourceEncounter: FhirResource & Readonly<{
+        resourceType: 'Encounter';
+        id: string;
+    }>;
+    destinationEncounter: FhirResource & Readonly<{
+        resourceType: 'Encounter';
+        id: string;
+    }>;
+    sourceHistoryIdentifier: string;
+    destinationHistoryIdentifier: string;
+    encounterClass: ClinicalCoding;
+}>;
+/**
+ * Builds the completed Communication used to project an already-committed
+ * provider transfer to the subject index.
+ *
+ * This helper is not the provider transaction itself. The authorized provider
+ * first persists the two Encounter updates and two EncounterHistory milestones;
+ * only then may this Communication be marked `completed`. If the person will
+ * return, the source Encounter becomes `on-hold`; otherwise it becomes
+ * `completed`. `discharged` is reserved for the distinct clinical discharge
+ * stage and is never inferred merely from movement. The destination becomes
+ * `in-progress` on arrival.
+ *
+ * `Communication.sender` remains the department Organization. The authenticated
+ * professional/device is transport audit evidence and must not be substituted
+ * into the FHIR sender, author or attester fields.
+ */
+export declare function prepareEncounterTransferProjectionCommunication(input: EncounterTransferProjectionInput): Record<string, unknown>;

package/dist/encounter-transfer-communication.js

@@ -0,0 +1,120 @@
+import { EncounterClaim, EncounterHistoryClaim, EncounterStatusR5, buildEncounterHistoryR5FlatEntry, } from 'fhir-data-utils-ts';
+import { CommunicationBundleEditor } from './communication-bundle.js';
+/**
+ * Builds the completed Communication used to project an already-committed
+ * provider transfer to the subject index.
+ *
+ * This helper is not the provider transaction itself. The authorized provider
+ * first persists the two Encounter updates and two EncounterHistory milestones;
+ * only then may this Communication be marked `completed`. If the person will
+ * return, the source Encounter becomes `on-hold`; otherwise it becomes
+ * `completed`. `discharged` is reserved for the distinct clinical discharge
+ * stage and is never inferred merely from movement. The destination becomes
+ * `in-progress` on arrival.
+ *
+ * `Communication.sender` remains the department Organization. The authenticated
+ * professional/device is transport audit evidence and must not be substituted
+ * into the FHIR sender, author or attester fields.
+ */
+export function prepareEncounterTransferProjectionCommunication(input) {
+    requireDateTime(input.occurredAt);
+    const source = normalizeEncounter(input.sourceEncounter, input.subjectReference);
+    const destination = normalizeEncounter(input.destinationEncounter, input.subjectReference);
+    if (source.id === destination.id)
+        throw new TypeError('distinct_encounters_required');
+    const sourceStatus = input.sourceDisposition === 'returning'
+        ? EncounterStatusR5.OnHold
+        : input.sourceDisposition === 'not-returning'
+            ? EncounterStatusR5.Completed
+            : (() => { throw new TypeError('source_disposition_invalid'); })();
+    const sourceUpdated = withEncounterStatus(source, sourceStatus, input.occurredAt);
+    const destinationUpdated = withEncounterStatus(destination, EncounterStatusR5.InProgress, input.occurredAt);
+    const sourceHistory = historyResource({
+        identifier: input.sourceHistoryIdentifier,
+        encounter: sourceUpdated,
+        status: sourceStatus,
+        occurredAt: input.occurredAt,
+        encounterClass: input.encounterClass,
+    });
+    const destinationHistory = historyResource({
+        identifier: input.destinationHistoryIdentifier,
+        encounter: destinationUpdated,
+        status: EncounterStatusR5.InProgress,
+        occurredAt: input.occurredAt,
+        encounterClass: input.encounterClass,
+    });
+    const editor = new CommunicationBundleEditor();
+    editor.newCommunication()
+        .setIdentifier(input.communicationIdentifier)
+        .setStatus('completed')
+        .setSubject(input.subjectReference)
+        .setSender(input.departmentSenderReference)
+        .setRecipients(input.indexRecipientReferences)
+        .setSent(input.occurredAt)
+        .setAttachmentTitle('encounter-transfer-bundle.json')
+        .setInnerBundleType('batch')
+        .addResource(sourceUpdated, { method: 'PUT', url: `Encounter/${sourceUpdated.id}` })
+        .addResource(sourceHistory, { method: 'POST', url: 'EncounterHistory' })
+        .addResource(destinationUpdated, { method: 'PUT', url: `Encounter/${destinationUpdated.id}` })
+        .addResource(destinationHistory, { method: 'POST', url: 'EncounterHistory' })
+        .doneCommunication();
+    return editor.build();
+}
+function normalizeEncounter(resource, subjectReference) {
+    if (resource.resourceType !== 'Encounter')
+        throw new TypeError('fhir_encounter_required');
+    const claims = claimsOf(resource);
+    if (claims[EncounterClaim.Subject] !== subjectReference)
+        throw new TypeError('encounter_subject_mismatch');
+    if (!text(claims[EncounterClaim.ServiceType]))
+        throw new TypeError('encounter_service_required');
+    return clone(resource);
+}
+function withEncounterStatus(resource, status, occurredAt) {
+    const claims = claimsOf(resource);
+    const nextClaims = {
+        ...claims,
+        [EncounterClaim.Status]: status,
+        ...(status === EncounterStatusR5.Completed ? { [EncounterClaim.ActualPeriodEnd]: occurredAt } : {}),
+        ...(status === EncounterStatusR5.InProgress && !claims[EncounterClaim.ActualPeriodStart]
+            ? { [EncounterClaim.ActualPeriodStart]: occurredAt }
+            : {}),
+    };
+    return { ...clone(resource), meta: { ...resource.meta, claims: nextClaims } };
+}
+function historyResource(input) {
+    const encounterClaims = claimsOf(input.encounter);
+    const id = uuidIdentifier(input.identifier);
+    const entry = buildEncounterHistoryR5FlatEntry({
+        entryId: id,
+        identifier: input.identifier,
+        encounterReference: `Encounter/${input.encounter.id}`,
+        status: input.status,
+        class: input.encounterClass,
+        serviceReference: text(encounterClaims[EncounterClaim.ServiceType]),
+        subjectReference: text(encounterClaims[EncounterClaim.Subject]),
+        actualPeriodStart: input.occurredAt,
+        locationReference: text(encounterClaims[EncounterClaim.Location]),
+    });
+    if (entry.claims[EncounterHistoryClaim.Status] !== input.status)
+        throw new TypeError('encounter_history_status_mismatch');
+    return { resourceType: 'EncounterHistory', id, meta: { claims: entry.claims } };
+}
+function claimsOf(resource) {
+    const meta = resource.meta;
+    if (!meta?.claims || typeof meta.claims !== 'object' || Array.isArray(meta.claims))
+        throw new TypeError('claims_first_resource_required');
+    return clone(meta.claims);
+}
+function uuidIdentifier(value) {
+    const normalized = text(value);
+    if (!normalized?.startsWith('urn:uuid:') || normalized.length <= 'urn:uuid:'.length)
+        throw new TypeError('encounter_history_identifier_invalid');
+    return normalized.slice('urn:uuid:'.length);
+}
+function requireDateTime(value) {
+    if (!/^\d{4}-\d{2}-\d{2}T/.test(value) || Number.isNaN(Date.parse(value)))
+        throw new TypeError('transfer_occurred_at_invalid');
+}
+function text(value) { return typeof value === 'string' && value.trim() ? value.trim() : undefined; }
+function clone(value) { return JSON.parse(JSON.stringify(value)); }

package/dist/equipment-compliance-orchestration.d.ts

@@ -0,0 +1,39 @@
+import { buildDeviceCalibrationFlatGraph, buildDeviceOperatingAuthorizationFlatResource } from 'fhir-data-utils-ts';
+export type EquipmentComplianceAction = 'record-calibration' | 'publish-operating-authorization';
+export type EquipmentComplianceActorContext = Readonly<{
+    actorReference: string;
+    departmentReference: string;
+}>;
+export type EquipmentComplianceDecision = EquipmentComplianceActorContext & Readonly<{
+    action: EquipmentComplianceAction;
+}>;
+/**
+ * Runtime-neutral authorization boundary for equipment compliance records.
+ * Products decide whether the authenticated assignment in its department may perform the action;
+ * the shared SDK never infers authority from a job-title string.
+ */
+export interface EquipmentComplianceAuthorizer {
+    authorize(decision: EquipmentComplianceDecision): boolean;
+}
+type CalibrationInput = Parameters<typeof buildDeviceCalibrationFlatGraph>[0];
+type OperatingAuthorizationInput = Parameters<typeof buildDeviceOperatingAuthorizationFlatResource>[0];
+/** Prepares standard claims-first records after an explicit product authorization decision. */
+export declare class EquipmentComplianceManager {
+    private readonly authorizer;
+    constructor(authorizer: EquipmentComplianceAuthorizer);
+    prepareCalibration(input: CalibrationInput, actorContext: EquipmentComplianceActorContext): readonly Readonly<{
+        resourceType: "DocumentReference" | "Procedure" | "DeviceMetric" | "RegulatedAuthorization";
+        id: string;
+        meta: Readonly<{
+            claims: Readonly<Record<string, string>>;
+        }>;
+    }>[];
+    prepareOperatingAuthorization(input: OperatingAuthorizationInput, actorContext: EquipmentComplianceActorContext): Readonly<{
+        resourceType: "DocumentReference" | "Procedure" | "DeviceMetric" | "RegulatedAuthorization";
+        id: string;
+        meta: Readonly<{
+            claims: Readonly<Record<string, string>>;
+        }>;
+    }>;
+}
+export {};

package/dist/equipment-compliance-orchestration.js

@@ -0,0 +1,18 @@
+import { buildDeviceCalibrationFlatGraph, buildDeviceOperatingAuthorizationFlatResource, } from 'fhir-data-utils-ts';
+/** Prepares standard claims-first records after an explicit product authorization decision. */
+export class EquipmentComplianceManager {
+    constructor(authorizer) {
+        this.authorizer = authorizer;
+    }
+    prepareCalibration(input, actorContext) {
+        if (!this.authorizer.authorize({ action: 'record-calibration', ...actorContext }))
+            throw new Error('equipment_calibration_forbidden');
+        return buildDeviceCalibrationFlatGraph(input);
+    }
+    prepareOperatingAuthorization(input, actorContext) {
+        if (!this.authorizer.authorize({ action: 'publish-operating-authorization', ...actorContext })) {
+            throw new Error('equipment_operating_authorization_forbidden');
+        }
+        return buildDeviceOperatingAuthorizationFlatResource(input);
+    }
+}

package/dist/fhir-scheduling.d.ts

@@ -0,0 +1,40 @@
+export declare const FHIR_SCHEDULING_REQUEST_TIMEOUT_MS = 3000;
+export type FhirSchedulingResourceType = 'Appointment' | 'AppointmentResponse' | 'Schedule' | 'Slot' | 'Subscription';
+export type FhirSchedulingResourceCapability = Readonly<{
+    resourceType: FhirSchedulingResourceType;
+    supported: boolean;
+    interactions: readonly string[];
+}>;
+export type FhirSchedulingCapabilitySummary = Readonly<{
+    fhirVersion: string;
+    softwareName?: string;
+    resources: readonly FhirSchedulingResourceCapability[];
+}>;
+export type FhirAccessTokenProvider = Readonly<{
+    getAccessToken(): Promise<string>;
+}>;
+export type FhirFetchResponse = Readonly<{
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+}>;
+export type FhirFetch = (url: string, init?: Readonly<Record<string, unknown>>) => Promise<FhirFetchResponse>;
+export type FhirSchedulingClientOptions = Readonly<{
+    baseUrl: string;
+    fetchFn?: FhirFetch;
+    accessTokenProvider?: FhirAccessTokenProvider;
+    timeoutMs?: number;
+    accept?: string;
+}>;
+/** Capability-driven FHIR scheduling client shared by every sector. */
+export declare class FhirSchedulingClient {
+    #private;
+    private readonly options;
+    readonly baseUrl: string;
+    constructor(options: FhirSchedulingClientOptions);
+    discoverCapabilities(): Promise<FhirSchedulingCapabilitySummary>;
+    searchAppointments(parameters: Readonly<Record<string, string>>): Promise<Record<string, unknown>>;
+    searchSlots(parameters: Readonly<Record<string, string>>): Promise<Record<string, unknown>>;
+    createAppointment(appointment: Readonly<Record<string, unknown>>): Promise<Record<string, unknown>>;
+    createAppointmentResponse(response: Readonly<Record<string, unknown>>): Promise<Record<string, unknown>>;
+}