gdc-common-utils-ts 2.0.18 → 2.2.2

package/dist/utils/individual-smart.js

@@ -0,0 +1,135 @@
+import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
+import { IndividualCredentialTypes, W3cCredentialTypes, } from '../constants/verifiable-credentials.js';
+import { normalizeSameAsHashCsv, normalizeSameAsHashList, normalizeTelephoneHash } from './same-as.js';
+import { buildUnsignedVpJwt } from './jwt.js';
+function getIndividualIdentitySameAs(input) {
+    const sameAsCandidates = [];
+    if (input.sameAs) {
+        sameAsCandidates.push(...normalizeSameAsHashList(input.sameAs));
+    }
+    if (input.email) {
+        sameAsCandidates.push(...normalizeSameAsHashList(input.email));
+    }
+    return [...new Set(sameAsCandidates)];
+}
+function getIndividualIdentityTelephone(input) {
+    const normalized = normalizeTelephoneHash(String(input.telephone || ''));
+    return normalized || undefined;
+}
+function buildIndividualIdentityVC(input, credentialType) {
+    const normalizedSameAs = getIndividualIdentitySameAs(input);
+    const normalizedTelephone = getIndividualIdentityTelephone(input);
+    const normalizedCredentialMaterial = String(input.credentialMaterial || '').trim();
+    const normalizedSubjectDid = String(input.subjectDid || '').trim();
+    const normalizedRelationship = String(input.relationship || '').trim();
+    const normalizedAuthorityBasis = String(input.authorityBasis || '').trim();
+    return {
+        type: [
+            W3cCredentialTypes.VerifiableCredential,
+            credentialType,
+        ],
+        credentialSubject: {
+            id: String(input.actorDid || '').trim(),
+            ...(normalizedSubjectDid ? { subject: normalizedSubjectDid } : {}),
+            ...(normalizedRelationship ? { relationship: normalizedRelationship } : {}),
+            ...(normalizedAuthorityBasis ? { authorityBasis: normalizedAuthorityBasis } : {}),
+            ...(normalizedSameAs.length
+                ? { sameAs: normalizeSameAsHashCsv(normalizedSameAs) }
+                : {}),
+            ...(normalizedTelephone
+                ? { [ClaimsPersonSchemaorg.telephone]: normalizedTelephone }
+                : {}),
+            ...(normalizedCredentialMaterial
+                ? { [ClaimsPersonSchemaorg.hasCredentialMaterial]: normalizedCredentialMaterial }
+                : {}),
+            ...(input.additionalCredentialSubject || {}),
+        },
+        ...(Array.isArray(input.evidence) && input.evidence.length
+            ? { evidence: [...input.evidence] }
+            : {}),
+        ...(input.additionalCredential || {}),
+    };
+}
+function buildIndividualIdentityVpPayload(input, credentialType) {
+    const credentials = Array.isArray(input.verifiableCredential)
+        ? [...input.verifiableCredential]
+        : input.verifiableCredential
+            ? [input.verifiableCredential]
+            : [buildIndividualIdentityVC({
+                    actorDid: input.actorDid,
+                    subjectDid: input.subjectDid,
+                    relationship: input.relationship,
+                    authorityBasis: input.authorityBasis,
+                    email: input.email,
+                    sameAs: input.sameAs,
+                    telephone: input.telephone,
+                    credentialMaterial: input.credentialMaterial,
+                    evidence: input.evidence,
+                }, credentialType)];
+    return {
+        ...(input.additionalPayload || {}),
+        vp: {
+            holder: String(input.clientId || '').trim(),
+            verifiableCredential: credentials,
+            ...(input.additionalVp || {}),
+        },
+    };
+}
+export function getIndividualControllerIdentitySameAs(input) {
+    return getIndividualIdentitySameAs(input);
+}
+export function getIndividualControllerIdentityTelephone(input) {
+    return getIndividualIdentityTelephone(input);
+}
+export function getIndividualControllerIdentityVC(input) {
+    return buildIndividualIdentityVC(input, IndividualCredentialTypes.IndividualControllerCredential);
+}
+export function buildIndividualControllerIdentityVpPayload(input) {
+    return buildIndividualIdentityVpPayload(input, IndividualCredentialTypes.IndividualControllerCredential);
+}
+export function buildUnsignedIndividualControllerIdentityVpJwt(input, options = {}) {
+    return buildUnsignedVpJwt(buildIndividualControllerIdentityVpPayload(input), options);
+}
+export function getIndividualSubjectVC(input) {
+    const normalizedSameAs = getIndividualIdentitySameAs({
+        sameAs: input.sameAs,
+    });
+    const normalizedTelephone = getIndividualIdentityTelephone({
+        telephone: input.telephone,
+    });
+    return {
+        type: [
+            W3cCredentialTypes.VerifiableCredential,
+            IndividualCredentialTypes.IndividualSubjectCredential,
+        ],
+        credentialSubject: {
+            id: String(input.subjectDid || '').trim(),
+            ...(normalizedSameAs.length
+                ? { sameAs: normalizeSameAsHashCsv(normalizedSameAs) }
+                : {}),
+            ...(normalizedTelephone
+                ? { [ClaimsPersonSchemaorg.telephone]: normalizedTelephone }
+                : {}),
+            ...(input.additionalCredentialSubject || {}),
+        },
+        ...(Array.isArray(input.evidence) && input.evidence.length
+            ? { evidence: [...input.evidence] }
+            : {}),
+        ...(input.additionalCredential || {}),
+    };
+}
+export function getIndividualMemberIdentitySameAs(input) {
+    return getIndividualIdentitySameAs(input);
+}
+export function getIndividualMemberIdentityTelephone(input) {
+    return getIndividualIdentityTelephone(input);
+}
+export function getIndividualMemberIdentityVC(input) {
+    return buildIndividualIdentityVC(input, IndividualCredentialTypes.IndividualMemberCredential);
+}
+export function buildIndividualMemberIdentityVpPayload(input) {
+    return buildIndividualIdentityVpPayload(input, IndividualCredentialTypes.IndividualMemberCredential);
+}
+export function buildUnsignedIndividualMemberIdentityVpJwt(input, options = {}) {
+    return buildUnsignedVpJwt(buildIndividualMemberIdentityVpPayload(input), options);
+}

