sos-sdk-core-ts 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## Unreleased
+
+- Add the claims-first Encounter transfer projection helper. It keeps a
+  returning source `on-hold`, completes a definitive source departure, starts
+  the destination `in-progress`, records both `EncounterHistory` milestones,
+  and sends the already-committed result to the subject index in one completed
+  Communication batch.
+- Document that movement does not imply `discharged`, that department sender,
+  HealthcareService and authenticated audit actor remain distinct, and that
+  emergency-contact files stay DocumentReference resources inside the Bundle.
+
+- Add the neutral `bundle-changes-response` contract and publish its scheduling
+  ownership guide. UHC consumers no longer expose a provisional copy.
+
+- Move the standard Appointment-in-Communication authoring flow and the
+  capability-driven FHIR scheduling client into the shared SOS/Vet/UHC layer.
+  Product packages no longer need human or veterinary wrappers for standard
+  FHIR resources.
+- Remove temporary SOSChain-prefixed emergency authorization aliases and data
+  reexport subpaths. Emergency Group and card-to-Place records now come from
+  their single owner, `sos-data-utils-ts@0.6.0`.
+- Consume the complete shared Task status vocabulary directly instead of
+  maintaining a local compatibility overlay.
+
 ## 0.4.0 - 2026-09-29
 
 - Add the shared high-level Communication Bundle editor and reader for SOS,

package/README.md

@@ -57,6 +57,10 @@ contains exactly one inner document, batch or collection Bundle in its
 audio or `text/calendar` are DocumentReference entries inside the inner Bundle.
 Native FHIR R4/R5 is materialized only at an explicit adapter boundary. See
 [Communication Bundle editor and reader](docs/COMMUNICATION_BUNDLE_EDITOR_READER.md).
+The shared scheduling and response-correlation boundary is documented in
+[FHIR scheduling interoperability](docs/FHIR_SCHEDULING_INTEROPERABILITY.md).
+Source-to-destination care movement and subject-index projection are documented
+in [Encounter transfer projection](docs/ENCOUNTER_TRANSFER_PROJECTION.md).
 
 The emergency-group contract stores subject references only on an enumerated
 FHIR Group. A group assistance request references that Group from one standard,
@@ -72,11 +76,9 @@ The `incident-reporter` relationship represents a short-lived grant issued by
 a trusted scan resolver to an already verified person at the scene; it does
 not imply guardianship, control or professional status.
 
-The older `SoschainEmergency*` names remain deprecated compatibility aliases
-to the same types and implementation; they are not a second contract.
-
-`buildSoschainPlaceCardAssociationClaims` records a UHC/VetChain card link to
-a canonical SOSChain Place or vehicle without merging either identity.
+Emergency evidence, Group records and card-to-Place associations are imported
+directly from `sos-data-utils-ts`; this orchestration package does not retain
+temporary reexport subpaths or product-prefixed authorization aliases.
 
 ## Care, emergency and alert orchestration
 

package/dist/bundle-changes-response.d.ts

@@ -0,0 +1,32 @@
+import type { BundleEntry, BundleJsonApi } from 'gdc-common-utils-ts/models/bundle';
+export declare const BundleChangeResponseStates: Readonly<{
+    readonly Successful: "successful";
+    readonly Failed: "failed";
+    readonly Pending: "pending";
+}>;
+export type BundleChangeResponseState = typeof BundleChangeResponseStates[keyof typeof BundleChangeResponseStates];
+export type BundleChangeResponseItem = Readonly<{
+    identifier: string;
+    changeEntryIndex: number;
+    responseEntryIndex?: number;
+    state: BundleChangeResponseState;
+    responseStatus?: string;
+    diagnostics: readonly string[];
+}>;
+export type BundleChangesResponseAnalysis = Readonly<{
+    entries: readonly BundleChangeResponseItem[];
+    successfulIdentifiers: readonly string[];
+    failedIdentifiers: readonly string[];
+    pendingIdentifiers: readonly string[];
+    diagnostics: readonly string[];
+}>;
+/** Reads every stable identifier carried by one Bundle entry in preference order. */
+export declare function readBundleEntryCorrelationIdentifiers(entry: BundleEntry): readonly string[];
+/**
+ * Correlates the submitted changes Bundle with the GW Bundle response.
+ *
+ * Correlation uses stable identifiers only, never array position. A missing,
+ * malformed or ambiguous response remains pending until the caller performs
+ * the resource-specific authoritative search.
+ */
+export declare function analyzeBundleChangesResponse(changesBundle: BundleJsonApi<BundleEntry>, responseBundle: BundleJsonApi<BundleEntry>): BundleChangesResponseAnalysis;

