gdc-common-utils-ts 2.1.0 → 2.2.2

package/dist/utils/index.js

@@ -1,4 +1,5 @@
 export * from './actor.js';
+export * from './authority-resolution.js';
 export * from './activation-policy.js';
 export * from './base-convert.js';
 export * from './baseN.js';
@@ -34,6 +35,7 @@ export * from './gw-core-path.js';
 export * from './gw-core-commercial-contract.js';
 export * from './legal-organization-verification-result.js';
 export * from './communication-fhir-r4.js';
+export * from './communication-editor.js';
 export * from './communication-document-reference.js';
 export * from './communication-bundle-document-request.js';
 export * from './communication-identity.js';
@@ -48,6 +50,7 @@ export * from './communication-didcomm-payload.js';
 export * from './confidential-storage-persistence.js';
 export * from './confidential-storage-test-data.js';
 export * from './permission-templates.js';
+export * from './client-assertion.js';
 export * from './professional-smart.js';
 export * from './related-person-list.js';
 export * from './clinical-resource-converters.js';
@@ -56,6 +59,7 @@ export * from './clinical-resource-view.js';
 export * from './fhir-validator.js';
 export * from './family-registration-test-data.js';
 export * from './individual-form-pdf.js';
+export * from './individual-smart.js';
 export * from './individual-organization-claims.js';
 export * from './inter-tenant-access-contract.js';
 export * from './legal-organization-onboarding-editor.js';
@@ -64,6 +68,7 @@ export * from './organization-did-binding.js';
 export * from './organization-authorization-urn.js';
 export * from './individual-organization-lifecycle.js';
 export * from './individual-onboarding-editor.js';
+export * from './individual-onboarding-acceptance-credential.js';
 export * from './individual-onboarding-document-reference.js';
 export * from './individual-organization-kyc.js';
 export * from './individual-bundle-vault.js';
@@ -88,12 +93,14 @@ export * from './normalize.js';
 export * from './object-convert.js';
 export * from './normalize-uuid.js';
 export * from './object-sanitize.js';
+export * from './unified-health-id.js';
 export * from './permission-templates.js';
 export * from './smart-scope.js';
 export * from './service-act-reasons.js';
 export * from './same-as.js';
 export * from './activation-request.js';
 export * from './vp-token.js';
+export * from './vital-sign-day-batch.js';
 export * from './wallet-mem.js';
 export * from './wallet-memory-queue.js';
 export * from './profile-outbox-memory-repository.js';

package/dist/utils/individual-onboarding-acceptance-credential.d.ts

@@ -0,0 +1,35 @@
+import type { VerifiableCredentialV2 } from '../models/verifiable-credential';
+/**
+ * Input for the canonical individual-onboarding acceptance credential.
+ *
+ * This helper builds the evidence object that a frontend/BFF can later sign
+ * with the user profile key pair before sending it as an attachment.
+ *
+ * Canonical semantics:
+ * - `credentialSubject.memberOf.taxID` is the organization tax identifier
+ * - `credentialSubject.hasOccupation.identifier.value` defaults to `RESPRSN`
+ * - `credentialSubject.hasCredential.material` binds the credential to the
+ *   profile signing material
+ */
+export type IndividualOnboardingAcceptanceCredentialInput = Readonly<{
+    issuerDid: string;
+    subjectDid: string;
+    organizationTaxId: string;
+    profileKeyMaterial: string;
+    validFrom: string;
+    credentialId?: string;
+    representativeIdentifier?: string;
+    representativeRoleCode?: string;
+    sameAs?: string;
+    validUntil?: string;
+    proof?: VerifiableCredentialV2['proof'];
+}>;
+/**
+ * Builds the canonical Verifiable Credential for individual onboarding
+ * acceptance.
+ *
+ * The result is unsigned by design. Callers sign it with the user profile key
+ * pair and then attach the signed VC to the `Organization/_transaction`
+ * request.
+ */
+export declare function buildIndividualOnboardingAcceptanceCredential(input: IndividualOnboardingAcceptanceCredentialInput): VerifiableCredentialV2;

package/dist/utils/individual-onboarding-acceptance-credential.js

