gdc-common-utils-ts 2.2.2 → 2.3.1

package/dist/utils/bundle-document-builder.d.ts

@@ -14,8 +14,43 @@ export type BundleDocumentResourceFilter = Readonly<{
     section?: string;
     resourceType?: string;
 }>;
+export type PrepareBundleDocumentForSubjectOptions = Readonly<{
+    context?: string;
+}>;
 export declare function getSimpleClaimAttributeName(key: string): string;
 export declare function extractFlatClaimValue(record: Record<string, any> | undefined, key: string): string;
+/**
+ * Validates and prepares an imported FHIR document for one authorized subject.
+ *
+ * The input is cloned. Every resource receives a deterministic flat
+ * `meta.claims` projection. Resources referenced by `Composition.section`
+ * receive the canonical section tokens in `Composition.section`, and patient
+ * subject references are rebound to the selected `did:web` subject. Existing
+ * claims are retained, except subject/patient values are forced to the
+ * selected subject so an imported local `Patient/{id}` cannot escape the
+ * controller-authorized index scope. The source object is never mutated.
+ *
+ * This is a conversion primitive only. It neither confirms that a mismatched
+ * Patient is the right person nor persists anything; confirmation belongs to
+ * the product UI and transport/authorization remain GW concerns.
+ */
+export declare function prepareBundleDocumentForSubject(bundle: Record<string, any>, subjectDid: string, options?: PrepareBundleDocumentForSubjectOptions): Record<string, any>;
+/**
+ * Returns the Patient Full Name addressed by the document Composition.
+ *
+ * Resolution prefers the Patient referenced by `Composition.subject`, then
+ * falls back to the first Patient for compatibility with incomplete imports.
+ * Name selection prefers `use=official`, then `usual`, then the first name;
+ * `HumanName.text` wins over assembling prefix/given/family/suffix.
+ */
+export declare function getBundleDocumentPatientFullName(bundle: Record<string, any>): string | undefined;
+/**
+ * Temporary Full Name comparison key: whitespace folding plus uppercase only.
+ * Diacritics and punctuation are intentionally preserved until the shared
+ * ICAO transliteration contract exists, so `JOSE` and `JOSÉ` do not compare as
+ * equal by accident.
+ */
+export declare function normalizeFullNameForComparison(value: unknown): string;
 export declare function detectClaimsResourceType(claims: BundleDocumentClaims): string | undefined;
 export declare function convertClaimsToFhirResource(claims: BundleDocumentClaims, version?: 'r4'): FhirResource;
 /**

package/dist/utils/bundle-document-builder.js

@@ -99,6 +99,182 @@ function normalizeSectionCode(value) {
         return { code: system };
     return { system, code };
 }
+function toCanonicalSectionToken(system, code) {
+    const normalizedSystem = asTrimmedString(system);
+    const normalizedCode = asTrimmedString(code);
+    if (!normalizedCode)
+        return '';
+    if (!normalizedSystem)
+        return normalizedCode;
+    return `${normalizedSystem === 'http://loinc.org' ? 'LOINC' : normalizedSystem}|${normalizedCode}`;
+}
+function resourceReferenceAliases(entry) {
+    const resource = entry?.resource;
+    const resourceType = asTrimmedString(resource?.resourceType);
+    const resourceId = asTrimmedString(resource?.id);
+    const fullUrl = asTrimmedString(entry?.fullUrl);
+    return Array.from(new Set([
+        fullUrl,
+        resourceType && resourceId ? `${resourceType}/${resourceId}` : '',
+        resourceId,
+        fullUrl ? fullUrl.split('/').slice(-2).join('/') : '',
+    ].filter(Boolean)));
+}
+function sectionMembershipByReference(composition) {
+    const memberships = new Map();
+    const visit = (sections) => {
+        if (!Array.isArray(sections))
+            return;
+        for (const section of sections) {
+            const coding = Array.isArray(section?.code?.coding) ? section.code.coding[0] : undefined;
+            const token = toCanonicalSectionToken(coding?.system, coding?.code);
+            if (token && Array.isArray(section?.entry)) {
+                for (const item of section.entry) {
+                    const reference = asTrimmedString(item?.reference);
+                    if (!reference)
+                        continue;
+                    const aliases = [reference, reference.split('/').slice(-2).join('/'), reference.split('/').pop() || ''];
+                    for (const alias of aliases.filter(Boolean)) {
+                        memberships.set(alias, Array.from(new Set([...(memberships.get(alias) || []), token])));
+                    }
+                }
+            }
+            visit(section?.section);
+        }
+    };
+    visit(composition?.section);
+    return memberships;
+}
+function allCompositionSectionTokens(composition) {
+    const tokens = [];
+    const visit = (sections) => {
+        if (!Array.isArray(sections))
+            return;
+        for (const section of sections) {
+            const coding = Array.isArray(section?.code?.coding) ? section.code.coding[0] : undefined;
+            const token = toCanonicalSectionToken(coding?.system, coding?.code);
+            if (token)
+                tokens.push(token);
+            visit(section?.section);
+        }
+    };
+    visit(composition?.section);
+    return Array.from(new Set(tokens));
+}
+function replacePatientSubjectReference(resource, subjectDid) {
+    const resourceType = asTrimmedString(resource?.resourceType);
+    if (resourceType === ResourceTypesFhirR4.Composition || resource?.subject?.reference) {
+        resource.subject = { ...(resource.subject || {}), reference: subjectDid };
+    }
+    if (resource?.patient?.reference) {
+        resource.patient = { ...(resource.patient || {}), reference: subjectDid };
+    }
+}
+/**
+ * Validates and prepares an imported FHIR document for one authorized subject.
+ *
+ * The input is cloned. Every resource receives a deterministic flat
+ * `meta.claims` projection. Resources referenced by `Composition.section`
+ * receive the canonical section tokens in `Composition.section`, and patient
+ * subject references are rebound to the selected `did:web` subject. Existing
+ * claims are retained, except subject/patient values are forced to the
+ * selected subject so an imported local `Patient/{id}` cannot escape the
+ * controller-authorized index scope. The source object is never mutated.
+ *
+ * This is a conversion primitive only. It neither confirms that a mismatched
+ * Patient is the right person nor persists anything; confirmation belongs to
+ * the product UI and transport/authorization remain GW concerns.
+ */
+export function prepareBundleDocumentForSubject(bundle, subjectDid, options = {}) {
+    const validation = validateBundleDocumentBasic(bundle);
+    if (!validation.ok)
+        throw new Error(validation.issues.join(' '));
+    const normalizedSubjectDid = asTrimmedString(subjectDid);
+    if (!normalizedSubjectDid)
+        throw new Error('A subject DID is required.');
+    const prepared = JSON.parse(JSON.stringify(bundle));
+    const entries = prepared.entry;
+    const composition = entries[0]?.resource;
+    const membership = sectionMembershipByReference(composition);
+    const allSections = allCompositionSectionTokens(composition);
+    for (const entry of entries) {
+        const resource = entry?.resource;
+        if (!resource || typeof resource !== 'object')
+            continue;
+        replacePatientSubjectReference(resource, normalizedSubjectDid);
+        const generated = convertFhirResourceToClaims(resource, options.context || 'org.hl7.fhir.r4');
+        const existing = resource?.meta?.claims;
+        const claims = {
+            ...generated,
+            ...(existing && typeof existing === 'object' && !Array.isArray(existing) ? existing : {}),
+        };
+        const resourceType = asTrimmedString(resource.resourceType);
+        if (resourceType !== 'Patient') {
+            if (resource?.subject?.reference)
+                claims[`${resourceType}.subject`] = normalizedSubjectDid;
+            if (resource?.patient?.reference)
+                claims[`${resourceType}.patient`] = normalizedSubjectDid;
+        }
+        const resourceSections = resourceType === ResourceTypesFhirR4.Composition
+            ? allSections
+            : resourceReferenceAliases(entry).flatMap((alias) => membership.get(alias) || []);
+        if (resourceSections.length > 0) {
+            claims[CompositionClaim.Section] = Array.from(new Set(resourceSections)).join(',');
+        }
+        resource.meta = {
+            ...(resource.meta && typeof resource.meta === 'object' ? resource.meta : {}),
+            claims,
+        };
+    }
+    return prepared;
+}
+/**
+ * Returns the Patient Full Name addressed by the document Composition.
+ *
+ * Resolution prefers the Patient referenced by `Composition.subject`, then
+ * falls back to the first Patient for compatibility with incomplete imports.
+ * Name selection prefers `use=official`, then `usual`, then the first name;
+ * `HumanName.text` wins over assembling prefix/given/family/suffix.
+ */
+export function getBundleDocumentPatientFullName(bundle) {
+    const entries = Array.isArray(bundle?.entry) ? bundle.entry : [];
+    const composition = entries[0]?.resource;
+    const subjectReference = asTrimmedString(composition?.subject?.reference);
+    const patientEntry = entries.find((entry) => {
+        if (entry?.resource?.resourceType !== 'Patient')
+            return false;
+        if (!subjectReference)
+            return true;
+        return resourceReferenceAliases(entry).some((alias) => alias === subjectReference
+            || alias === subjectReference.split('/').slice(-2).join('/')
+            || alias === subjectReference.split('/').pop());
+    }) || entries.find((entry) => entry?.resource?.resourceType === 'Patient');
+    const names = Array.isArray(patientEntry?.resource?.name) ? patientEntry.resource.name : [];
+    const name = names.find((item) => item?.use === 'official')
+        || names.find((item) => item?.use === 'usual')
+        || names[0];
+    if (!name)
+        return undefined;
+    const text = asTrimmedString(name.text);
+    if (text)
+        return text;
+    const parts = [
+        ...(Array.isArray(name.prefix) ? name.prefix : []),
+        ...(Array.isArray(name.given) ? name.given : []),
+        name.family,
+        ...(Array.isArray(name.suffix) ? name.suffix : []),
+    ].map(asTrimmedString).filter(Boolean);
+    return parts.length > 0 ? parts.join(' ') : undefined;
+}
+/**
+ * Temporary Full Name comparison key: whitespace folding plus uppercase only.
+ * Diacritics and punctuation are intentionally preserved until the shared
+ * ICAO transliteration contract exists, so `JOSE` and `JOSÉ` do not compare as
+ * equal by accident.
+ */
+export function normalizeFullNameForComparison(value) {
+    return asTrimmedString(value).replace(/\s+/g, ' ').toUpperCase();
+}
 function resolveContainedReferenceListClaimKey(resourceType) {
     switch (resourceType) {
         case ResourceTypesFhirR4.MedicationStatement:

package/dist/utils/clinical-resource-view.d.ts

@@ -29,6 +29,14 @@ export type ClinicalResourceExpandedView = Readonly<{
     xhtml?: string;
     notes: string[];
 }>;
+/** UI-ready summary for one Composition section and its resolved entries. */
+export type ClinicalSectionView = Readonly<{
+    code?: string;
+    title: string;
+    emptyReason?: string;
+    resources: ClinicalResourceCardView[];
+    unresolvedReferences: string[];
+}>;
 export type ClinicalResourceLike = Readonly<{
     resourceType?: string;
     text?: {
@@ -87,6 +95,14 @@ export declare function toClinicalResourceExpandedView(entry: ClinicalResourceEn
  * Maps all entries from a Bundle into expanded views.
  */
 export declare function toClinicalResourceExpandedViews(bundle: ClinicalResourceBundleLike): ClinicalResourceExpandedView[];
+/**
+ * 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 declare function toClinicalSectionViews(bundle: ClinicalResourceBundleLike): ClinicalSectionView[];
 /**
  * Returns the most useful local text plus international display pair that can
  * be inferred from one FHIR-like resource and its `meta.claims`.

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);