package/dist/utils/medication-statement-entry-editor.d.ts

@@ -0,0 +1,90 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - Keep exactly one exported class per file.
+ * - Keep this file focused on one typed editor surface.
+ * - Move shared helpers to reusable helper/base modules instead of duplicating logic here.
+ */
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged MedicationStatement resource entry.
+ *
+ * Use this surface in the frontend when the user creates, corrects, or reviews
+ * medication data one entry at a time before the final document is built.
+ */
+export declare class MedicationStatementEntryEditor extends ClinicalResourceEntryEditor {
+    /** Overrides the canonical identifier when import or migration logic needs one explicit public id. */
+    setIdentifier(identifier?: string | null): this;
+    /** Returns the canonical identifier currently exposed for this medication entry. */
+    getIdentifier(): string | undefined;
+    /** Ensures the entry has one synchronized canonical identifier across public claim, `resource.id`, and `fullUrl`. */
+    ensureIdentifier(): string;
+    /** Sets the subject/patient reference for this medication statement. */
+    setSubject(subject?: string | null): this;
+    /** Returns the subject/patient reference for this medication statement. */
+    getSubject(): string | undefined;
+    /** Sets the medication statement status. */
+    setStatus(status?: string | null): this;
+    /** Returns the medication statement status. */
+    getStatus(): string | undefined;
+    /** Sets the effective date or period token stored in the flat-claims model. */
+    setEffective(value?: string | null): this;
+    /** Returns the effective date or period token. */
+    getEffective(): string | undefined;
+    /** Sets the coded medication identifier/value used by downstream FHIR export. */
+    setCode(code?: string | null): this;
+    /** Returns the coded medication identifier/value. */
+    getCode(): string | undefined;
+    /** Sets the human-readable medication text shown in UI cards and document narratives. */
+    setMedicationText(text?: string | null): this;
+    /** Returns the human-readable medication text. */
+    getMedicationText(): string | undefined;
+    /** Sets one free-text note attached to the medication entry. */
+    setNote(note?: string | null): this;
+    /** Returns the current medication note. */
+    getNote(): string | undefined;
+    /** Sets one flat-text dosage instruction. */
+    setDosageInstruction(value?: string | null): this;
+    /** Returns the flat-text dosage instruction. */
+    getDosageInstruction(): string | undefined;
+    /** Replaces the medication category/section tags used by document assembly and local filtering. */
+    setCategoryList(values: readonly string[]): this;
+    /** Returns the medication category/section tags. */
+    getCategoryList(): string[];
+    /** Sets the numeric dose quantity value. */
+    setDoseQuantityValue(value?: number | null): this;
+    /** Returns the numeric dose quantity value. */
+    getDoseQuantityValue(): number | undefined;
+    /** Sets the dose quantity unit token. */
+    setDoseQuantityUnit(value?: string | null): this;
+    /** Returns the dose quantity unit token. */
+    getDoseQuantityUnit(): string | undefined;
+    /** Sets the timing frequency for structured dosage authoring. */
+    setTimingFrequency(value?: number | null): this;
+    /** Returns the timing frequency. */
+    getTimingFrequency(): number | undefined;
+    /** Sets the timing period for structured dosage authoring. */
+    setTimingPeriod(value?: number | null): this;
+    /** Returns the timing period. */
+    getTimingPeriod(): number | undefined;
+    /** Sets the timing period unit token. */
+    setTimingPeriodUnit(value?: string | null): this;
+    /** Returns the timing period unit token. */
+    getTimingPeriodUnit(): string | undefined;
+    /** Marks whether this dosage is `as needed`. */
+    setDosageAsNeeded(value?: boolean | null): this;
+    /** Returns whether this dosage is `as needed`. */
+    getDosageAsNeeded(): boolean | undefined;
+    /** Replaces the linked child-resource reference list, typically `DocumentReference/...` items. */
+    setContainedResourceReferenceList(references: readonly string[]): this;
+    /** Returns the linked child-resource reference list. */
+    getContainedResourceReferenceList(): string[];
+    /** Marks whether the medication was user-entered or user-confirmed in self-managed flows. */
+    setUserSelected(value?: boolean | null): this;
+    /** Returns whether the medication was marked as user-selected. */
+    getUserSelected(): boolean | undefined;
+    /** @deprecated Use `setContainedResourceReferenceList(...)`. */
+    setContainedDocumentIdentifierList(identifiers: readonly string[]): this;
+    /** @deprecated Use `getContainedResourceReferenceList()`. */
+    getContainedDocumentIdentifierList(): string[];
+}