package/dist/bundle-changes-response.js

@@ -0,0 +1,154 @@
+// Copyright 2026 Connecting Solution & Applications Ltd under the Apache License, Version 2.0.
+export const BundleChangeResponseStates = Object.freeze({
+    Successful: 'successful',
+    Failed: 'failed',
+    Pending: 'pending',
+});
+function asRecord(value) {
+    return value !== null && typeof value === 'object'
+        ? value
+        : {};
+}
+function asNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function appendIdentifier(target, value) {
+    const identifier = asNonEmptyString(value);
+    if (identifier && !target.includes(identifier))
+        target.push(identifier);
+}
+function appendClaimIdentifiers(target, claims) {
+    for (const [name, value] of Object.entries(claims)) {
+        if (name === 'identifier' || name.endsWith('.identifier') || name.endsWith('.identifier.value')) {
+            appendIdentifier(target, value);
+        }
+    }
+}
+/** Reads every stable identifier carried by one Bundle entry in preference order. */
+export function readBundleEntryCorrelationIdentifiers(entry) {
+    const identifiers = [];
+    const resource = asRecord(entry.resource);
+    const resourceMeta = asRecord(resource.meta);
+    const entryMeta = asRecord(entry.meta);
+    appendIdentifier(identifiers, entry.fullUrl);
+    appendIdentifier(identifiers, resource.id);
+    appendIdentifier(identifiers, entry.id);
+    appendClaimIdentifiers(identifiers, asRecord(resourceMeta.claims));
+    appendClaimIdentifiers(identifiers, asRecord(entryMeta.claims));
+    return identifiers;
+}
+function readBundleEntryResponseOutcome(entry) {
+    const response = asRecord(entry.response);
+    const outcome = asRecord(response.outcome);
+    const issues = Array.isArray(outcome.issue) ? outcome.issue.map(asRecord) : [];
+    const severities = [];
+    const diagnostics = [];
+    for (const issue of issues) {
+        const severity = asNonEmptyString(issue.severity)?.toLowerCase();
+        if (severity)
+            severities.push(severity);
+        const diagnostic = asNonEmptyString(issue.diagnostics)
+            ?? asNonEmptyString(asRecord(issue.details).text);
+        if (diagnostic)
+            diagnostics.push(diagnostic);
+    }
+    const status = asNonEmptyString(response.status);
+    return { ...(status ? { status } : {}), severities, diagnostics };
+}
+function isSuccessfulStatus(status) {
+    return !!status && /^2\d\d(?:\s|$)/.test(status);
+}
+/**
+ * Correlates the submitted changes Bundle with the GW Bundle response.
+ *
+ * Correlation uses stable identifiers only, never array position. A missing,
+ * malformed or ambiguous response remains pending until the caller performs
+ * the resource-specific authoritative search.
+ */
+export function analyzeBundleChangesResponse(changesBundle, responseBundle) {
+    const responseEntries = responseBundle.data.map((entry, index) => ({
+        entry,
+        index,
+        identifiers: readBundleEntryCorrelationIdentifiers(entry),
+    }));
+    const seenChangeIdentifiers = new Set();
+    const claimedResponseIndexes = new Set();
+    const diagnostics = [];
+    const entries = [];
+    const changes = changesBundle.data.map((changeEntry, changeEntryIndex) => {
+        const identifiers = readBundleEntryCorrelationIdentifiers(changeEntry);
+        const identifier = identifiers[0];
+        if (!identifier) {
+            throw new Error(`Changes Bundle entry ${changeEntryIndex} requires a stable fullUrl, resource.id, entry.id or identifier claim.`);
+        }
+        if (seenChangeIdentifiers.has(identifier)) {
+            throw new Error(`Changes Bundle contains duplicate primary identifier '${identifier}'.`);
+        }
+        seenChangeIdentifiers.add(identifier);
+        return {
+            index: changeEntryIndex,
+            identifier,
+            matchingResponses: responseEntries.filter((candidate) => candidate.identifiers.some((candidateIdentifier) => identifiers.includes(candidateIdentifier))),
+        };
+    });
+    const responseMatchCounts = new Map();
+    changes.forEach(({ matchingResponses }) => matchingResponses.forEach(({ index }) => {
+        responseMatchCounts.set(index, (responseMatchCounts.get(index) ?? 0) + 1);
+    }));
+    changes.forEach(({ identifier, index: changeEntryIndex, matchingResponses }) => {
+        if (matchingResponses.length !== 1) {
+            const message = matchingResponses.length === 0
+                ? `No response entry carries a stable identifier for change '${identifier}'.`
+                : `More than one response entry matches change '${identifier}'.`;
+            diagnostics.push(message);
+            entries.push({ identifier, changeEntryIndex, state: BundleChangeResponseStates.Pending, diagnostics: [message] });
+            return;
+        }
+        const match = matchingResponses[0];
+        if ((responseMatchCounts.get(match.index) ?? 0) > 1) {
+            const message = `Response entry ${match.index} ambiguously matches more than one submitted change.`;
+            diagnostics.push(message);
+            entries.push({
+                identifier,
+                changeEntryIndex,
+                responseEntryIndex: match.index,
+                state: BundleChangeResponseStates.Pending,
+                diagnostics: [message],
+            });
+            return;
+        }
+        claimedResponseIndexes.add(match.index);
+        const outcome = readBundleEntryResponseOutcome(match.entry);
+        const hasError = outcome.severities.some((severity) => severity === 'fatal' || severity === 'error');
+        const state = !outcome.status
+            ? BundleChangeResponseStates.Pending
+            : isSuccessfulStatus(outcome.status) && !hasError
+                ? BundleChangeResponseStates.Successful
+                : BundleChangeResponseStates.Failed;
+        const itemDiagnostics = [...outcome.diagnostics];
+        if (!outcome.status)
+            itemDiagnostics.push(`Response entry ${match.index} has no status.`);
+        entries.push({
+            identifier,
+            changeEntryIndex,
+            responseEntryIndex: match.index,
+            state,
+            ...(outcome.status ? { responseStatus: outcome.status } : {}),
+            diagnostics: itemDiagnostics,
+        });
+    });
+    responseEntries.forEach(({ index }) => {
+        if (!claimedResponseIndexes.has(index)) {
+            diagnostics.push(`Response entry ${index} does not correlate with one submitted change.`);
+        }
+    });
+    return {
+        entries,
+        successfulIdentifiers: entries.filter(({ state }) => state === BundleChangeResponseStates.Successful).map(({ identifier }) => identifier),
+        failedIdentifiers: entries.filter(({ state }) => state === BundleChangeResponseStates.Failed).map(({ identifier }) => identifier),
+        pendingIdentifiers: entries.filter(({ state }) => state === BundleChangeResponseStates.Pending).map(({ identifier }) => identifier),
+        diagnostics,
+    };
+}