@@ -0,0 +1,55 @@
+import { ActivationCredentialTypes, W3cCredentialContexts, W3cCredentialTypes } from '../constants/verifiable-credentials.js';
+import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function requireText(value, fieldName) {
+    const normalized = normalizeText(value);
+    if (!normalized) {
+        throw new Error(`buildIndividualOnboardingAcceptanceCredential requires ${fieldName}.`);
+    }
+    return normalized;
+}
+/**
+ * Builds the canonical Verifiable Credential for individual onboarding
+ * acceptance.
+ *
+ * The result is unsigned by design. Callers sign it with the user profile key
+ * pair and then attach the signed VC to the `Organization/_transaction`
+ * request.
+ */
+export function buildIndividualOnboardingAcceptanceCredential(input) {
+    const issuerDid = requireText(input.issuerDid, 'issuerDid');
+    const subjectDid = requireText(input.subjectDid, 'subjectDid');
+    const organizationTaxId = requireText(input.organizationTaxId, 'organizationTaxId');
+    const profileKeyMaterial = requireText(input.profileKeyMaterial, 'profileKeyMaterial');
+    const validFrom = requireText(input.validFrom, 'validFrom');
+    const roleCode = normalizeText(input.representativeRoleCode) || 'RESPRSN';
+    return {
+        '@context': [W3cCredentialContexts.V2, 'https://schema.org'],
+        ...(normalizeText(input.credentialId) ? { id: normalizeText(input.credentialId) } : {}),
+        type: [W3cCredentialTypes.VerifiableCredential, ActivationCredentialTypes.LegalRepresentativeCredential],
+        issuer: issuerDid,
+        credentialSubject: {
+            id: subjectDid,
+            memberOf: {
+                taxID: organizationTaxId,
+            },
+            hasOccupation: {
+                identifier: {
+                    value: roleCode,
+                },
+            },
+            hasCredential: {
+                material: profileKeyMaterial,
+            },
+            ...(normalizeText(input.representativeIdentifier)
+                ? { [ClaimsPersonSchemaorg.identifierValue]: normalizeText(input.representativeIdentifier) }
+                : {}),
+            ...(normalizeText(input.sameAs) ? { sameAs: normalizeText(input.sameAs) } : {}),
+        },
+        validFrom,
+        ...(normalizeText(input.validUntil) ? { validUntil: normalizeText(input.validUntil) } : {}),
+        ...(input.proof ? { proof: input.proof } : {}),
+    };
+}

package/dist/utils/individual-smart.d.ts

@@ -0,0 +1,59 @@
+export type IndividualActorIdentityCredentialInput = Readonly<{
+    actorDid: string;
+    subjectDid?: string;
+    relationship?: string;
+    authorityBasis?: string;
+    email?: string;
+    sameAs?: string | readonly string[];
+    telephone?: string;
+    credentialMaterial?: string;
+    evidence?: readonly Record<string, unknown>[];
+    additionalCredentialSubject?: Record<string, unknown>;
+    additionalCredential?: Record<string, unknown>;
+}>;
+export type IndividualActorIdentityVpPayloadInput = Readonly<{
+    clientId: string;
+    actorDid: string;
+    subjectDid?: string;
+    relationship?: string;
+    authorityBasis?: string;
+    email?: string;
+    sameAs?: string | readonly string[];
+    telephone?: string;
+    credentialMaterial?: string;
+    evidence?: readonly Record<string, unknown>[];
+    verifiableCredential?: string | Record<string, unknown> | ReadonlyArray<string | Record<string, unknown>>;
+    additionalVp?: Record<string, unknown>;
+    additionalPayload?: Record<string, unknown>;
+}>;
+export type IndividualSubjectCredentialInput = Readonly<{
+    subjectDid: string;
+    sameAs?: string | readonly string[];
+    telephone?: string;
+    evidence?: readonly Record<string, unknown>[];
+    additionalCredentialSubject?: Record<string, unknown>;
+    additionalCredential?: Record<string, unknown>;
+}>;
+export type IndividualControllerCredentialInput = IndividualActorIdentityCredentialInput;
+export type IndividualControllerVpPayloadInput = IndividualActorIdentityVpPayloadInput;
+export type IndividualMemberCredentialInput = IndividualActorIdentityCredentialInput;
+export type IndividualMemberVpPayloadInput = IndividualActorIdentityVpPayloadInput;
+export declare function getIndividualControllerIdentitySameAs(input: Readonly<Pick<IndividualControllerCredentialInput, 'sameAs' | 'email'>>): string[];
+export declare function getIndividualControllerIdentityTelephone(input: Readonly<Pick<IndividualControllerCredentialInput, 'telephone'>>): string | undefined;
+export declare function getIndividualControllerIdentityVC(input: IndividualControllerCredentialInput): Record<string, unknown>;
+export declare function buildIndividualControllerIdentityVpPayload(input: IndividualControllerVpPayloadInput): Record<string, unknown>;
+export declare function buildUnsignedIndividualControllerIdentityVpJwt(input: IndividualControllerVpPayloadInput, options?: Readonly<{
+    nowSeconds?: number;
+    ttlSeconds?: number;
+    nonce?: string;
+}>): string;
+export declare function getIndividualSubjectVC(input: IndividualSubjectCredentialInput): Record<string, unknown>;
+export declare function getIndividualMemberIdentitySameAs(input: Readonly<Pick<IndividualMemberCredentialInput, 'sameAs' | 'email'>>): string[];
+export declare function getIndividualMemberIdentityTelephone(input: Readonly<Pick<IndividualMemberCredentialInput, 'telephone'>>): string | undefined;
+export declare function getIndividualMemberIdentityVC(input: IndividualMemberCredentialInput): Record<string, unknown>;
+export declare function buildIndividualMemberIdentityVpPayload(input: IndividualMemberVpPayloadInput): Record<string, unknown>;
+export declare function buildUnsignedIndividualMemberIdentityVpJwt(input: IndividualMemberVpPayloadInput, options?: Readonly<{
+    nowSeconds?: number;
+    ttlSeconds?: number;
+    nonce?: string;
+}>): string;

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