package/dist/utils/medication-statement-entry-editor.js

@@ -0,0 +1,94 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - Keep exactly one exported class per file.
+ * - Keep this file focused on one typed editor surface.
+ * - Move shared helpers to reusable helper/base modules instead of duplicating logic here.
+ */
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor.js';
+import { MedicationStatementClaim, MedicationStatementClaimsFhirApiExtended } from '../models/interoperable-claims/medication-statement-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged MedicationStatement resource entry.
+ *
+ * Use this surface in the frontend when the user creates, corrects, or reviews
+ * medication data one entry at a time before the final document is built.
+ */
+export class MedicationStatementEntryEditor extends ClinicalResourceEntryEditor {
+    /** Overrides the canonical identifier when import or migration logic needs one explicit public id. */
+    setIdentifier(identifier) { return this.setIdentifierValue(MedicationStatementClaim.Identifier, identifier); }
+    /** Returns the canonical identifier currently exposed for this medication entry. */
+    getIdentifier() { return this.getIdentifierValue(MedicationStatementClaim.Identifier); }
+    /** Ensures the entry has one synchronized canonical identifier across public claim, `resource.id`, and `fullUrl`. */
+    ensureIdentifier() { return this.ensureIdentifierValue(MedicationStatementClaim.Identifier); }
+    /** Sets the subject/patient reference for this medication statement. */
+    setSubject(subject) { return this.setSubjectClaims(MedicationStatementClaim.Subject, MedicationStatementClaim.Patient, subject); }
+    /** Returns the subject/patient reference for this medication statement. */
+    getSubject() { return this.getSubjectClaims(MedicationStatementClaim.Subject, MedicationStatementClaim.Patient); }
+    /** Sets the medication statement status. */
+    setStatus(status) { return this.setScalarClaim(MedicationStatementClaim.Status, status); }
+    /** Returns the medication statement status. */
+    getStatus() { return this.getScalarClaim(MedicationStatementClaim.Status); }
+    /** Sets the effective date or period token stored in the flat-claims model. */
+    setEffective(value) { return this.setScalarClaim(MedicationStatementClaim.Effective, value); }
+    /** Returns the effective date or period token. */
+    getEffective() { return this.getScalarClaim(MedicationStatementClaim.Effective); }
+    /** Sets the coded medication identifier/value used by downstream FHIR export. */
+    setCode(code) { return this.setScalarClaim(MedicationStatementClaim.Code, code); }
+    /** Returns the coded medication identifier/value. */
+    getCode() { return this.getScalarClaim(MedicationStatementClaim.Code); }
+    /** Sets the human-readable medication text shown in UI cards and document narratives. */
+    setMedicationText(text) { return this.setScalarClaim(MedicationStatementClaim.MedicationText, text); }
+    /** Returns the human-readable medication text. */
+    getMedicationText() { return this.getScalarClaim(MedicationStatementClaim.MedicationText); }
+    /** Sets one free-text note attached to the medication entry. */
+    setNote(note) { return this.setScalarClaim(MedicationStatementClaim.Note, note); }
+    /** Returns the current medication note. */
+    getNote() { return this.getScalarClaim(MedicationStatementClaim.Note); }
+    /** Sets one flat-text dosage instruction. */
+    setDosageInstruction(value) { return this.setScalarClaim(MedicationStatementClaim.DosageInstruction, value); }
+    /** Returns the flat-text dosage instruction. */
+    getDosageInstruction() { return this.getScalarClaim(MedicationStatementClaim.DosageInstruction); }
+    /** Replaces the medication category/section tags used by document assembly and local filtering. */
+    setCategoryList(values) { return this.setCsvClaimList(MedicationStatementClaim.Category, values); }
+    /** Returns the medication category/section tags. */
+    getCategoryList() { return this.getCsvClaimList(MedicationStatementClaim.Category); }
+    /** Sets the numeric dose quantity value. */
+    setDoseQuantityValue(value) { return this.setNumberClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityValue, value); }
+    /** Returns the numeric dose quantity value. */
+    getDoseQuantityValue() { return this.getNumberClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityValue); }
+    /** Sets the dose quantity unit token. */
+    setDoseQuantityUnit(value) { return this.setScalarClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityUnit, value); }
+    /** Returns the dose quantity unit token. */
+    getDoseQuantityUnit() { return this.getScalarClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityUnit); }
+    /** Sets the timing frequency for structured dosage authoring. */
+    setTimingFrequency(value) { return this.setNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingFrequency, value); }
+    /** Returns the timing frequency. */
+    getTimingFrequency() { return this.getNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingFrequency); }
+    /** Sets the timing period for structured dosage authoring. */
+    setTimingPeriod(value) { return this.setNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriod, value); }
+    /** Returns the timing period. */
+    getTimingPeriod() { return this.getNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriod); }
+    /** Sets the timing period unit token. */
+    setTimingPeriodUnit(value) { return this.setScalarClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriodUnit, value); }
+    /** Returns the timing period unit token. */
+    getTimingPeriodUnit() { return this.getScalarClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriodUnit); }
+    /** Marks whether this dosage is `as needed`. */
+    setDosageAsNeeded(value) { return this.setBooleanClaim(MedicationStatementClaimsFhirApiExtended.DosageAsNeeded, value); }
+    /** Returns whether this dosage is `as needed`. */
+    getDosageAsNeeded() { return this.getBooleanClaim(MedicationStatementClaimsFhirApiExtended.DosageAsNeeded); }
+    /** Replaces the linked child-resource reference list, typically `DocumentReference/...` items. */
+    setContainedResourceReferenceList(references) { return this.setCsvClaimList(MedicationStatementClaim.ContainedReferenceList, references); }
+    /** Returns the linked child-resource reference list. */
+    getContainedResourceReferenceList() { return this.getCsvClaimList(MedicationStatementClaim.ContainedReferenceList); }
+    /** Marks whether the medication was user-entered or user-confirmed in self-managed flows. */
+    setUserSelected(value) { return this.setBooleanClaim(MedicationStatementClaim.UserSelected, value); }
+    /** Returns whether the medication was marked as user-selected. */
+    getUserSelected() { return this.getBooleanClaim(MedicationStatementClaim.UserSelected); }
+    /** @deprecated Use `setContainedResourceReferenceList(...)`. */
+    setContainedDocumentIdentifierList(identifiers) { return this.setContainedResourceReferenceList(identifiers); }
+    /** @deprecated Use `getContainedResourceReferenceList()`. */
+    getContainedDocumentIdentifierList() { return this.getContainedResourceReferenceList(); }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.medicationStatement, MedicationStatementEntryEditor);