package/dist/care-emergency-alert-orchestration.js

@@ -89,17 +89,6 @@ export function orchestrateEmergencyRequest(input) {
     });
     return Object.freeze({ intake, serviceRequestEntry, triageTaskEntry });
 }
-// Compatibility overlay for the published data package used by clean installs.
-// The next grouped release exposes the same standard values directly there.
-const EmergencyTaskStatus = Object.freeze({
-    ...TaskStatus,
-    Received: 'received',
-    Accepted: 'accepted',
-    Rejected: 'rejected',
-    Ready: 'ready',
-    OnHold: 'on-hold',
-    EnteredInError: 'entered-in-error',
-});
 /**
  * Reads only the standard, claims-first coordinates required by a responder
  * console. It does not resolve contact endpoints or grant callback authority.
@@ -110,7 +99,7 @@ export function readEmergencyTriageTask(taskEntry) {
     }
     const claims = taskEntry.claims;
     const status = scalarClaim(claims[TaskClaim.Status], 'emergency_triage_status_required');
-    if (!Object.values(EmergencyTaskStatus).includes(status)) {
+    if (!Object.values(TaskStatus).includes(status)) {
         throw new TypeError('emergency_triage_status_invalid');
     }
     return Object.freeze({
@@ -161,7 +150,7 @@ export function prepareEmergencyResponderCallback(input) {
     const responderReference = reference(input.responderReference, 'PractitionerRole', 'emergency_callback_responder_invalid');
     if (task.ownerReference !== responderReference)
         throw new TypeError('emergency_callback_task_owner_required');
-    if (task.status !== EmergencyTaskStatus.Accepted && task.status !== EmergencyTaskStatus.InProgress) {
+    if (task.status !== TaskStatus.Accepted && task.status !== TaskStatus.InProgress) {
         throw new TypeError('emergency_callback_active_task_required');
     }
     if (!task.communicationThreadId)
@@ -180,20 +169,20 @@ export function prepareEmergencyResponderCallback(input) {
 }
 function emergencyTriageTransition(currentStatus, action) {
     const transitions = {
-        acknowledge: { [EmergencyTaskStatus.Requested]: EmergencyTaskStatus.Accepted, [EmergencyTaskStatus.Received]: EmergencyTaskStatus.Accepted },
-        start: { [EmergencyTaskStatus.Accepted]: EmergencyTaskStatus.InProgress, [EmergencyTaskStatus.Ready]: EmergencyTaskStatus.InProgress },
+        acknowledge: { [TaskStatus.Requested]: TaskStatus.Accepted, [TaskStatus.Received]: TaskStatus.Accepted },
+        start: { [TaskStatus.Accepted]: TaskStatus.InProgress, [TaskStatus.Ready]: TaskStatus.InProgress },
         escalate: {
-            [EmergencyTaskStatus.Requested]: EmergencyTaskStatus.Requested,
-            [EmergencyTaskStatus.Received]: EmergencyTaskStatus.Requested,
-            [EmergencyTaskStatus.Accepted]: EmergencyTaskStatus.Requested,
-            [EmergencyTaskStatus.InProgress]: EmergencyTaskStatus.Requested,
+            [TaskStatus.Requested]: TaskStatus.Requested,
+            [TaskStatus.Received]: TaskStatus.Requested,
+            [TaskStatus.Accepted]: TaskStatus.Requested,
+            [TaskStatus.InProgress]: TaskStatus.Requested,
         },
         reject: {
-            [EmergencyTaskStatus.Requested]: EmergencyTaskStatus.Rejected,
-            [EmergencyTaskStatus.Received]: EmergencyTaskStatus.Rejected,
-            [EmergencyTaskStatus.Accepted]: EmergencyTaskStatus.Rejected,
+            [TaskStatus.Requested]: TaskStatus.Rejected,
+            [TaskStatus.Received]: TaskStatus.Rejected,
+            [TaskStatus.Accepted]: TaskStatus.Rejected,
         },
-        complete: { [EmergencyTaskStatus.InProgress]: EmergencyTaskStatus.Completed },
+        complete: { [TaskStatus.InProgress]: TaskStatus.Completed },
     };
     const nextStatus = transitions[action]?.[currentStatus];
     if (!nextStatus)

package/dist/communication-bundle.d.ts

@@ -15,6 +15,28 @@ export type AttachmentDocumentInput = Readonly<{
     authorReferences?: readonly string[];
     eventReferences?: readonly string[];
 }>;
+export type AppointmentCommunicationBundleInput = Readonly<{
+    communicationIdentifier: string;
+    status: string;
+    category?: string | readonly string[];
+    topic?: string;
+    text?: string;
+    subjectReference: string;
+    senderReference: string;
+    recipientReferences: readonly string[];
+    sent?: string;
+    appointment: FhirResource & Readonly<{
+        resourceType: 'Appointment';
+        id: string;
+    }>;
+    calendarDocument?: Readonly<{
+        identifier: string;
+        contentType: 'text/calendar';
+        dataBase64?: string;
+        url?: string;
+        title?: string;
+    }>;
+}>;
 /**
  * SOS/Vet/UHC extension of the existing GDC BundleEditor.
  *
@@ -30,6 +52,18 @@ export declare class CommunicationBundleEditor extends BundleEditor {
     /** Builds the inherited claims-first outer batch after validating every attached Bundle. */
     build(): ReturnType<BundleEditor['build']>;
 }
