gdc-common-utils-ts 2.1.0 → 2.3.0

package/dist/utils/clinical-resource-view.js

@@ -17,16 +17,17 @@ const GENERIC_ASSERTER_CLAIM_SUFFIX = '.asserter';
 export function toClinicalResourceCommonView(entry) {
     const claims = readClaims(entry);
     const resourceType = resolveResourceType(entry, claims);
-    const title = resolveTitle(resourceType, claims);
+    const resource = entry.resource;
+    const title = resolveTitle(resourceType, claims, resource);
     return {
         title,
         resourceType,
-        identifier: resolveIdentifier(resourceType, claims),
-        date: resolveDate(resourceType, claims),
-        periodStart: resolvePeriodStart(resourceType, claims),
-        periodEnd: resolvePeriodEnd(resourceType, claims),
+        identifier: resolveIdentifier(resourceType, claims, resource),
+        date: resolveDate(resourceType, claims, resource),
+        periodStart: resolvePeriodStart(resourceType, claims, resource),
+        periodEnd: resolvePeriodEnd(resourceType, claims, resource),
         fullUrl: trimValue(entry.fullUrl),
-        actors: resolveActors(resourceType, claims),
+        actors: resolveActors(resourceType, claims, resource),
         claims,
     };
 }
@@ -72,6 +73,51 @@ export function toClinicalResourceExpandedView(entry) {
 export function toClinicalResourceExpandedViews(bundle) {
     return readBundleEntries(bundle).map((entry) => toClinicalResourceExpandedView(entry));
 }
+/**
+ * Builds section cards from the references authored in an IPS Composition.
+ *
+ * The Composition is authoritative for grouping. Resource type is deliberately
+ * not used to guess a section because Observation and supporting resources can
+ * be referenced from several IPS sections.
+ */
+export function toClinicalSectionViews(bundle) {
+    const entries = readBundleEntries(bundle);
+    const composition = entries.find((entry) => entry.resource?.resourceType === ResourceTypesFhirR4.Composition);
+    if (!composition?.resource) {
+        return [];
+    }
+    const entryIndex = indexEntriesByFhirReference(entries);
+    return flattenCompositionSections(asArray(composition.resource.section)).map((section) => {
+        const references = asArray(section.entry)
+            .map((item) => trimValue(asRecord(item).reference))
+            .filter(Boolean);
+        const resolvedEntries = [];
+        const unresolvedReferences = [];
+        references.forEach((reference) => {
+            const resolved = resolveIndexedEntry(entryIndex, reference);
+            if (resolved) {
+                resolvedEntries.push(resolved);
+            }
+            else {
+                unresolvedReferences.push(reference);
+            }
+        });
+        const code = resolveCodeableConceptToken(section.code);
+        const title = trimValue(section.title)
+            || resolveCodeableConceptLabel(section.code)
+            || code
+            || 'Section';
+        return {
+            ...(code ? { code } : {}),
+            title,
+            ...(resolveCodeableConceptLabel(section.emptyReason)
+                ? { emptyReason: resolveCodeableConceptLabel(section.emptyReason) }
+                : {}),
+            resources: resolvedEntries.map((entry) => toClinicalResourceCardView(entry)),
+            unresolvedReferences,
+        };
+    });
+}
 /**
  * Returns the most useful local text plus international display pair that can
  * be inferred from one FHIR-like resource and its `meta.claims`.
@@ -158,18 +204,19 @@ function resolveResourceType(entry, claims) {
     }
     return 'Unknown';
 }
-function resolveTitle(resourceType, claims) {
+function resolveTitle(resourceType, claims, resource) {
     if (resourceType === ResourceTypesFhirR4.Communication) {
         return (trimValue(claims[CommunicationClaim.ContentAttachmentTitle])
             || trimValue(claims[CommunicationClaim.Text])
             || trimValue(claims[CommunicationClaim.NoteText])
+            || resolveFhirResourceTitle(resourceType, resource)
             || resourceType);
     }
     if (resourceType === ResourceTypesFhirR4.Consent) {
         const firstCategory = splitCsv(claims[ClaimConsent.category])[0];
         const firstAction = splitCsv(claims[ClaimConsent.action])[0];
         const firstPurpose = splitCsv(claims[ClaimConsent.purpose])[0];
-        return firstCategory || firstAction || firstPurpose || resourceType;
+        return firstCategory || firstAction || firstPurpose || resolveFhirResourceTitle(resourceType, resource) || resourceType;
     }
     if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
         const text = firstClaimValue(claims, [
@@ -180,7 +227,7 @@ function resolveTitle(resourceType, claims) {
             MedicationStatementClaim.Code,
             MedicationStatementClaimsFhirApi.Code,
         ]);
-        return text || firstCode || resourceType;
+        return text || firstCode || resolveFhirResourceTitle(resourceType, resource) || resourceType;
     }
     if (resourceType === ResourceTypesFhirR4.Condition) {
         const firstCode = firstClaimCsvValue(claims, [
@@ -191,7 +238,7 @@ function resolveTitle(resourceType, claims) {
             ConditionClaim.Category,
             ConditionClaimsFhirApi.Category,
         ]);
-        return firstCode || firstCategory || resourceType;
+        return firstCode || firstCategory || resolveFhirResourceTitle(resourceType, resource) || resourceType;
     }
     if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
         const firstCode = firstClaimCsvValue(claims, [
@@ -202,78 +249,78 @@ function resolveTitle(resourceType, claims) {
             AllergyIntoleranceClaim.Category,
             AllergyIntoleranceClaimsFhirApi.Category,
         ]);
-        return firstCode || firstCategory || resourceType;
+        return firstCode || firstCategory || resolveFhirResourceTitle(resourceType, resource) || resourceType;
     }
-    return resourceType;
+    return resolveFhirResourceTitle(resourceType, resource) || resourceType;
 }
-function resolveIdentifier(resourceType, claims) {
+function resolveIdentifier(resourceType, claims, resource) {
     if (resourceType === ResourceTypesFhirR4.Communication) {
-        return trimValue(claims[CommunicationClaim.Identifier]);
+        return trimValue(claims[CommunicationClaim.Identifier]) || resolveFhirIdentifier(resource);
     }
     if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.identifier]);
+        return trimValue(claims[ClaimConsent.identifier]) || resolveFhirIdentifier(resource);
     }
     if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
         return firstClaimValue(claims, [
             MedicationStatementClaim.Identifier,
             MedicationStatementClaimsFhirApi.Identifier,
-        ]);
+        ]) || resolveFhirIdentifier(resource);
     }
     if (resourceType === ResourceTypesFhirR4.Condition) {
         return firstClaimValue(claims, [
             ConditionClaim.Identifier,
             ConditionClaimsFhirApi.Identifier,
-        ]);
+        ]) || resolveFhirIdentifier(resource);
     }
     if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
         return firstClaimValue(claims, [
             AllergyIntoleranceClaim.Identifier,
             AllergyIntoleranceClaimsFhirApi.Identifier,
-        ]);
+        ]) || resolveFhirIdentifier(resource);
     }
-    return undefined;
+    return resolveFhirIdentifier(resource);
 }
-function resolveDate(resourceType, claims) {
+function resolveDate(resourceType, claims, resource) {
     if (resourceType === ResourceTypesFhirR4.Communication) {
-        return trimValue(claims[CommunicationClaim.Sent]);
+        return trimValue(claims[CommunicationClaim.Sent]) || resolveFhirDate(resourceType, resource);
     }
     if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.date]);
+        return trimValue(claims[ClaimConsent.date]) || resolveFhirDate(resourceType, resource);
     }
     if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
         return firstClaimValue(claims, [
             MedicationStatementClaim.Effective,
             MedicationStatementClaimsFhirApi.Effective,
-        ]);
+        ]) || resolveFhirDate(resourceType, resource);
     }
     if (resourceType === ResourceTypesFhirR4.Condition) {
         return firstClaimValue(claims, [
             ConditionClaim.OnsetDateTime,
             ConditionClaimsFhirApi.OnsetDateTime,
-        ]);
+        ]) || resolveFhirDate(resourceType, resource);
     }
     if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
         return firstClaimValue(claims, [
             AllergyIntoleranceClaim.OnsetDateTime,
             AllergyIntoleranceClaimsFhirApi.OnsetDateTime,
-        ]);
+        ]) || resolveFhirDate(resourceType, resource);
     }
     const genericDate = findBySuffix(claims, '.date');
-    return genericDate || undefined;
+    return genericDate || resolveFhirDate(resourceType, resource) || undefined;
 }
-function resolvePeriodStart(resourceType, claims) {
+function resolvePeriodStart(resourceType, claims, resource) {
     if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.periodStart]);
+        return trimValue(claims[ClaimConsent.periodStart]) || resolveFhirPeriod(resource).start;
     }
-    return findBySuffix(claims, '.period-start') || undefined;
+    return findBySuffix(claims, '.period-start') || resolveFhirPeriod(resource).start || undefined;
 }
-function resolvePeriodEnd(resourceType, claims) {
+function resolvePeriodEnd(resourceType, claims, resource) {
     if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.periodEnd]);
+        return trimValue(claims[ClaimConsent.periodEnd]) || resolveFhirPeriod(resource).end;
     }
-    return findBySuffix(claims, '.period-end') || undefined;
+    return findBySuffix(claims, '.period-end') || resolveFhirPeriod(resource).end || undefined;
 }
-function resolveActors(resourceType, claims) {
+function resolveActors(resourceType, claims, resource) {
     const out = [];
     if (resourceType === ResourceTypesFhirR4.Consent) {
         const identifiers = splitCsv(claims[ClaimConsent.actorIdentifier]);
@@ -350,6 +397,7 @@ function resolveActors(resourceType, claims) {
     appendGenericActorType(out, claims, GENERIC_CREATOR_CLAIM_SUFFIX, 'creator');
     appendGenericActorType(out, claims, GENERIC_PERFORMER_CLAIM_SUFFIX, 'performer');
     appendGenericActorType(out, claims, GENERIC_ASSERTER_CLAIM_SUFFIX, 'asserter');
+    appendFhirActors(out, resource);
     return out;
 }
 function resolveXhtml(entry, claims) {
@@ -464,6 +512,192 @@ function resolveResourceCodeDisplay(resource) {
     }
     return undefined;
 }
+function resolveFhirResourceTitle(resourceType, resource) {
+    if (!resource) {
+        return undefined;
+    }
+    const codeableConceptCandidates = [];
+    if (resourceType === ResourceTypesFhirR4.MedicationStatement
+        || resourceType === ResourceTypesFhirR4.MedicationRequest) {
+        codeableConceptCandidates.push(resource.medicationCodeableConcept);
+        const medicationDisplay = trimValue(asRecord(resource.medicationReference).display);
+        if (medicationDisplay)
+            return medicationDisplay;
+    }
+    if (resourceType === ResourceTypesFhirR4.Immunization) {
+        codeableConceptCandidates.push(resource.vaccineCode);
+    }
+    if (resourceType === ResourceTypesFhirR4.Device) {
+        const deviceName = asArray(resource.deviceName)
+            .map((item) => trimValue(asRecord(item).name))
+            .find(Boolean);
+        if (deviceName)
+            return deviceName;
+        codeableConceptCandidates.push(resource.type);
+    }
+    if (resourceType === ResourceTypesFhirR4.DeviceUseStatement) {
+        const deviceDisplay = trimValue(asRecord(resource.device).display);
+        if (deviceDisplay)
+            return deviceDisplay;
+    }
+    codeableConceptCandidates.push(resource.code, resource.title, resource.name, resource.description, resource.scope, resource.category);
+    for (const candidate of codeableConceptCandidates) {
+        const plainText = trimValue(candidate);
+        if (plainText && typeof candidate !== 'object') {
+            return plainText;
+        }
+        const label = resolveCodeableConceptLabel(candidate);
+        if (label) {
+            return label;
+        }
+        for (const item of asArray(candidate)) {
+            const arrayLabel = resolveCodeableConceptLabel(item);
+            if (arrayLabel)
+                return arrayLabel;
+        }
+    }
+    return undefined;
+}
+function resolveFhirIdentifier(resource) {
+    if (!resource)
+        return undefined;
+    for (const identifier of asArray(resource.identifier)) {
+        const record = asRecord(identifier);
+        const value = trimValue(record.value);
+        if (value)
+            return value;
+    }
+    return trimValue(resource.id) || undefined;
+}
+function resolveFhirDate(resourceType, resource) {
+    if (!resource)
+        return undefined;
+    const period = resolveFhirPeriod(resource);
+    const candidates = resourceType === ResourceTypesFhirR4.MedicationRequest
+        ? [resource.authoredOn, period.start]
+        : resourceType === ResourceTypesFhirR4.Immunization
+            ? [resource.occurrenceDateTime, resource.occurrenceString, resource.recorded]
+            : resourceType === ResourceTypesFhirR4.Procedure
+                ? [resource.performedDateTime, resource.performedString, period.start]
+                : [
+                    resource.effectiveDateTime,
+                    resource.effectiveInstant,
+                    resource.occurrenceDateTime,
+                    resource.onsetDateTime,
+                    resource.dateTime,
+                    resource.date,
+                    resource.issued,
+                    resource.recordedDate,
+                    resource.recordedOn,
+                    resource.authoredOn,
+                    resource.created,
+                    period.start,
+                ];
+    return firstDefinedText(candidates.map((candidate) => trimValue(candidate) || undefined));
+}
+function resolveFhirPeriod(resource) {
+    if (!resource)
+        return {};
+    const candidates = [
+        resource.effectivePeriod,
+        resource.performedPeriod,
+        resource.occurrencePeriod,
+        resource.timingPeriod,
+        resource.period,
+        resource.onsetPeriod,
+    ];
+    for (const candidate of candidates) {
+        const period = asRecord(candidate);
+        const start = trimValue(period.start);
+        const end = trimValue(period.end);
+        if (start || end) {
+            return {
+                ...(start ? { start } : {}),
+                ...(end ? { end } : {}),
+            };
+        }
+    }
+    return {};
+}
+function appendFhirActors(out, resource) {
+    if (!resource)
+        return;
+    appendFhirReference(out, resource.subject || resource.patient, 'subject');
+    appendFhirReference(out, resource.informationSource || resource.source, 'source');
+    appendFhirReference(out, resource.sender, 'sender');
+    appendFhirReference(out, resource.recipient, 'recipient');
+    appendFhirReference(out, resource.recorder || resource.asserter, 'asserter');
+    appendFhirReference(out, resource.author, 'creator');
+    appendFhirReference(out, resource.performer, 'performer');
+}
+function appendFhirReference(out, value, type) {
+    const values = Array.isArray(value) ? value : [value];
+    values.forEach((item) => {
+        const record = asRecord(item);
+        const actor = asRecord(record.actor);
+        const identifierRecord = asRecord(record.identifier);
+        const actorIdentifierRecord = asRecord(actor.identifier);
+        const identifier = firstDefinedText([
+            trimValue(record.reference) || undefined,
+            trimValue(actor.reference) || undefined,
+            trimValue(identifierRecord.value) || undefined,
+            trimValue(actorIdentifierRecord.value) || undefined,
+            trimValue(record.display) || undefined,
+            trimValue(actor.display) || undefined,
+        ]);
+        if (identifier)
+            pushActor(out, { identifier, type });
+    });
+}
+function resolveCodeableConceptLabel(value) {
+    const concept = asRecord(value);
+    const localText = trimValue(concept.text) || undefined;
+    const internationalDisplay = asArray(concept.coding)
+        .map((coding) => trimValue(asRecord(coding).display))
+        .find(Boolean);
+    return buildCombinedLabel(localText, internationalDisplay);
+}
+function resolveCodeableConceptToken(value) {
+    const coding = asArray(asRecord(value).coding)
+        .map((item) => asRecord(item))
+        .find((item) => trimValue(item.code));
+    if (!coding)
+        return undefined;
+    const system = trimValue(coding.system);
+    const code = trimValue(coding.code);
+    return system ? `${system}|${code}` : code;
+}
+function flattenCompositionSections(values) {
+    const out = [];
+    values.forEach((value) => {
+        const section = asRecord(value);
+        out.push(section);
+        out.push(...flattenCompositionSections(asArray(section.section)));
+    });
+    return out;
+}
+function indexEntriesByFhirReference(entries) {
+    const index = new Map();
+    entries.forEach((entry) => {
+        const fullUrl = trimValue(entry.fullUrl);
+        const resourceType = trimValue(entry.resource?.resourceType);
+        const id = trimValue(entry.resource?.id);
+        if (fullUrl)
+            index.set(fullUrl, entry);
+        if (resourceType && id)
+            index.set(`${resourceType}/${id}`, entry);
+        if (id)
+            index.set(`urn:uuid:${id}`, entry);
+    });
+    return index;
+}
+function resolveIndexedEntry(index, reference) {
+    const direct = index.get(reference);
+    if (direct)
+        return direct;
+    const relativeReference = reference.match(/([A-Za-z]+\/[^/]+)$/)?.[1];
+    return relativeReference ? index.get(relativeReference) : undefined;
+}
 function firstDefinedText(values) {
     for (const value of values) {
         const normalized = trimValue(value);

package/dist/utils/communication-attached-bundle-session-helpers.js

@@ -39,7 +39,9 @@ export function ensureEntryResource(entry, mode) {
     throw new Error('Active entry does not contain a valid resource object.');
 }
 export function validateBundleLike(bundle, mode) {
-    const looksLikeBundle = bundle && bundle.resourceType === ResourceTypesFhirR4.Bundle && Array.isArray(bundle.data);
+    const looksLikeBundle = bundle
+        && bundle.resourceType === ResourceTypesFhirR4.Bundle
+        && (Array.isArray(bundle.data) || Array.isArray(bundle.entry));
     if (looksLikeBundle || mode === 'normalize') {
         return;
     }
@@ -75,19 +77,19 @@ export function asTrimmedString(value) {
 }
 export function resolveContainedDocumentsClaimKey(resourceType) {
     if (resourceType === ResourceTypesFhirR4.Consent) {
-        return ClaimConsent.containedDocuments;
+        return ClaimConsent.containedReferenceList;
     }
     if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
-        return MedicationStatementClaim.ContainedDocuments;
+        return MedicationStatementClaim.ContainedReferenceList;
     }
     if (resourceType === ResourceTypesFhirR4.Condition) {
-        return ConditionClaim.ContainedDocuments;
+        return ConditionClaim.ContainedReferenceList;
     }
     if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
-        return AllergyIntoleranceClaim.ContainedDocuments;
+        return AllergyIntoleranceClaim.ContainedReferenceList;
     }
     if (resourceType === ResourceTypesFhirR4.DiagnosticReport) {
-        return DiagnosticReportClaim.ContainedDocuments;
+        return DiagnosticReportClaim.ContainedReferenceList;
     }
     return '';
 }

package/dist/utils/communication-attached-bundle-session.d.ts

@@ -2,7 +2,7 @@ import { BundleEntry, BundleJsonApi } from '../models/bundle';
 import { type ActiveEntrySelection, type AddContainedDocumentToActiveEntryInput, type CommunicationAttachedBundleSessionOptions, type UpsertClaimsResourceEntryInput, type UpsertEntryInput } from '../models/communication-attached-bundle-session';
 import { type BundleResourceIdFilters } from './bundle-query';
 import type { MedicationStatementClaimsFlat } from '../models/interoperable-claims/medication-statement-claims';
-export { BundleEntryClaimsContext, CommunicationAttachmentClaimsContext, ConsentEditorScopeCodes, ConsentEditorTargetKinds, } from '../models/communication-attached-bundle-session';
+export { BundleEntryClaimsContext, CommunicationClaimsContext, CommunicationAttachmentClaimsContext, ConsentEditorScopeCodes, ConsentEditorTargetKinds, } from '../models/communication-attached-bundle-session';
 export type { ActiveEntrySelection, AddContainedDocumentToActiveEntryInput, CommunicationAttachedBundleSessionMode, CommunicationAttachedBundleSessionOptions, ConsentEditorClassifiedActors, ConsentEditorClassifiedPurpose, ConsentEditorClassifiedRole, ConsentEditorClassifiedRoles, ConsentEditorClassifiedTarget, ConsentEditorScopeCode, ConsentEditorTargetKind, ConsentViewModel, UpsertClaimsResourceEntryInput, UpsertEntryInput, } from '../models/communication-attached-bundle-session';
 /**
  * Communication editing session with bundle-in-memory as source of truth.
@@ -24,8 +24,32 @@ export declare class CommunicationAttachedBundleSession {
     constructor(options?: CommunicationAttachedBundleSessionOptions);
     /** Returns a deep copy of communication claims. */
     getCommunicationClaims(): Record<string, unknown>;
+    /** Returns the canonical outer Communication identifier. */
+    getCommunicationIdentifier(): string;
+    /** Sets the canonical outer Communication identifier. */
+    setCommunicationIdentifier(value: unknown): this;
+    /** Returns the canonical outer Communication subject. */
+    getCommunicationSubject(): string;
+    /** Sets the canonical outer Communication subject. */
+    setCommunicationSubject(value: unknown): this;
+    /** Returns the canonical outer Communication categories. */
+    getCommunicationCategoryList(): string[];
+    /** Replaces the canonical outer Communication categories. */
+    setCommunicationCategory(value: string | readonly string[]): this;
+    /** Returns the canonical outer Communication topic. */
+    getCommunicationTopic(): string;
+    /** Sets the canonical outer Communication topic. */
+    setCommunicationTopic(value: unknown): this;
+    /** Returns the canonical outer Communication text. */
+    getCommunicationText(): string;
+    /** Sets the canonical outer Communication text. */
+    setCommunicationText(value: unknown): this;
     /** Returns a deep copy of the current in-memory bundle. */
     getBundleInMemory(): BundleJsonApi<BundleEntry>;
+    /** Replaces the attached clinical bundle and resyncs the outer Communication attachment. */
+    setAttachedBundle(bundle: BundleJsonApi<BundleEntry>): this;
+    /** Alias of `getBundleInMemory()` with communication wording. */
+    getAttachedBundle(): BundleJsonApi<BundleEntry>;
     /** Returns the active entry index, or null when no entry is selected. */
     getActiveEntryIndex(): number | null;
     /** Returns the active entry position, or null when no entry is selected. */
@@ -86,7 +110,8 @@ export declare class CommunicationAttachedBundleSession {
     upsertActiveMedicationStatementEntry(input: UpsertClaimsResourceEntryInput<MedicationStatementClaimsFlat | Record<string, unknown>>): this;
     /**
      * DocumentReference helper for bundle-contained attachments linked from
-     * other clinical resources through `*.contained-documents`.
+     * other clinical resources through `*.contained-reference-list`
+     * (with `*.contained-documents` kept as legacy compatibility alias).
      */
     upsertActiveDocumentReferenceEntry(input: UpsertClaimsResourceEntryInput<Record<string, unknown>>): this;
     /**
@@ -145,7 +170,8 @@ export declare class CommunicationAttachedBundleSession {
     upsertActiveRelatedPersonEntry(input: UpsertClaimsResourceEntryInput<Record<string, unknown>>): this;
     /**
      * Creates or updates a linked `DocumentReference` entry and stores its
-     * identifier under the active resource `*.contained-documents` claim.
+     * identifier/reference under the active resource
+     * `*.contained-reference-list` claim.
      */
     addContainedDocumentToActiveEntry(input: AddContainedDocumentToActiveEntryInput): this;
     /**

package/dist/utils/communication-attached-bundle-session.js

@@ -6,8 +6,9 @@ import { DocumentReferenceClaim } from '../models/interoperable-claims/document-
 import { BundleEntryClaimsContext, } from '../models/communication-attached-bundle-session.js';
 import { BundleQuery } from './bundle-query.js';
 import { addClaimValues } from '../claims/claim-list-helpers.js';
+import { getCommunicationCategoryList, getCommunicationIdentifier, getCommunicationSubject, getCommunicationText, getCommunicationTopic, setCommunicationCategory, setCommunicationIdentifier, setCommunicationSubject, setCommunicationText, setCommunicationTopic, } from '../claims/claims-helpers-communication.js';
 import { asTrimmedString, cloneBundle, cloneEntry, cloneUnknownValue, createEmptyBundle, encodeBundleToBase64, ensureEntryResource, resolveBundleEntryCanonicalIdValue, resolveBundleEntryIdentifier, resolveContainedDocumentsClaimKey, resolveSubjectFromClaims, runtimeUuid, setIfMissing, validateBundleLike, } from './communication-attached-bundle-session-helpers.js';
-export { BundleEntryClaimsContext, CommunicationAttachmentClaimsContext, ConsentEditorScopeCodes, ConsentEditorTargetKinds, } from '../models/communication-attached-bundle-session.js';
+export { BundleEntryClaimsContext, CommunicationClaimsContext, CommunicationAttachmentClaimsContext, ConsentEditorScopeCodes, ConsentEditorTargetKinds, } from '../models/communication-attached-bundle-session.js';
 /**
  * Communication editing session with bundle-in-memory as source of truth.
  *
@@ -41,10 +42,66 @@ export class CommunicationAttachedBundleSession {
             ...this.communicationClaims,
         };
     }
+    /** Returns the canonical outer Communication identifier. */
+    getCommunicationIdentifier() {
+        return getCommunicationIdentifier(this.communicationClaims);
+    }
+    /** Sets the canonical outer Communication identifier. */
+    setCommunicationIdentifier(value) {
+        this.communicationClaims = setCommunicationIdentifier(this.communicationClaims, value);
+        return this;
+    }
+    /** Returns the canonical outer Communication subject. */
+    getCommunicationSubject() {
+        return getCommunicationSubject(this.communicationClaims);
+    }
+    /** Sets the canonical outer Communication subject. */
+    setCommunicationSubject(value) {
+        this.communicationClaims = setCommunicationSubject(this.communicationClaims, value);
+        return this;
+    }
+    /** Returns the canonical outer Communication categories. */
+    getCommunicationCategoryList() {
+        return getCommunicationCategoryList(this.communicationClaims);
+    }
+    /** Replaces the canonical outer Communication categories. */
+    setCommunicationCategory(value) {
+        this.communicationClaims = setCommunicationCategory(this.communicationClaims, value);
+        return this;
+    }
+    /** Returns the canonical outer Communication topic. */
+    getCommunicationTopic() {
+        return getCommunicationTopic(this.communicationClaims);
+    }
+    /** Sets the canonical outer Communication topic. */
+    setCommunicationTopic(value) {
+        this.communicationClaims = setCommunicationTopic(this.communicationClaims, value);
+        return this;
+    }
+    /** Returns the canonical outer Communication text. */
+    getCommunicationText() {
+        return getCommunicationText(this.communicationClaims);
+    }
+    /** Sets the canonical outer Communication text. */
+    setCommunicationText(value) {
+        this.communicationClaims = setCommunicationText(this.communicationClaims, value);
+        return this;
+    }
     /** Returns a deep copy of the current in-memory bundle. */
     getBundleInMemory() {
         return cloneBundle(this.bundleInMemory);
     }
+    /** Replaces the attached clinical bundle and resyncs the outer Communication attachment. */
+    setAttachedBundle(bundle) {
+        validateBundleLike(bundle, this.mode);
+        this.bundleInMemory = cloneBundle(bundle);
+        this.syncAttachmentFromBundle();
+        return this;
+    }
+    /** Alias of `getBundleInMemory()` with communication wording. */
+    getAttachedBundle() {
+        return this.getBundleInMemory();
+    }
     /** Returns the active entry index, or null when no entry is selected. */
     getActiveEntryIndex() {
         return this.activeEntryIndex;
@@ -230,7 +287,8 @@ export class CommunicationAttachedBundleSession {
     }
     /**
      * DocumentReference helper for bundle-contained attachments linked from
-     * other clinical resources through `*.contained-documents`.
+     * other clinical resources through `*.contained-reference-list`
+     * (with `*.contained-documents` kept as legacy compatibility alias).
      */
     upsertActiveDocumentReferenceEntry(input) {
         return this.upsertActiveClaimsResourceEntry(ResourceTypesFhirR4.DocumentReference, input);
@@ -329,7 +387,8 @@ export class CommunicationAttachedBundleSession {
     }
     /**
      * Creates or updates a linked `DocumentReference` entry and stores its
-     * identifier under the active resource `*.contained-documents` claim.
+     * identifier/reference under the active resource
+     * `*.contained-reference-list` claim.
      */
     addContainedDocumentToActiveEntry(input) {
         if (this.activeEntryIndex === null) {

package/dist/utils/communication-consent-access-editor.d.ts

@@ -4,11 +4,15 @@ import type { CommunicationAttachedBundleSessionOptions, ConsentEditorClassified
 import type { ConsentDuplicateRuleConflict } from './consent-duplicate-rules';
 import { CommunicationAttachedBundleSession } from './communication-attached-bundle-session';
 /**
- * High-level consent-access editor alias for onboarding and app-facing code.
+ * High-level access-policy editor for onboarding and app-facing code.
  *
- * This keeps the business intent explicit for developers who are editing
- * Consent access rules inside a Communication-carried bundle and should not
- * need to start from the lower-level generic session name.
+ * This edits permit/deny rules governing who may access which data, for which
+ * purpose and scope, inside a Communication-carried bundle. It does not model
+ * informed consent for a clinical procedure, treatment or intervention.
+ *
+ * The name deliberately separates authorization consent from clinical
+ * intervention consent while retaining the FHIR-like `Consent` resource used
+ * by the existing access-rule contract.
  */
 export declare class ConsentAccessEditor extends CommunicationAttachedBundleSession {
     /** Returns duplicate atomic consent-rule conflicts across the current bundle. */

package/dist/utils/communication-consent-access-editor.js

@@ -7,11 +7,15 @@ import { detectDuplicateConsentRuleConflicts } from './consent-duplicate-rules.j
 import { CommunicationAttachedBundleSession } from './communication-attached-bundle-session.js';
 import { asTrimmedString, buildClassifiedConsentTarget, buildConsentViewModel, buildSectionCatalogOptions, classifyConsentActors, classifyConsentPurposes, classifyConsentRoles, classifyConsentTargetsFromClaims, CSV_SEPARATOR, flattenClassifiedActors, flattenClassifiedRoles, flattenClassifiedTargets, normalizeCsvValues, splitCsv, } from './communication-attached-bundle-session-helpers.js';
 /**
- * High-level consent-access editor alias for onboarding and app-facing code.
+ * High-level access-policy editor for onboarding and app-facing code.
  *
- * This keeps the business intent explicit for developers who are editing
- * Consent access rules inside a Communication-carried bundle and should not
- * need to start from the lower-level generic session name.
+ * This edits permit/deny rules governing who may access which data, for which
+ * purpose and scope, inside a Communication-carried bundle. It does not model
+ * informed consent for a clinical procedure, treatment or intervention.
+ *
+ * The name deliberately separates authorization consent from clinical
+ * intervention consent while retaining the FHIR-like `Consent` resource used
+ * by the existing access-rule contract.
  */
 export class ConsentAccessEditor extends CommunicationAttachedBundleSession {
     /** Returns duplicate atomic consent-rule conflicts across the current bundle. */

package/dist/utils/communication-didcomm-payload.d.ts

@@ -27,6 +27,11 @@ export declare function buildDidcommPayloadFromCommunicationClaims(input: BuildD
  * one DIDComm-style payload.
  */
 export declare function getFirstCommunicationClaimsFromDidcommPayload(payload: IDecodedDidcommPayload): Record<string, unknown>;
+/**
+ * Reads canonical communication claims from every `body.data[]` entry of one
+ * DIDComm-style payload.
+ */
+export declare function getCommunicationClaimsListFromDidcommPayload(payload: IDecodedDidcommPayload): Record<string, unknown>[];
 /**
  * Decodes the attached bundle carried in `Communication.content-attachment-data`.
  */