package/dist/utils/observation-component-entry-editor.d.ts

@@ -0,0 +1,57 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - Keep exactly one exported class per file.
+ * - Keep this file focused on one typed editor surface.
+ * - Move shared helpers to reusable helper/base modules instead of duplicating logic here.
+ */
+import { type CodingDescriptor } from '../constants/vital-signs';
+import { BundleEntryEditor } from './bundle-entry-editor';
+/**
+ * Typed editor for one staged ObservationComponent resource entry.
+ *
+ * Keep this surface thin and claim-focused so 101 tests can teach one
+ * resource at a time without exposing bundle-internal plumbing.
+ */
+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;
+    /**
+     * Stores the local-language label used by forms and local UI copy.
+     *
+     * Keep this distinct from `setCodeDisplay(...)`, which is the canonical
+     * English/international display carried by the coded concept.
+     */
+    setCodeTextLocal(text: string): this;
+    /**
+     * Returns the local-language label used by forms and local UI copy.
+     *
+     * Keep this distinct from `getCodeDisplay()`, which returns the canonical
+     * English/international display when present.
+     */
+    getCodeTextLocal(): string | undefined;
+    /** Compatibility alias for older examples/tests. Prefer `setCodeTextLocal(...)`. */
+    setLocalText(text: string): this;
+    /** Compatibility alias for older examples/tests. Prefer `getCodeTextLocal()`. */
+    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.
+ */