+/**
+ * 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 declare class AppointmentCommunicationBundleEditor extends CommunicationBundleEditor {
+    addAppointmentCommunication(input: AppointmentCommunicationBundleInput): this;
+}
+/** Authors one standard Appointment delivery without a product-specific wrapper. */
+export declare function prepareAppointmentCommunicationBundle(input: AppointmentCommunicationBundleInput): Record<string, unknown>;
 /** High-level message editor extending the established attached-Bundle session. */
 export declare class CommunicationMessageEditor extends CommunicationAttachedBundleSession {
     #private;

package/dist/communication-bundle.js

@@ -15,7 +15,7 @@ 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 { DocumentReferenceClaim } from 'fhir-data-utils-ts';
+import { AppointmentClaim, DocumentReferenceClaim } from 'fhir-data-utils-ts';
 /**
  * SOS/Vet/UHC extension of the existing GDC BundleEditor.
  *
@@ -62,6 +62,52 @@ _CommunicationBundleEditor_messages = new WeakMap(), _CommunicationBundleEditor_
         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) {
@@ -217,6 +263,23 @@ function claimsFromResource(resource) {
 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');

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/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>>;
+}

package/dist/fhir-scheduling.js

@@ -0,0 +1,127 @@
+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 __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 _FhirSchedulingClient_instances, _FhirSchedulingClient_fetchFn, _FhirSchedulingClient_timeoutMs, _FhirSchedulingClient_capability, _FhirSchedulingClient_search, _FhirSchedulingClient_requireInteraction, _FhirSchedulingClient_request;
+export const FHIR_SCHEDULING_REQUEST_TIMEOUT_MS = 3000;
+const schedulingResourceTypes = Object.freeze([
+    'Appointment',
+    'AppointmentResponse',
+    'Schedule',
+    'Slot',
+    'Subscription',
+]);
+/** Capability-driven FHIR scheduling client shared by every sector. */
+export class FhirSchedulingClient {
+    constructor(options) {
+        _FhirSchedulingClient_instances.add(this);
+        this.options = options;
+        _FhirSchedulingClient_fetchFn.set(this, void 0);
+        _FhirSchedulingClient_timeoutMs.set(this, void 0);
+        _FhirSchedulingClient_capability.set(this, void 0);
+        this.baseUrl = normalizeBaseUrl(options.baseUrl);
+        __classPrivateFieldSet(this, _FhirSchedulingClient_fetchFn, options.fetchFn ?? globalThis.fetch, "f");
+        __classPrivateFieldSet(this, _FhirSchedulingClient_timeoutMs, requireSchedulingTimeout(options.timeoutMs), "f");
+    }
+    async discoverCapabilities() {
+        const metadata = await __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_request).call(this, 'metadata');
+        if (metadata.resourceType !== 'CapabilityStatement') {
+            throw new TypeError('fhir_capability_statement_required');
+        }
+        const resources = array(metadata.rest).flatMap(rest => array(record(rest).resource));
+        __classPrivateFieldSet(this, _FhirSchedulingClient_capability, Object.freeze({
+            fhirVersion: text(metadata.fhirVersion),
+            ...(optionalText(record(metadata.software).name)
+                ? { softwareName: optionalText(record(metadata.software).name) }
+                : {}),
+            resources: Object.freeze(schedulingResourceTypes.map(resourceType => {
+                const resource = resources.map(record).find(candidate => candidate.type === resourceType);
+                return Object.freeze({
+                    resourceType,
+                    supported: Boolean(resource),
+                    interactions: Object.freeze(array(resource?.interaction).map(item => text(record(item).code))),
+                });
+            })),
+        }), "f");
+        return __classPrivateFieldGet(this, _FhirSchedulingClient_capability, "f");
+    }
+    async searchAppointments(parameters) {
+        await __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_requireInteraction).call(this, 'Appointment', 'search-type');
+        return __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_search).call(this, 'Appointment', parameters);
+    }
+    async searchSlots(parameters) {
+        await __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_requireInteraction).call(this, 'Slot', 'search-type');
+        return __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_search).call(this, 'Slot', parameters);
+    }
+    async createAppointment(appointment) {
+        await __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_requireInteraction).call(this, 'Appointment', 'create');
+        return __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_request).call(this, 'Appointment', { method: 'POST', body: JSON.stringify(appointment) });
+    }
+    async createAppointmentResponse(response) {
+        await __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_requireInteraction).call(this, 'AppointmentResponse', 'create');
+        return __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_request).call(this, 'AppointmentResponse', { method: 'POST', body: JSON.stringify(response) });
+    }
+}
+_FhirSchedulingClient_fetchFn = new WeakMap(), _FhirSchedulingClient_timeoutMs = new WeakMap(), _FhirSchedulingClient_capability = new WeakMap(), _FhirSchedulingClient_instances = new WeakSet(), _FhirSchedulingClient_search = async function _FhirSchedulingClient_search(resourceType, parameters) {
+    return __classPrivateFieldGet(this, _FhirSchedulingClient_instances, "m", _FhirSchedulingClient_request).call(this, `${resourceType}?${new URLSearchParams(parameters)}`);
+}, _FhirSchedulingClient_requireInteraction = async function _FhirSchedulingClient_requireInteraction(resourceType, interaction) {
+    const capability = __classPrivateFieldGet(this, _FhirSchedulingClient_capability, "f") ?? await this.discoverCapabilities();
+    const resource = capability.resources.find(candidate => candidate.resourceType === resourceType);
+    if (!resource?.supported || !resource.interactions.includes(interaction)) {
+        throw new TypeError(`Configured FHIR server does not advertise ${resourceType}.${interaction}.`);
+    }
+}, _FhirSchedulingClient_request = async function _FhirSchedulingClient_request(path, init = {}) {
+    const token = this.options.accessTokenProvider
+        ? await this.options.accessTokenProvider.getAccessToken()
+        : undefined;
+    const response = await __classPrivateFieldGet(this, _FhirSchedulingClient_fetchFn, "f").call(this, `${this.baseUrl}/${path}`, {
+        ...init,
+        signal: AbortSignal.timeout(__classPrivateFieldGet(this, _FhirSchedulingClient_timeoutMs, "f")),
+        headers: {
+            accept: this.options.accept ?? 'application/fhir+json',
+            ...(init.body ? { 'content-type': 'application/fhir+json' } : {}),
+            ...(token ? { authorization: `Bearer ${token}` } : {}),
+        },
+    });
+    const responseText = await response.text();
+    const body = parseResponseBody(responseText);
+    if (!response.ok)
+        throw new Error(`FHIR scheduling request failed (${response.status}).`);
+    return record(body);
+};
+function normalizeBaseUrl(value) {
+    const baseUrl = String(value ?? '').trim().replace(/\/+$/u, '');
+    if (!baseUrl)
+        throw new TypeError('fhir_base_url_required');
+    return baseUrl;
+}
+function requireSchedulingTimeout(value) {
+    const timeoutMs = value ?? FHIR_SCHEDULING_REQUEST_TIMEOUT_MS;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > FHIR_SCHEDULING_REQUEST_TIMEOUT_MS) {
+        throw new RangeError(`FHIR scheduling timeout must be between 1 and ${FHIR_SCHEDULING_REQUEST_TIMEOUT_MS} ms.`);
+    }
+    return timeoutMs;
+}
+function parseResponseBody(value) {
+    if (!value)
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return { text: value };
+    }
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function array(value) { return Array.isArray(value) ? value : []; }
+function optionalText(value) { return typeof value === 'string' && value.trim() ? value.trim() : undefined; }
+function text(value) { return optionalText(value) ?? ''; }

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 /** Shared runtime-neutral orchestration remains independent from product SDKs. */
-export { EmergencyCapabilities, EvidenceDomains, EvidenceRelationships, SoschainEmergencyCapabilities, SoschainEvidenceDomains, SoschainEvidenceRelationships, } from 'sos-data-utils-ts/emergency-evidence';
-export type { EvidenceRelationship, SoschainEvidenceRelationship, } from 'sos-data-utils-ts/emergency-evidence';
-export * from './emergency-group.js';
+export { EmergencyCapabilities, EvidenceDomains, EvidenceRelationships, } from 'sos-data-utils-ts/emergency-evidence';
+export type { EvidenceRelationship, } from 'sos-data-utils-ts/emergency-evidence';
 export * from './emergency-authorization.js';
 export * from './care-emergency-alert-orchestration.js';
