gdc-common-utils-ts 2.1.0 → 2.2.2

package/dist/utils/clinical-resource-entry-editor.d.ts

@@ -0,0 +1,123 @@
+import { AllowedResourceType, type ResourceTypeEntryEditor } from '../models/bundle-editor-types';
+import { BundleEntryEditor } from './bundle-entry-editor';
+export declare class ClinicalResourceEntryEditor extends BundleEntryEditor {
+    /**
+     * Returns the best current identifier for the resource:
+     * - public `<ResourceType>.identifier` claim first
+     * - otherwise internal `resource.id`
+     * - otherwise `fullUrl`
+     *
+     * This fallback order matters because the editor may stage one new entry
+     * before the public identifier claim has been synchronized.
+     */
+    protected getIdentifierValue(claimKey: string): string | undefined;
+    protected setIdentifierValue(claimKey: string, identifier?: string | null): this;
+    /** Writes the same subject value into both subject-style claim slots used by this resource family. */
+    protected setSubjectClaims(subjectClaimKey: string, patientClaimKey: string, subject?: string | null): this;
+    /** Reads the normalized subject value from the supported subject/patient claim aliases. */
+    protected getSubjectClaims(subjectClaimKey: string, patientClaimKey: string): string | undefined;
+    /** Writes one trimmed string claim and removes the key when the value is blank. */
+    protected setScalarClaim(claimKey: string, value?: string | null): this;
+    /** Reads one string claim using the shared blank-to-undefined normalization rule. */
+    protected getScalarClaim(claimKey: string): string | undefined;
+    /** Stores one numeric claim through the flat-claims string representation used by the bundle editors. */
+    protected setNumberClaim(claimKey: string, value?: number | null): this;
+    /** Reads one numeric flat claim and converts it back to a finite number when possible. */
+    protected getNumberClaim(claimKey: string): number | undefined;
+    /** Stores one boolean claim and removes it when the caller wants to clear the field. */
+    protected setBooleanClaim(claimKey: string, value?: boolean | null): this;
+    /** Reads one boolean claim while tolerating both real booleans and serialized `'true'` / `'false'` values. */
+    protected getBooleanClaim(claimKey: string): boolean | undefined;
+    /** Stores one multi-value flat claim using the shared CSV serialization helper. */
+    protected setCsvClaimList(claimKey: string, values: readonly string[]): this;
+    /** Reads one CSV-backed flat claim as a normalized string list. */
+    protected getCsvClaimList(claimKey: string): string[];
+    /**
+     * Ensures one canonical identifier across:
+     * - public identifier claim
+     * - `resource.id`
+     * - `fullUrl`
+     *
+     * This is the preferred onboarding path after `newEntryAs(...)` /
+     * `newContainedResourceAs(...)` when the entry was created without an
+     * explicit id.
+     */
+    protected ensureIdentifierValue(claimKey: string): string;
+    /** Resolves which claim stores the CSV list of linked/contained resource references for this resource type. */
+    protected getContainedReferenceListClaimKey(): string;
+    /** Builds one resource-scoped claim key such as `MedicationStatement.language`. */
+    protected getResourceScopedClaimKey(suffix: string): string;
+    /** Returns the canonical `ResourceType/<identifier>` reference for the current staged entry. */
+    protected getEntryReference(): string;
+    /** Replaces the linked child-resource reference list on the current parent resource. */
+    setContainedResourceReferenceList(references: readonly string[]): this;
+    /** Returns the normalized linked child-resource reference list for the current parent resource. */
+    getContainedResourceReferenceList(): string[];
+    /** Adds one child-resource reference to the parent list, deduplicating exact matches. */
+    addContainedResourceReference(reference: string): this;
+    /** Removes one child-resource reference from the parent list without touching any staged child entry. */
+    removeContainedResourceReference(reference: string): this;
+    /**
+     * Creates one linked child entry, then seeds it from an already prepared claims object.
+     *
+     * Keep this as a plumbing/import helper. The 101 path should prefer
+     * `newContainedResourceAs(...)` so the front edits the child through the
+     * typed editor surface instead of raw claim objects.
+     */
+    addContainedResourceByClaims(resourceType: AllowedResourceType, claims: Record<string, unknown>, resourceIdOrReference?: string, options?: Readonly<{
+        contained?: boolean;
+    }>): BundleEntryEditor;
+    /**
+     * Opens one linked child/sibling resource through the same `BundleEditor`.
+     *
+     * Default path:
+     * - create one visible sibling resource
+     * - link it from the parent CSV reference list
+     *
+     * Advanced path:
+     * - pass `{ contained: true }` only when the FHIR export must rebuild the
+     *   resource under `parent.contained[]`.
+     */
+    /**
+     * Creates one linked child entry through the same bundle editor.
+     *
+     * Default behavior:
+     * - create one visible sibling entry
+     * - add its canonical `ResourceType/<id>` reference to the parent list
+     *
+     * Advanced behavior:
+     * - `{ contained: true }` also marks the child so FHIR export can rebuild it
+     *   under `parent.contained[]` instead of showing it as a normal top-level
+     *   clinical resource entry.
+     */
+    newContainedResource(resourceType: AllowedResourceType, resourceIdOrReference?: string, options?: Readonly<{
+        contained?: boolean;
+    }>): BundleEntryEditor;
+    /** Creates one linked child entry and immediately returns the typed editor for that child resource type. */
+    newContainedResourceAs<T extends AllowedResourceType>(resourceType: T, resourceIdOrReference?: string, options?: Readonly<{
+        contained?: boolean;
+    }>): ResourceTypeEntryEditor<T>;
+    /** @deprecated Use `newContainedResource(...)`. */
+    addContainedResourceEntry(resourceType: AllowedResourceType, resourceIdOrReference?: string, options?: Readonly<{
+        contained?: boolean;
+    }>): BundleEntryEditor;
+    /**
+     * Removes one linked child reference and, when the child was marked as
+     * contained under this exact parent, also removes the staged child entry.
+     */
+    removeContainedResourceByReference(reference: string): this;
+    /** Stores the generic `<ResourceType>.language` flat claim used by multilingual resource payloads. */
+    setLanguage(value?: string | null): this;
+    /** Returns the generic `<ResourceType>.language` flat claim when present. */
+    getLanguage(): string | undefined;
+    /** Stores the generic `<ResourceType>.user-selected` flag used by self-managed user flows. */
+    setUserSelected(value?: boolean | null): this;
+    /** Returns the generic `<ResourceType>.user-selected` flag when present. */
+    getUserSelected(): boolean | undefined;
+}
+/**
+ * Reduced Observation component-style editor surface.
+ *
+ * This base layer owns the reusable code/value authoring helpers shared by
+ * Vital Signs and broader Observation entry editors.
+ */