package/dist/utils/observation-component-entry-editor.js

@@ -0,0 +1,105 @@
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
+import { normalizeOptionalIdentifier } from './bundle-editor-helpers.js';
+import { BundleEntryEditor } from './bundle-entry-editor.js';
+/**
+ * Typed editor for one staged ObservationComponent resource entry.
+ *
+ * Keep this surface thin and claim-focused so 101 tests can teach one
+ * resource at a time without exposing bundle-internal plumbing.
+ */
+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));
+    }
+    /**
+     * Stores the local-language label used by forms and local UI copy.
+     *
+     * Keep this distinct from `setCodeDisplay(...)`, which is the canonical
+     * English/international display carried by the coded concept.
+     */
+    setCodeTextLocal(text) {
+        return this.setClaim(ObservationClaim.CodeText, String(text).trim());
+    }
+    /**
+     * Returns the local-language label used by forms and local UI copy.
+     *
+     * Keep this distinct from `getCodeDisplay()`, which returns the canonical
+     * English/international display when present.
+     */
+    getCodeTextLocal() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeText));
+    }
+    /** Compatibility alias for older examples/tests. Prefer `setCodeTextLocal(...)`. */
+    setLocalText(text) {
+        return this.setCodeTextLocal(text);
+    }
+    /** Compatibility alias for older examples/tests. Prefer `getCodeTextLocal()`. */
+    getLocalText() {
+        return this.getCodeTextLocal();
+    }
+    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.
+ */

package/dist/utils/observation-entry-editor.d.ts

@@ -0,0 +1,29 @@
+import { VitalSignEntryEditor } from './vital-sign-entry-editor';
+/**
+ * Typed editor for one staged Observation resource entry.
+ *
+ * Use this when a caller needs to stage one observation row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export declare class ObservationEntryEditor extends VitalSignEntryEditor {
+    /** Writes the based-on reference. */
+    setBasedOn(reference: string): this;
+    /** Reads the based-on reference. */
+    getBasedOn(): string | undefined;
+    /** Writes the encounter reference. */
+    setEncounter(reference: string): this;
+    /** Reads the encounter reference. */
+    getEncounter(): string | undefined;
+    /** Writes the performer reference. */
+    setPerformer(reference: string): this;
+    /** Reads the performer reference. */
+    getPerformer(): string | undefined;
+    /** Writes the has-member reference. */
+    setHasMember(reference: string): this;
+    /** Reads the has-member reference. */
+    getHasMember(): string | undefined;
+    /** Writes the has-member list. */
+    setHasMemberList(references: readonly string[]): this;
+    /** Reads the has-member list. */
+    getHasMemberList(): string[];
+}

package/dist/utils/observation-entry-editor.js