-export * from './place-card-association.js';
 export * from './secure-message-crypto.js';
 export * from './equipment-compliance-orchestration.js';
 export * from './communication-bundle.js';
+export * from './fhir-scheduling.js';
+export * from './bundle-changes-response.js';
+export * from './encounter-transfer-communication.js';

package/dist/index.js

@@ -1,9 +1,10 @@
 /** Shared runtime-neutral orchestration remains independent from product SDKs. */
-export { EmergencyCapabilities, EvidenceDomains, EvidenceRelationships, SoschainEmergencyCapabilities, SoschainEvidenceDomains, SoschainEvidenceRelationships, } from 'sos-data-utils-ts/emergency-evidence';
-export * from './emergency-group.js';
+export { EmergencyCapabilities, EvidenceDomains, EvidenceRelationships, } from 'sos-data-utils-ts/emergency-evidence';
 export * from './emergency-authorization.js';
 export * from './care-emergency-alert-orchestration.js';
-export * from './place-card-association.js';
 export * from './secure-message-crypto.js';
 export * from './equipment-compliance-orchestration.js';
 export * from './communication-bundle.js';
+export * from './fhir-scheduling.js';
+export * from './bundle-changes-response.js';
+export * from './encounter-transfer-communication.js';

package/docs/COMMUNICATION_BUNDLE_EDITOR_READER.md

