gdc-common-utils-ts 1.20.2 → 1.23.0

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

@@ -1,5 +1,5 @@
 import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
-import { allergyIntoleranceFlatToFhirR4, appointmentFlatToFhirR4, carePlanFlatToFhirR4, clinicalImpressionFlatToFhirR4, compositionFlatToFhirR4, conditionFlatToFhirR4, convertFhirResourceToClaims, coverageFlatToFhirR4, deviceFlatToFhirR4, documentReferenceFlatToFhirR4, diagnosticReportFlatToFhirR4, encounterFlatToFhirR4, flagFlatToFhirR4, flatClaimsToFhirResource, immunizationFlatToFhirR4, locationFlatToFhirR4, medicationStatementFlatToFhirR4, observationFlatToFhirR4, organizationFlatToFhirR4, procedureFlatToFhirR4, relatedPersonFlatToFhirR4, } from './clinical-resource-converters.js';
+import { allergyIntoleranceFlatToFhirR4, appointmentFlatToFhirR4, carePlanFlatToFhirR4, clinicalImpressionFlatToFhirR4, compositionFlatToFhirR4, conditionFlatToFhirR4, convertFhirResourceToClaims, coverageFlatToFhirR4, deviceFlatToFhirR4, documentReferenceFlatToFhirR4, diagnosticReportFlatToFhirR4, encounterFlatToFhirR4, flagFlatToFhirR4, flatClaimsToFhirResource, immunizationFlatToFhirR4, locationFlatToFhirR4, medicationStatementFlatToFhirR4, observationFromFlatToFhirR4, organizationFlatToFhirR4, procedureFlatToFhirR4, relatedPersonFlatToFhirR4, } from './clinical-resource-converters.js';
 function asTrimmedString(value) {
     if (value === undefined || value === null)
         return '';
@@ -59,6 +59,24 @@ function claimsToFlatStrings(claims) {
     }
     return out;
 }