package/dist/utils/clinical-resource-entry-editor.js

@@ -0,0 +1,296 @@
+import { cloneClaimValue, createCanonicalIdentifierUrn, normalizeContainedReference, normalizeOptionalIdentifier, resolveContainedFlagClaimKey, resolveContainedParentReferenceClaimKey, resolveContainedReferenceListClaimKey, } from './bundle-editor-helpers.js';
+import { BundleEntryEditor } from './bundle-entry-editor.js';
+import { getClaimValues, setClaimValues } from '../claims/claim-list-helpers.js';
+export class ClinicalResourceEntryEditor extends BundleEntryEditor {
+    /**
+     * Returns the best current identifier for the resource:
+     * - public `<ResourceType>.identifier` claim first
+     * - otherwise internal `resource.id`
+     * - otherwise `fullUrl`
+     *
+     * This fallback order matters because the editor may stage one new entry
+     * before the public identifier claim has been synchronized.
+     */
+    getIdentifierValue(claimKey) {
+        return normalizeOptionalIdentifier(this.getClaim(claimKey)
+            || this.getResourceId()
+            || this.getFullUrl());
+    }
+    setIdentifierValue(claimKey, identifier) {
+        const normalized = normalizeOptionalIdentifier(identifier);
+        if (!normalized) {
+            this.removeClaim(claimKey);
+            this.setResourceId(undefined);
+            this.setFullUrl(undefined);
+            return this;
+        }
+        this.setClaim(claimKey, normalized);
+        this.setResourceId(normalized);
+        this.setFullUrl(normalized);
+        return this;
+    }
+    /** Writes the same subject value into both subject-style claim slots used by this resource family. */
+    setSubjectClaims(subjectClaimKey, patientClaimKey, subject) {
+        const normalized = normalizeOptionalIdentifier(subject);
+        if (!normalized) {
+            this.removeClaim(subjectClaimKey);
+            this.removeClaim(patientClaimKey);
+            return this;
+        }
+        this.setClaim(subjectClaimKey, normalized);
+        this.setClaim(patientClaimKey, normalized);
+        return this;
+    }
+    /** Reads the normalized subject value from the supported subject/patient claim aliases. */
+    getSubjectClaims(subjectClaimKey, patientClaimKey) {
+        return normalizeOptionalIdentifier(this.getClaim(subjectClaimKey)
+            || this.getClaim(patientClaimKey));
+    }
+    /** Writes one trimmed string claim and removes the key when the value is blank. */
+    setScalarClaim(claimKey, value) {
+        const normalized = normalizeOptionalIdentifier(value);
+        if (!normalized) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, normalized);
+    }
+    /** Reads one string claim using the shared blank-to-undefined normalization rule. */
+    getScalarClaim(claimKey) {
+        return normalizeOptionalIdentifier(this.getClaim(claimKey));
+    }
+    /** Stores one numeric claim through the flat-claims string representation used by the bundle editors. */
+    setNumberClaim(claimKey, value) {
+        if (value === undefined || value === null || Number.isNaN(value)) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, String(value));
+    }
+    /** Reads one numeric flat claim and converts it back to a finite number when possible. */
+    getNumberClaim(claimKey) {
+        const raw = this.getClaim(claimKey);
+        if (raw === undefined || raw === null || raw === '')
+            return undefined;
+        const numeric = Number(raw);
+        return Number.isFinite(numeric) ? numeric : undefined;
+    }
+    /** Stores one boolean claim and removes it when the caller wants to clear the field. */
+    setBooleanClaim(claimKey, value) {
+        if (value === undefined || value === null) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, value);
+    }
+    /** Reads one boolean claim while tolerating both real booleans and serialized `'true'` / `'false'` values. */
+    getBooleanClaim(claimKey) {
+        const raw = this.getClaim(claimKey);
+        if (typeof raw === 'boolean')
+            return raw;
+        if (raw === 'true')
+            return true;
+        if (raw === 'false')
+            return false;
+        return undefined;
+    }
+    /** Stores one multi-value flat claim using the shared CSV serialization helper. */
+    setCsvClaimList(claimKey, values) {
+        const next = setClaimValues({}, claimKey, values);
+        const normalized = normalizeOptionalIdentifier(next[claimKey]);
+        if (!normalized) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, normalized);
+    }
+    /** Reads one CSV-backed flat claim as a normalized string list. */
+    getCsvClaimList(claimKey) {
+        return getClaimValues(this.getClaims(), claimKey);
+    }
+    /**
+     * Ensures one canonical identifier across:
+     * - public identifier claim
+     * - `resource.id`
+     * - `fullUrl`
+     *
+     * This is the preferred onboarding path after `newEntryAs(...)` /
+     * `newContainedResourceAs(...)` when the entry was created without an
+     * explicit id.
+     */
+    ensureIdentifierValue(claimKey) {
+        const existingClaim = normalizeOptionalIdentifier(this.getClaim(claimKey));
+        if (existingClaim)
+            return existingClaim;
+        const existingResourceIdentifier = normalizeOptionalIdentifier(this.getResourceId() || this.getFullUrl());
+        if (existingResourceIdentifier) {
+            this.setIdentifierValue(claimKey, existingResourceIdentifier);
+            return existingResourceIdentifier;
+        }
+        const generated = createCanonicalIdentifierUrn();
+        this.setIdentifierValue(claimKey, generated);
+        return generated;
+    }
+    /** Resolves which claim stores the CSV list of linked/contained resource references for this resource type. */
+    getContainedReferenceListClaimKey() {
+        const resourceType = String(this.getMutableEntry().resource?.resourceType || '').trim();
+        const claimKey = resolveContainedReferenceListClaimKey(resourceType);
+        if (!claimKey) {
+            throw new Error(`Contained-reference linking is not supported for resource type: ${resourceType || '(unknown)'}`);
+        }
+        return claimKey;
+    }
+    /** Builds one resource-scoped claim key such as `MedicationStatement.language`. */
+    getResourceScopedClaimKey(suffix) {
+        const resourceType = String(this.getMutableEntry().resource?.resourceType || '').trim();
+        if (!resourceType) {
+            throw new Error('Resource-scoped claim access requires one concrete resource type.');
+        }
+        return `${resourceType}.${String(suffix || '').trim()}`;
+    }
+    /** Returns the canonical `ResourceType/<identifier>` reference for the current staged entry. */
+    getEntryReference() {
+        const resourceType = String(this.getMutableEntry().resource?.resourceType || '').trim();
+        const identifier = normalizeOptionalIdentifier(this.getResourceId() || this.getFullUrl());
+        if (!resourceType || !identifier) {
+            throw new Error('Contained-resource linking requires the parent entry to have a concrete resource type and identifier.');
+        }
+        return `${resourceType}/${identifier}`;
+    }
+    /** Replaces the linked child-resource reference list on the current parent resource. */
+    setContainedResourceReferenceList(references) {
+        return this.setCsvClaimList(this.getContainedReferenceListClaimKey(), references);
+    }
+    /** Returns the normalized linked child-resource reference list for the current parent resource. */
+    getContainedResourceReferenceList() {
+        return this.getCsvClaimList(this.getContainedReferenceListClaimKey());
+    }
+    /** Adds one child-resource reference to the parent list, deduplicating exact matches. */
+    addContainedResourceReference(reference) {
+        const next = [...this.getContainedResourceReferenceList(), String(reference || '').trim()]
+            .filter(Boolean);
+        return this.setContainedResourceReferenceList([...new Set(next)]);
+    }
+    /** Removes one child-resource reference from the parent list without touching any staged child entry. */
+    removeContainedResourceReference(reference) {
+        const normalized = String(reference || '').trim();
+        if (!normalized) {
+            return this;
+        }
+        return this.setContainedResourceReferenceList(this.getContainedResourceReferenceList().filter((item) => item !== normalized));
+    }
+    /**
+     * Creates one linked child entry, then seeds it from an already prepared claims object.
+     *
+     * Keep this as a plumbing/import helper. The 101 path should prefer
+     * `newContainedResourceAs(...)` so the front edits the child through the
+     * typed editor surface instead of raw claim objects.
+     */
+    addContainedResourceByClaims(resourceType, claims, resourceIdOrReference, options) {
+        const seededIdentifier = normalizeOptionalIdentifier(resourceIdOrReference)
+            || normalizeOptionalIdentifier(claims[`${resourceType}.identifier`])
+            || createCanonicalIdentifierUrn();
+        const containedEntry = this.addContainedResourceEntry(resourceType, seededIdentifier, options);
+        Object.entries(claims || {}).forEach(([key, value]) => {
+            containedEntry.setClaim(key, cloneClaimValue(value));
+        });
+        return containedEntry;
+    }
+    /**
+     * Opens one linked child/sibling resource through the same `BundleEditor`.
+     *
+     * Default path:
+     * - create one visible sibling resource
+     * - link it from the parent CSV reference list
+     *
+     * Advanced path:
+     * - pass `{ contained: true }` only when the FHIR export must rebuild the
+     *   resource under `parent.contained[]`.
+     */
+    /**
+     * Creates one linked child entry through the same bundle editor.
+     *
+     * Default behavior:
+     * - create one visible sibling entry
+     * - add its canonical `ResourceType/<id>` reference to the parent list
+     *
+     * Advanced behavior:
+     * - `{ contained: true }` also marks the child so FHIR export can rebuild it
+     *   under `parent.contained[]` instead of showing it as a normal top-level
+     *   clinical resource entry.
+     */
+    newContainedResource(resourceType, resourceIdOrReference, options) {
+        const parentReference = this.getEntryReference();
+        const seededIdentifier = normalizeOptionalIdentifier(resourceIdOrReference) || createCanonicalIdentifierUrn();
+        const normalizedContained = normalizeContainedReference(resourceType, seededIdentifier);
+        const containedEntry = this.bundleEditor.newEntryAs(resourceType, normalizedContained.identifier);
+        containedEntry
+            .setResourceId(normalizedContained.identifier)
+            .setFullUrl(normalizedContained.identifier)
+            .setClaim(`${resourceType}.identifier`, normalizedContained.identifier);
+        if (options?.contained) {
+            containedEntry
+                .setClaim(resolveContainedFlagClaimKey(resourceType), true)
+                .setClaim(resolveContainedParentReferenceClaimKey(resourceType), parentReference);
+        }
+        this.addContainedResourceReference(normalizedContained.reference);
+        return containedEntry;
+    }
+    /** Creates one linked child entry and immediately returns the typed editor for that child resource type. */
+    newContainedResourceAs(resourceType, resourceIdOrReference, options) {
+        return this.newContainedResource(resourceType, resourceIdOrReference, options).asResourceType(resourceType);
+    }
+    /** @deprecated Use `newContainedResource(...)`. */
+    addContainedResourceEntry(resourceType, resourceIdOrReference, options) {
+        return this.newContainedResource(resourceType, resourceIdOrReference, options);
+    }
+    /**
+     * Removes one linked child reference and, when the child was marked as
+     * contained under this exact parent, also removes the staged child entry.
+     */
+    removeContainedResourceByReference(reference) {
+        const parentReference = this.getEntryReference();
+        const normalizedContained = normalizeContainedReference(String(reference || '').includes('/') ? String(reference || '').split('/')[0] : '', String(reference || ''));
+        const normalizedReference = normalizedContained.reference || String(reference || '').trim();
+        const normalizedIdentifier = normalizedContained.identifier || normalizedReference.split('/').pop() || '';
+        this.removeContainedResourceReference(normalizedReference);
+        const childEntryIndex = this.bundleEditor.findEntryIndexByIdentifierOrFullUrl(normalizedIdentifier);
+        if (childEntryIndex < 0) {
+            return this;
+        }
+        const childEntry = this.bundleEditor.getMutableEntry(childEntryIndex);
+        const childClaims = childEntry.resource?.meta?.claims || {};
+        const childResourceType = String(childEntry.resource?.resourceType || '').trim();
+        const childContainedFlagClaimKey = resolveContainedFlagClaimKey(childResourceType);
+        const childContainedParentReferenceClaimKey = resolveContainedParentReferenceClaimKey(childResourceType);
+        const isContainedChild = childClaims[childContainedFlagClaimKey] === true
+            || childClaims[childContainedFlagClaimKey] === 'true';
+        const childParentReference = normalizeOptionalIdentifier(childClaims[childContainedParentReferenceClaimKey]);
+        if (isContainedChild && childParentReference === parentReference) {
+            this.bundleEditor.removeMutableEntry(childEntryIndex);
+        }
+        return this;
+    }
+    /** Stores the generic `<ResourceType>.language` flat claim used by multilingual resource payloads. */
+    setLanguage(value) {
+        return this.setScalarClaim(this.getResourceScopedClaimKey('language'), value);
+    }
+    /** Returns the generic `<ResourceType>.language` flat claim when present. */
+    getLanguage() {
+        return this.getScalarClaim(this.getResourceScopedClaimKey('language'));
+    }
+    /** Stores the generic `<ResourceType>.user-selected` flag used by self-managed user flows. */
+    setUserSelected(value) {
+        return this.setBooleanClaim(this.getResourceScopedClaimKey('user-selected'), value);
+    }
+    /** Returns the generic `<ResourceType>.user-selected` flag when present. */
+    getUserSelected() {
+        return this.getBooleanClaim(this.getResourceScopedClaimKey('user-selected'));
+    }
+}
+/**
+ * Reduced Observation component-style editor surface.
+ *
+ * This base layer owns the reusable code/value authoring helpers shared by
+ * Vital Signs and broader Observation entry editors.
+ */

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-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`.
  */