@@ -24,26 +24,23 @@ unordered group such as an Appointment and its calendar attachment.
 ## Author
 
 ```ts
-import { CommunicationBundleEditor } from 'sos-sdk-core-ts'
+import { AppointmentCommunicationBundleEditor } from 'sos-sdk-core-ts'
 
-const outerBatch = new CommunicationBundleEditor()
-  .newCommunication()
-  .setIdentifier(communicationIdentifier)
-  .setStatus('completed')
-  .setSubject(subjectReference)
-  .setSender(departmentOrganizationReference)
-  .setRecipients(recipientReferences)
-  .setInnerBundleType('collection')
-  .addResource(appointment)
-  .addAttachmentDocument({
-    identifier: calendarDocumentIdentifier,
+const outerBatch = new AppointmentCommunicationBundleEditor()
+  .addAppointmentCommunication({
+    communicationIdentifier,
+    status: 'completed',
     subjectReference,
-    contentType: 'text/calendar',
-    dataBase64: calendarDataBase64,
-    title: 'appointment.ics',
-    eventReferences: [appointmentReference],
+    senderReference: departmentOrganizationReference,
+    recipientReferences,
+    appointment,
+    calendarDocument: {
+      identifier: calendarDocumentIdentifier,
+      contentType: 'text/calendar',
+      dataBase64: calendarDataBase64,
+      title: 'appointment.ics',
+    },
   })
-  .doneCommunication()
   .build()
 ```
 