+function ensureClaimsIdentifier(claims, resource) {
+    const resourceType = asTrimmedString(resource?.resourceType);
+    const identifierKey = resourceType ? `${resourceType}.identifier` : '';
+    if (!identifierKey) {
+        return claims;
+    }
+    if (asTrimmedString(claims[identifierKey])) {
+        return claims;
+    }
+    const resourceId = asTrimmedString(resource?.id);
+    if (!resourceId) {
+        return claims;
+    }
+    return {
+        ...claims,
+        [identifierKey]: resourceId,
+    };
+}
 function ensureResourceIdentifier(resource, claims, fallbackIndex) {
     const identifier = Object.entries(claims).find(([key]) => String(key).toLowerCase().endsWith('.identifier'))?.[1];
     const nextId = asTrimmedString(identifier) || `${resource.resourceType.toLowerCase()}-${fallbackIndex + 1}`;
@@ -111,7 +129,7 @@ export function convertClaimsToFhirResource(claims, version = 'r4') {
         case 'Location':
             return locationFlatToFhirR4(flatClaims);
         case 'Observation':
-            return observationFlatToFhirR4(flatClaims);
+            return observationFromFlatToFhirR4(flatClaims);
         case 'Organization':
             return organizationFlatToFhirR4(flatClaims);
         case 'Procedure':
@@ -166,9 +184,9 @@ export function extractBundleDocumentClaimsList(bundle, context = 'org.hl7.fhir.
         .map((resource) => {
         const metaClaims = resource?.meta?.claims;
         if (metaClaims && typeof metaClaims === 'object' && !Array.isArray(metaClaims)) {
-            return { ...metaClaims };
+            return ensureClaimsIdentifier({ ...metaClaims }, resource);
         }
-        return convertFhirResourceToClaims(resource, context);
+        return ensureClaimsIdentifier(convertFhirResourceToClaims(resource, context), resource);
     });
 }
 export function resolveClaimsSectionList(claims) {

package/dist/utils/bundle-editor.d.ts

@@ -1,9 +1,12 @@
+import { type CodingDescriptor } from '../constants/vital-signs';
 import { type BundleEntry, type BundleJsonApi, type BundleRequest } from '../models/bundle';
 import { buildEmployeePurgeBundle, buildEmployeeSearchBundle, EmployeeBundleOperations, EmployeeClaims } from './employee';
 export type BundleOperation = (typeof EmployeeBundleOperations)[keyof typeof EmployeeBundleOperations];
 export declare const BundleEditableResourceTypes: Readonly<{
     readonly employee: "Employee";
     readonly consent: "Consent";
+    readonly observation: "Observation";
+    readonly vitalSign: "Observation";
 }>;
 export type AllowedResourceType = string;
 export type BuiltBundleEntry = {
@@ -38,9 +41,32 @@ export declare class BundleEditor {
     private bundleOperation;
     private allowedResourceType;
     private readonly entries;
-    /** Declares which business operation this bundle is staging. */
+    /**
+     * Declares which business action this in-memory bundle is staging.
+     *
+     * Important distinction:
+     * - this is **not** the same concept as FHIR `Bundle.entry.request.method`
+     * - this is the higher-level action the editor is helping to assemble, for
+     *   example `create`, `search`, `disable`, or `purge`
+     * - the lower-level transport/request method may later be derived from that
+     *   action, and may differ by backend contract
+     *
+     * Example:
+     * - bundle operation `disable`
+     * - current employee GW contract -> inner `entry.request.method = DELETE`
+     * - current individual organization GW contract -> explicit `/_disable`
+     *   route with inner `entry.request.method = POST`
+     */
     setBundleOperation(operation: BundleOperation): this;
-    /** Returns the current business operation assigned to the bundle. */
+    /**
+     * Returns the current high-level business action assigned to the bundle.
+     *
+     * Read this as:
+     * - "what am I trying to do?"
+     *
+     * not as:
+     * - "which HTTP/FHIR request method will the final entry use?"
+     */
     getBundleOperation(): BundleOperation | null;
     /**
      * Restricts the bundle to one resource type.
@@ -104,6 +130,10 @@ export declare class BundleEntryEditor {
     constructor(bundleEditor: BundleEditor, entryIndex: number);
     /** Opens the current entry as one employee-specific resource editor. */
     asEmployee(): EmployeeEntryEditor;
+    /** Opens the current entry as one vital-sign-specific Observation editor. */
+    asVitalSign(): VitalSignEntryEditor;
+    /** Opens the current entry as one general Observation editor. */
+    asObservation(): ObservationEntryEditor;
     /** Reads one claim from this entry. */
     getClaim(key: string): unknown;
     /** Checks whether this entry contains one claim key. */
@@ -127,6 +157,79 @@ export declare class BundleEntryEditor {
     protected getMutableEntry(): BuiltBundleEntry;
     protected getClaims(): EmployeeClaims;
 }
+/**
+ * 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.
+ */
+export declare class ObservationComponentEntryEditor extends BundleEntryEditor {
+    setCode(code: CodingDescriptor | string): this;
+    getCode(): string | undefined;
+    setCodeSystem(system: string): this;
+    getCodeSystem(): string | undefined;
+    setCodeValue(value: string): this;
+    getCodeValue(): string | undefined;
+    setCodeDisplay(display: string): this;
+    getCodeDisplay(): string | undefined;
+    /** Local-language label intended for forms and local UI. */
+    setLocalText(text: string): this;
+    getLocalText(): string | undefined;
+    setValueQuantityNumber(value: number): this;
+    getValueQuantityNumber(): number | undefined;
+    setValueQuantityUnit(unit: CodingDescriptor | string): this;
+    getValueQuantityUnit(): string | undefined;
+    setValueString(value: string): this;
+    getValueString(): string | undefined;
+    setValueDate(value: string): this;
+    getValueDate(): string | undefined;
+}
+/**
+ * Vital-sign-specific editor surface for one staged Observation entry.
+ *
+ * This layer applies the visible/searchable Vital Signs claim contract on top
+ * of the reduced Observation component helpers.
+ */
+export declare class VitalSignEntryEditor extends ObservationComponentEntryEditor {
+    setIdentifier(identifier?: string | null): this;
+    getIdentifier(): string | undefined;
+    ensureIdentifier(): string;
+    setSubject(subject: string): this;
+    getSubject(): string | undefined;
+    setStatus(status: string): this;
+    getStatus(): string | undefined;
+    setCategory(category: CodingDescriptor | string): this;
+    getCategory(): string | undefined;
+    setDate(date: string): this;
+    getDate(): string | undefined;
+    setNote(note: string): this;
+    getNote(): string | undefined;
+    setVitalSignType(code: CodingDescriptor, unit?: CodingDescriptor): this;
+    setHeartRate(value: number): this;
+    getHeartRate(): number | undefined;
+    setBodyTemperature(value: number): this;
+    getBodyTemperature(): number | undefined;
+    setSystolicBloodPressure(value: number): this;
+    getSystolicBloodPressure(): number | undefined;
+    setDiastolicBloodPressure(value: number): this;
+    getDiastolicBloodPressure(): number | undefined;
+}
+/**
+ * General Observation editor surface.
+ *
+ * This extends the Vital Sign editor so generic Observation rows can reuse the
+ * same code/date/value helpers while adding broader Observation references.
+ */
+export declare class ObservationEntryEditor extends VitalSignEntryEditor {
+    setBasedOn(reference: string): this;
+    getBasedOn(): string | undefined;
+    setEncounter(reference: string): this;
+    getEncounter(): string | undefined;
+    setPerformer(reference: string): this;
+    getPerformer(): string | undefined;
+    setHasMember(reference: string): this;
+    getHasMember(): string | undefined;
+}
 /**
  * Employee-specific editor for one staged bundle entry.
  *

package/dist/utils/bundle-editor.js

@@ -1,9 +1,13 @@
 import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
 import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { ObservationCategoryCodes, VitalSignsCodes, VitalSignsUnits } from '../constants/vital-signs.js';
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
 import { buildEmployeeBatchEntry, buildEmployeePurgeBundle, buildEmployeeSearchBundle, EmployeeBatchEntryTypes, EmployeeBundleMethods, EmployeeBundleOperations, EmployeeResourceTypes, } from './employee.js';
 export const BundleEditableResourceTypes = Object.freeze({
     employee: EmployeeResourceTypes.employee,
     consent: ResourceTypesFhirR4.Consent,
+    observation: ResourceTypesFhirR4.Observation,
+    vitalSign: ResourceTypesFhirR4.Observation,
 });
 function cloneEntry(value) {
     return JSON.parse(JSON.stringify(value));
@@ -75,12 +79,35 @@ export class BundleEditor {
     bundleOperation = null;
     allowedResourceType = null;
     entries = [];
-    /** Declares which business operation this bundle is staging. */
+    /**
+     * Declares which business action this in-memory bundle is staging.
+     *
+     * Important distinction:
+     * - this is **not** the same concept as FHIR `Bundle.entry.request.method`
+     * - this is the higher-level action the editor is helping to assemble, for
+     *   example `create`, `search`, `disable`, or `purge`
+     * - the lower-level transport/request method may later be derived from that
+     *   action, and may differ by backend contract
+     *
+     * Example:
+     * - bundle operation `disable`
+     * - current employee GW contract -> inner `entry.request.method = DELETE`
+     * - current individual organization GW contract -> explicit `/_disable`
+     *   route with inner `entry.request.method = POST`
+     */
     setBundleOperation(operation) {
         this.bundleOperation = operation;
         return this;
     }
-    /** Returns the current business operation assigned to the bundle. */
+    /**
+     * Returns the current high-level business action assigned to the bundle.
+     *
+     * Read this as:
+     * - "what am I trying to do?"
+     *
+     * not as:
+     * - "which HTTP/FHIR request method will the final entry use?"
+     */
     getBundleOperation() {
         return this.bundleOperation;
     }
@@ -301,6 +328,22 @@ export class BundleEntryEditor {
         }
         return new EmployeeEntryEditor(this.bundleEditor, this.entryIndex);
     }
+    /** Opens the current entry as one vital-sign-specific Observation editor. */
+    asVitalSign() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Observation) {
+            throw new Error(`BundleEntryEditor cannot open this entry as VitalSign: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new VitalSignEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one general Observation editor. */
+    asObservation() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Observation) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Observation: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new ObservationEntryEditor(this.bundleEditor, this.entryIndex);
+    }
     /** Reads one claim from this entry. */
     getClaim(key) {
         return cloneClaimValue(this.getClaims()[String(key).trim()]);
@@ -397,6 +440,243 @@ export class BundleEntryEditor {
         };
     }
 }
+/**
+ * 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.
+ */
+export class ObservationComponentEntryEditor extends BundleEntryEditor {
+    setCode(code) {
+        const token = typeof code === 'string' ? code.trim() : code.claim;
+        this.setClaim(ObservationClaim.Code, token);
+        if (typeof code !== 'string') {
+            this.setClaim(ObservationClaim.CodeSystem, code.system);
+            this.setClaim(ObservationClaim.CodeValue, code.code);
+            if (code.display) {
+                this.setClaim(ObservationClaim.CodeDisplay, code.display);
+            }
+        }
+        return this;
+    }
+    getCode() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Code));
+    }
+    setCodeSystem(system) {
+        return this.setClaim(ObservationClaim.CodeSystem, String(system).trim());
+    }
+    getCodeSystem() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeSystem));
+    }
+    setCodeValue(value) {
+        return this.setClaim(ObservationClaim.CodeValue, String(value).trim());
+    }
+    getCodeValue() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeValue));
+    }
+    setCodeDisplay(display) {
+        return this.setClaim(ObservationClaim.CodeDisplay, String(display).trim());
+    }
+    getCodeDisplay() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeDisplay));
+    }
+    /** Local-language label intended for forms and local UI. */
+    setLocalText(text) {
+        return this.setClaim(ObservationClaim.CodeText, String(text).trim());
+    }
+    getLocalText() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeText));
+    }
+    setValueQuantityNumber(value) {
+        return this.setClaim(ObservationClaim.ValueQuantityNumber, String(value));
+    }
+    getValueQuantityNumber() {
+        const raw = this.getClaim(ObservationClaim.ValueQuantityNumber);
+        if (raw === undefined || raw === null || raw === '')
+            return undefined;
+        const numeric = Number(raw);
+        return Number.isFinite(numeric) ? numeric : undefined;
+    }
+    setValueQuantityUnit(unit) {
+        const normalized = typeof unit === 'string' ? unit.trim() : unit.claim;
+        return this.setClaim(ObservationClaim.ValueQuantityUnit, normalized);
+    }
+    getValueQuantityUnit() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.ValueQuantityUnit));
+    }
+    setValueString(value) {
+        return this.setClaim(ObservationClaim.ValueString, String(value).trim());
+    }
+    getValueString() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.ValueString));
+    }
+    setValueDate(value) {
+        return this.setClaim(ObservationClaim.ValueDate, String(value).trim());
+    }
+    getValueDate() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.ValueDate));
+    }
+}
+/**
+ * Vital-sign-specific editor surface for one staged Observation entry.
+ *
+ * This layer applies the visible/searchable Vital Signs claim contract on top
+ * of the reduced Observation component helpers.
+ */
+export class VitalSignEntryEditor extends ObservationComponentEntryEditor {
+    setIdentifier(identifier) {
+        const normalized = normalizeOptionalIdentifier(identifier);
+        if (!normalized) {
+            this.removeClaim(ObservationClaim.Identifier);
+            this.setResourceId(undefined);
+            this.setFullUrl(undefined);
+            return this;
+        }
+        this.setClaim(ObservationClaim.Identifier, normalized);
+        this.setResourceId(normalized);
+        this.setFullUrl(normalized);
+        return this;
+    }
+    getIdentifier() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Identifier)
+            || this.getResourceId()
+            || this.getFullUrl());
+    }
+    ensureIdentifier() {
+        const existing = this.getIdentifier();
+        if (existing)
+            return existing;
+        const generated = createCanonicalIdentifierUrn();
+        this.setIdentifier(generated);
+        return generated;
+    }
+    setSubject(subject) {
+        const normalized = String(subject).trim();
+        this.setClaim(ObservationClaim.Subject, normalized);
+        this.setClaim(ObservationClaim.Patient, normalized);
+        return this;
+    }
+    getSubject() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Subject)
+            || this.getClaim(ObservationClaim.Patient));
+    }
+    setStatus(status) {
+        return this.setClaim(ObservationClaim.Status, String(status).trim());
+    }
+    getStatus() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Status));
+    }
+    setCategory(category) {
+        const normalized = typeof category === 'string' ? category.trim() : category.claim;
+        return this.setClaim(ObservationClaim.Category, normalized);
+    }
+    getCategory() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Category));
+    }
+    setDate(date) {
+        const normalized = String(date).trim();
+        this.setClaim(ObservationClaim.Date, normalized);
+        this.setClaim(ObservationClaim.EffectiveDateTime, normalized);
+        return this;
+    }
+    getDate() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Date)
+            || this.getClaim(ObservationClaim.EffectiveDateTime));
+    }
+    setNote(note) {
+        return this.setClaim(ObservationClaim.Note, String(note).trim());
+    }
+    getNote() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Note));
+    }
+    setVitalSignType(code, unit) {
+        this.setCategory(ObservationCategoryCodes.VitalSigns);
+        this.setStatus(this.getStatus() || 'final');
+        this.setCode(code);
+        this.setCodeSystem(code.system);
+        this.setCodeValue(code.code);
+        if (code.display) {
+            this.setCodeDisplay(code.display);
+            this.setLocalText(code.display);
+        }
+        if (unit) {
+            this.setValueQuantityUnit(unit);
+        }
+        return this;
+    }
+    setHeartRate(value) {
+        return this
+            .setVitalSignType(VitalSignsCodes.HeartRate, VitalSignsUnits.BeatsPerMinute)
+            .setValueQuantityNumber(value);
+    }
+    getHeartRate() {
+        return this.getCodeValue() === VitalSignsCodes.HeartRate.code
+            ? this.getValueQuantityNumber()
+            : undefined;
+    }
+    setBodyTemperature(value) {
+        return this
+            .setVitalSignType(VitalSignsCodes.BodyTemperature, VitalSignsUnits.Celsius)
+            .setValueQuantityNumber(value);
+    }
+    getBodyTemperature() {
+        return this.getCodeValue() === VitalSignsCodes.BodyTemperature.code
+            ? this.getValueQuantityNumber()
+            : undefined;
+    }
+    setSystolicBloodPressure(value) {
+        return this
+            .setVitalSignType(VitalSignsCodes.SystolicBloodPressure, VitalSignsUnits.MillimeterOfMercury)
+            .setValueQuantityNumber(value);
+    }
+    getSystolicBloodPressure() {
+        return this.getCodeValue() === VitalSignsCodes.SystolicBloodPressure.code
+            ? this.getValueQuantityNumber()
+            : undefined;
+    }
+    setDiastolicBloodPressure(value) {
+        return this
+            .setVitalSignType(VitalSignsCodes.DiastolicBloodPressure, VitalSignsUnits.MillimeterOfMercury)
+            .setValueQuantityNumber(value);
+    }
+    getDiastolicBloodPressure() {
+        return this.getCodeValue() === VitalSignsCodes.DiastolicBloodPressure.code
+            ? this.getValueQuantityNumber()
+            : undefined;
+    }
+}
+/**
+ * General Observation editor surface.
+ *
+ * This extends the Vital Sign editor so generic Observation rows can reuse the
+ * same code/date/value helpers while adding broader Observation references.
+ */
+export class ObservationEntryEditor extends VitalSignEntryEditor {
+    setBasedOn(reference) {
+        return this.setClaim(ObservationClaim.BasedOn, String(reference).trim());
+    }
+    getBasedOn() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.BasedOn));
+    }
+    setEncounter(reference) {
+        return this.setClaim(ObservationClaim.Encounter, String(reference).trim());
+    }
+    getEncounter() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Encounter));
+    }
+    setPerformer(reference) {
+        return this.setClaim(ObservationClaim.Performer, String(reference).trim());
+    }
+    getPerformer() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Performer));
+    }
+    setHasMember(reference) {
+        return this.setClaim(ObservationClaim.HasMember, String(reference).trim());
+    }
+    getHasMember() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.HasMember));
+    }
+}
 /**
  * Employee-specific editor for one staged bundle entry.
  *

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

@@ -7,7 +7,7 @@ export { deviceUseStatementFlatToFhirR4, deviceUseStatementFhirR4ToFlat, } from
 export { documentReferenceFlatToFhirR4, documentReferenceFhirR4ToFlat, } from '../convert/convert-document-reference';
 export { immunizationFlatToFhirR4, immunizationFhirR4ToFlat, } from '../convert/convert-immunization';
 export { locationFlatToFhirR4, locationFhirR4ToFlat, } from '../convert/convert-location';
-export { observationFlatToFhirR4, observationFhirR4ToFlat, } from '../convert/convert-observation';
+export { observationFromFlatToFhirR4, observationToFlatFhirR4, observationFlatToFhirR4, observationFhirR4ToFlat, } from '../convert/convert-observation';
 export { organizationFlatToFhirR4, organizationFhirR4ToFlat, } from '../convert/convert-organization';
 export { procedureFlatToFhirR4, procedureFhirR4ToFlat, } from '../convert/convert-procedure';
 export { deviceFlatToFhirR4, deviceFhirR4ToFlat, } from '../convert/convert-device';
@@ -29,7 +29,7 @@ import { deviceUseStatementFhirR4ToFlat, deviceUseStatementFlatToFhirR4 } from '
 import { documentReferenceFhirR4ToFlat, documentReferenceFlatToFhirR4 } from '../convert/convert-document-reference';
 import { immunizationFhirR4ToFlat, immunizationFlatToFhirR4 } from '../convert/convert-immunization';
 import { locationFhirR4ToFlat, locationFlatToFhirR4 } from '../convert/convert-location';
-import { observationFhirR4ToFlat, observationFlatToFhirR4 } from '../convert/convert-observation';
+import { observationFromFlatToFhirR4, observationToFlatFhirR4 } from '../convert/convert-observation';
 import { organizationFhirR4ToFlat, organizationFlatToFhirR4 } from '../convert/convert-organization';
 import { procedureFhirR4ToFlat, procedureFlatToFhirR4 } from '../convert/convert-procedure';
 import { deviceFhirR4ToFlat, deviceFlatToFhirR4 } from '../convert/convert-device';
@@ -57,8 +57,8 @@ export declare const immunizationFlatToFhir: typeof immunizationFlatToFhirR4;
 export declare const immunizationFhirToFlat: typeof immunizationFhirR4ToFlat;
 export declare const locationFlatToFhir: typeof locationFlatToFhirR4;
 export declare const locationFhirToFlat: typeof locationFhirR4ToFlat;
-export declare const observationFlatToFhir: typeof observationFlatToFhirR4;
-export declare const observationFhirToFlat: typeof observationFhirR4ToFlat;
+export declare const observationFlatToFhir: typeof observationFromFlatToFhirR4;
+export declare const observationFhirToFlat: typeof observationToFlatFhirR4;
 export declare const organizationFlatToFhir: typeof organizationFlatToFhirR4;
 export declare const organizationFhirToFlat: typeof organizationFhirR4ToFlat;
 export declare const procedureFlatToFhir: typeof procedureFlatToFhirR4;

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

@@ -8,7 +8,7 @@ export { deviceUseStatementFlatToFhirR4, deviceUseStatementFhirR4ToFlat, } from
 export { documentReferenceFlatToFhirR4, documentReferenceFhirR4ToFlat, } from '../convert/convert-document-reference.js';
 export { immunizationFlatToFhirR4, immunizationFhirR4ToFlat, } from '../convert/convert-immunization.js';
 export { locationFlatToFhirR4, locationFhirR4ToFlat, } from '../convert/convert-location.js';
-export { observationFlatToFhirR4, observationFhirR4ToFlat, } from '../convert/convert-observation.js';
+export { observationFromFlatToFhirR4, observationToFlatFhirR4, observationFlatToFhirR4, observationFhirR4ToFlat, } from '../convert/convert-observation.js';
 export { organizationFlatToFhirR4, organizationFhirR4ToFlat, } from '../convert/convert-organization.js';
 export { procedureFlatToFhirR4, procedureFhirR4ToFlat, } from '../convert/convert-procedure.js';
 export { deviceFlatToFhirR4, deviceFhirR4ToFlat, } from '../convert/convert-device.js';
@@ -30,7 +30,7 @@ import { deviceUseStatementFhirR4ToFlat, deviceUseStatementFlatToFhirR4 } from '
 import { documentReferenceFhirR4ToFlat, documentReferenceFlatToFhirR4 } from '../convert/convert-document-reference.js';
 import { immunizationFhirR4ToFlat, immunizationFlatToFhirR4 } from '../convert/convert-immunization.js';
 import { locationFhirR4ToFlat, locationFlatToFhirR4 } from '../convert/convert-location.js';
-import { observationFhirR4ToFlat, observationFlatToFhirR4 } from '../convert/convert-observation.js';
+import { observationFromFlatToFhirR4, observationToFlatFhirR4, } from '../convert/convert-observation.js';
 import { organizationFhirR4ToFlat, organizationFlatToFhirR4 } from '../convert/convert-organization.js';
 import { procedureFhirR4ToFlat, procedureFlatToFhirR4 } from '../convert/convert-procedure.js';
 import { deviceFhirR4ToFlat, deviceFlatToFhirR4 } from '../convert/convert-device.js';
@@ -58,8 +58,8 @@ export const immunizationFlatToFhir = immunizationFlatToFhirR4;
 export const immunizationFhirToFlat = immunizationFhirR4ToFlat;
 export const locationFlatToFhir = locationFlatToFhirR4;
 export const locationFhirToFlat = locationFhirR4ToFlat;
-export const observationFlatToFhir = observationFlatToFhirR4;
-export const observationFhirToFlat = observationFhirR4ToFlat;
+export const observationFlatToFhir = observationFromFlatToFhirR4;
+export const observationFhirToFlat = observationToFlatFhirR4;
 export const organizationFlatToFhir = organizationFlatToFhirR4;
 export const organizationFhirToFlat = organizationFhirR4ToFlat;
 export const procedureFlatToFhir = procedureFlatToFhirR4;
@@ -108,7 +108,7 @@ export function convertFhirResourceToClaims(resource, context = 'org.hl7.fhir.r4
         case 'Location':
             return locationFhirR4ToFlat(resource);
         case 'Observation':
-            return observationFhirR4ToFlat(resource);
+            return observationToFlatFhirR4(resource);
         case 'Organization':
             return organizationFhirR4ToFlat(resource);
         case 'Procedure':

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

@@ -206,6 +206,17 @@ export declare class CommunicationAttachedBundleSession {
         type?: string;
         request?: BundleRequest;
     }>): this;
+    /**
+     * Observation helper for IPS-style and sectioned bundle authoring.
+     *
+     * Expected keys should come from Observation claims constants.
+     */
+    upsertActiveObservationEntry(input: Readonly<{
+        claims: Record<string, unknown>;
+        fullUrl?: string;
+        type?: string;
+        request?: BundleRequest;
+    }>): this;
     /**
      * AllergyIntolerance helper for IPS-in-Communication use cases.
      *

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

@@ -11,6 +11,7 @@ import { BundleQuery } from './bundle-query.js';
 import { addClaimValues } from '../claims/claim-list-helpers.js';
 import { detectDuplicateConsentRuleConflicts, } from './consent-duplicate-rules.js';
 import { MedicationStatementClaim, } from '../models/interoperable-claims/medication-statement-claims.js';
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
 export const ConsentEditorTargetKinds = Object.freeze({
     Section: 'section',
     ResourceType: 'resource-type',
@@ -235,6 +236,22 @@ export class CommunicationAttachedBundleSession {
             request: input.request,
         });
     }
+    /**
+     * Observation helper for IPS-style and sectioned bundle authoring.
+     *
+     * Expected keys should come from Observation claims constants.
+     */
+    upsertActiveObservationEntry(input) {
+        return this.upsertActiveEntry({
+            resourceType: ResourceTypesFhirR4.Observation,
+            claims: {
+                ...input.claims,
+            },
+            fullUrl: input.fullUrl,
+            type: input.type,
+            request: input.request,
+        });
+    }
     /**
      * AllergyIntolerance helper for IPS-in-Communication use cases.
      *
@@ -439,6 +456,10 @@ export class CommunicationAttachedBundleSession {
             if (documentReferenceSubject) {
                 return documentReferenceSubject;
             }
+            const observationSubject = asTrimmedString(claims[ObservationClaim.Subject] || claims[ObservationClaim.Patient]);
+            if (observationSubject) {
+                return observationSubject;
+            }
         }
         const fromClaims = asTrimmedString(this.communicationClaims[CommunicationClaim.Subject]);
         return fromClaims || undefined;
@@ -481,6 +502,10 @@ export class CommunicationAttachedBundleSession {
         if (documentReferenceIdentifier) {
             return `${ResourceTypesFhirR4.DocumentReference}:${documentReferenceIdentifier}`;
         }
+        const observationIdentifier = asTrimmedString(claims[ObservationClaim.Identifier]);
+        if (observationIdentifier) {
+            return `${ResourceTypesFhirR4.Observation}:${observationIdentifier}`;
+        }
         return '';
     }
     createBundleEntry(input) {
@@ -522,6 +547,10 @@ export class CommunicationAttachedBundleSession {
         if (documentReferenceIdentifier) {
             return documentReferenceIdentifier;
         }
+        const observationIdentifier = asTrimmedString(claims[ObservationClaim.Identifier]);
+        if (observationIdentifier) {
+            return observationIdentifier;
+        }
         const communicationIdentifier = asTrimmedString(claims[CommunicationClaim.Identifier]);
         if (communicationIdentifier) {
             return communicationIdentifier;