@@ -0,0 +1,68 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - Keep exactly one exported class per file.
+ * - Keep this file focused on one typed editor surface.
+ * - Move shared helpers to reusable helper/base modules instead of duplicating logic here.
+ */
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { normalizeOptionalIdentifier } from './bundle-editor-helpers.js';
+import { VitalSignEntryEditor } from './vital-sign-entry-editor.js';
+import { getClaimValues, setClaimValues } from '../claims/claim-list-helpers.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged Observation resource entry.
+ *
+ * Use this when a caller needs to stage one observation row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export class ObservationEntryEditor extends VitalSignEntryEditor {
+    /** Writes the based-on reference. */
+    setBasedOn(reference) {
+        return this.setClaim(ObservationClaim.BasedOn, String(reference).trim());
+    }
+    /** Reads the based-on reference. */
+    getBasedOn() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.BasedOn));
+    }
+    /** Writes the encounter reference. */
+    setEncounter(reference) {
+        return this.setClaim(ObservationClaim.Encounter, String(reference).trim());
+    }
+    /** Reads the encounter reference. */
+    getEncounter() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Encounter));
+    }
+    /** Writes the performer reference. */
+    setPerformer(reference) {
+        return this.setClaim(ObservationClaim.Performer, String(reference).trim());
+    }
+    /** Reads the performer reference. */
+    getPerformer() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Performer));
+    }
+    /** Writes the has-member reference. */
+    setHasMember(reference) {
+        return this.setClaim(ObservationClaim.HasMember, String(reference).trim());
+    }
+    /** Reads the has-member reference. */
+    getHasMember() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.HasMember));
+    }
+    /** Writes the has-member list. */
+    setHasMemberList(references) {
+        const next = setClaimValues({}, ObservationClaim.HasMember, references);
+        const normalized = normalizeOptionalIdentifier(next[ObservationClaim.HasMember]);
+        if (!normalized) {
+            this.removeClaim(ObservationClaim.HasMember);
+            return this;
+        }
+        return this.setClaim(ObservationClaim.HasMember, normalized);
+    }
+    /** Reads the has-member list. */
+    getHasMemberList() {
+        return getClaimValues(this.getClaims(), ObservationClaim.HasMember);
+    }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.observation, ObservationEntryEditor);

package/dist/utils/procedure-entry-editor.d.ts

@@ -0,0 +1,71 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged Procedure resource entry.
+ *
+ * Use this when a caller needs to stage one procedure row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export declare class ProcedureEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical procedure identifier. */
+    setIdentifier(identifier?: string | null): this;
+    /** Reads the canonical procedure identifier. */
+    getIdentifier(): string | undefined;
+    /** Ensures the procedure entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier(): string;
+    /** Writes the subject/patient reference. */
+    setSubject(subject?: string | null): this;
+    /** Reads the subject/patient reference. */
+    getSubject(): string | undefined;
+    /** Writes the procedure status. */
+    setStatus(status?: string | null): this;
+    /** Reads the procedure status. */
+    getStatus(): string | undefined;
+    /** Writes the procedure date. */
+    setDate(date?: string | null): this;
+    /** Reads the procedure date. */
+    getDate(): string | undefined;
+    /** Writes the procedure code. */
+    setCode(code?: string | null): this;
+    /** Reads the procedure code. */
+    getCode(): string | undefined;
+    /** Writes the local code text. */
+    setCodeTextLocal(text?: string | null): this;
+    /** Reads the local code text. */
+    getCodeTextLocal(): string | undefined;
+    /** Writes the code display text. */
+    setCodeDisplay(display?: string | null): this;
+    /** Reads the code display text. */
+    getCodeDisplay(): string | undefined;
+    /** Writes the encounter reference. */
+    setEncounter(reference?: string | null): this;
+    /** Reads the encounter reference. */
+    getEncounter(): string | undefined;
+    /** Writes the location reference. */
+    setLocation(reference?: string | null): this;
+    /** Reads the location reference. */
+    getLocation(): string | undefined;
+    /** Writes the reason code. */
+    setReasonCode(code?: string | null): this;
+    /** Reads the reason code. */
+    getReasonCode(): string | undefined;
+    /** Writes the note text. */
+    setNote(note?: string | null): this;
+    /** Reads the note text. */
+    getNote(): string | undefined;
+    /** Alias for `setNote(...)` used by callers that expect clinical wording. */
+    setClinicalNote(note?: string | null): this;
+    /** Alias for `getNote()` used by callers that expect clinical wording. */
+    getClinicalNote(): string | undefined;
+    /** Writes the performer list. */
+    setPerformerList(references: readonly string[]): this;
+    /** Reads the performer list. */
+    getPerformerList(): string[];
+    /** Writes the based-on list. */
+    setBasedOnList(references: readonly string[]): this;
+    /** Reads the based-on list. */
+    getBasedOnList(): string[];
+    /** Writes the reason-reference list. */
+    setReasonReferenceList(references: readonly string[]): this;
+    /** Reads the reason-reference list. */
+    getReasonReferenceList(): string[];
+}