@@ -82,3 +79,7 @@ outer resource that is not a batch Bundle.
 - The SOS editor subclasses the established GDC Bundle editor/reader and the
   attached-Bundle session. A future antifraud-common implementation can replace
   that base behind this shared SOS API without migrating Vet and UHC separately.
+- `AppointmentCommunicationBundleEditor` and `FhirSchedulingClient` are named
+  after their FHIR responsibilities. Product packages must not introduce
+  `HumanAppointment`, `VeterinaryAppointment`, `HumanCommunication` or similar
+  wrappers for standard resources.

package/docs/ENCOUNTER_TRANSFER_PROJECTION.md

@@ -0,0 +1,38 @@
+# Encounter transfer projection
+
+The care provider owns the authoritative movement transaction. When a person
+leaves one operational service and arrives at another, the provider persists:
+
+1. the source `Encounter` as `on-hold` when the person will return, or
+   `completed` when the departure is definitive;
+2. one source `EncounterHistory` milestone with the same state;
+3. the destination `Encounter` as `in-progress` on confirmed arrival; and
+4. one destination `EncounterHistory` milestone.
+
+`discharged` is not a movement synonym. It is reserved for the separate
+clinical discharge stage. A diagnostic test, operation, ward move or ICU
+admission therefore does not automatically discharge the source encounter.
+
+After the provider has committed those four records, it can call
+`prepareEncounterTransferProjectionCommunication(...)`. The helper produces a
+completed `Communication` whose inner batch Bundle projects the same four
+changes to the subject-index provider. The Communication is continuity and
+discovery evidence; it is not a substitute for the provider transaction.
+
+The department Organization is `Communication.sender`. Each Encounter keeps an
+explicit `HealthcareService`. The authenticated professional/device remains
+separate audit evidence and must not be copied into sender, document author or
+attester fields.
+
+Emergency-contact delivery follows the existing Communication Bundle rules:
+
+- written text may be Communication content;
+- audio, PDF and calendar files are `DocumentReference` entries;
+- an arbitrary FHIR payload must be a validated inner Bundle;
+- a live voice or video call is not an `Appointment`;
+- a scheduled conversation may carry `Appointment`, later
+  `AppointmentResponse`, and an optional `.ics` DocumentReference.
+
+Portals should explain the outcome in plain language first. FHIR resource names
+belong in optional technical details, SDK documentation and professional
+support material—not in the primary user instruction.

package/docs/FHIR_SCHEDULING_INTEROPERABILITY.md

@@ -0,0 +1,28 @@
+# FHIR scheduling interoperability
+
+`sos-sdk-core-ts/fhir-scheduling` is the product-neutral scheduling boundary
+shared by SOS, Vet and UHC channels. It discovers the remote
+`CapabilityStatement` before using `Schedule`, `Slot` or `Appointment` and
+fails closed when the provider does not advertise the required interaction.
+
+Portal, telephone, chatbot and other channel adapters call the same client.
+They must not introduce human- or animal-prefixed Appointment types. Sector
+policy decides who may search or write; the FHIR resource contract stays the
+same.
+
+An appointment message is authored with
+`AppointmentCommunicationBundleEditor`. The outer transport is a Bundle of
+FHIR `Communication` resources. Each Communication carries one inner document,
+batch or collection Bundle; an optional calendar file is a `DocumentReference`
+inside that inner Bundle, never a bare `text/calendar` Communication payload.
+
+`analyzeBundleChangesResponse(changesBundle, responseBundle)` correlates a GW
+response by stable identifiers. Missing, malformed or ambiguous responses stay
+pending until the caller performs an authoritative resource search; array
+position is never treated as identity.
+
+Executable contracts:
+
+- `tests/fhir-scheduling.test.mjs`
+- `tests/communication-bundle.test.mjs`
+- `tests/bundle-changes-response.test.mjs`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sos-sdk-core-ts",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Runtime-neutral shared orchestration for SOS, Vet and UHC products",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -16,10 +16,6 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./emergency-group": {
-      "types": "./dist/emergency-group.d.ts",
-      "default": "./dist/emergency-group.js"
-    },
     "./care-emergency-alert-orchestration": {
       "types": "./dist/care-emergency-alert-orchestration.d.ts",
       "default": "./dist/care-emergency-alert-orchestration.js"
@@ -28,10 +24,6 @@
       "types": "./dist/emergency-authorization.d.ts",
       "default": "./dist/emergency-authorization.js"
     },
-    "./place-card-association": {
-      "types": "./dist/place-card-association.d.ts",
-      "default": "./dist/place-card-association.js"
-    },
     "./secure-message-crypto": {
       "types": "./dist/secure-message-crypto.d.ts",
       "default": "./dist/secure-message-crypto.js"
@@ -43,6 +35,18 @@
     "./communication-bundle": {
       "types": "./dist/communication-bundle.d.ts",
       "default": "./dist/communication-bundle.js"
+    },
+    "./fhir-scheduling": {
+      "types": "./dist/fhir-scheduling.d.ts",
+      "default": "./dist/fhir-scheduling.js"
+    },
+    "./bundle-changes-response": {
+      "types": "./dist/bundle-changes-response.d.ts",
+      "default": "./dist/bundle-changes-response.js"
+    },
+    "./encounter-transfer-communication": {
+      "types": "./dist/encounter-transfer-communication.d.ts",
+      "default": "./dist/encounter-transfer-communication.js"
     }
   },
   "files": [
@@ -63,9 +67,9 @@
     "@noble/ciphers": "2.4.0",
     "@noble/hashes": "2.4.0",
     "@noble/post-quantum": "0.7.1",
-    "fhir-data-utils-ts": "0.6.0",
+    "fhir-data-utils-ts": "0.6.1",
     "gdc-common-utils-ts": "2.9.21",
-    "sos-data-utils-ts": "0.5.1"
+    "sos-data-utils-ts": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "^22.5.0",

package/dist/emergency-group.d.ts

@@ -1,2 +0,0 @@
-/** Compatibility subpath for the canonical shared emergency record contracts. */
-export * from 'sos-data-utils-ts/emergency-group';

package/dist/emergency-group.js

@@ -1,2 +0,0 @@
-/** Compatibility subpath for the canonical shared emergency record contracts. */
-export * from 'sos-data-utils-ts/emergency-group';

package/dist/place-card-association.d.ts

@@ -1,2 +0,0 @@
-/** Compatibility subpath for the canonical shared card-target contracts. */
-export * from 'sos-data-utils-ts/place-card-association';

package/dist/place-card-association.js

@@ -1,2 +0,0 @@
-/** Compatibility subpath for the canonical shared card-target contracts. */
-export * from 'sos-data-utils-ts/place-card-association';