gdc-common-utils-ts 2.0.18 → 2.2.2

package/dist/utils/same-as.js

@@ -1,4 +1,5 @@
 import { createHash } from 'crypto';
+import { normalizePhone } from './consent.js';
 import { encodeMultibase58btc } from './multibase58.js';
 /**
  * Builds the ICA-compatible multibase58(multihash(sha3-256)) payload for a
@@ -28,6 +29,12 @@ function looksLikeEmail(value) {
     const trimmed = value.trim();
     return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed);
 }
+function splitCommaSeparatedValues(value) {
+    return String(value || '')
+        .split(',')
+        .map((candidate) => candidate.trim())
+        .filter(Boolean);
+}
 /**
  * Normalizes a public controller alias into the same representation used by
  * ICA for `credentialSubject.sameAs` and `controller.sameAs`.
@@ -64,6 +71,71 @@ export function normalizeSameAsHash(value) {
     }
     return trimmed;
 }
+/**
+ * Normalizes one or more `sameAs` aliases into one deduplicated array.
+ *
+ * Input forms:
+ * - one plain string
+ * - one CSV string
+ * - one array of plain/CSV strings
+ *
+ * Normalization rules:
+ * - whitespace-only entries are discarded
+ * - emails are hashed into ICA-compatible `urn:multibase:z...`
+ * - already-normalized `urn:multibase:z...` values are preserved
+ * - duplicate normalized entries are removed while preserving order
+ *
+ * @param value Canonical sameAs source value(s).
+ */
+export function normalizeSameAsHashList(value) {
+    const candidates = Array.isArray(value)
+        ? value.flatMap((entry) => splitCommaSeparatedValues(entry))
+        : splitCommaSeparatedValues(String(value || ''));
+    const normalized = candidates
+        .map((candidate) => normalizeSameAsHash(candidate))
+        .filter(Boolean);
+    return [...new Set(normalized)];
+}
+/**
+ * Joins one or more normalized `sameAs` aliases into the current flat CSV
+ * storage form used by some shared VC/profile helpers.
+ *
+ * @param value Canonical sameAs source value(s).
+ */
+export function normalizeSameAsHashCsv(value) {
+    return normalizeSameAsHashList(value).join(',');
+}
+/**
+ * Normalizes one public telephone alias into the same hashed
+ * `urn:multibase:z...` representation used for ICA-compatible public
+ * continuity identifiers, while keeping the telephone claim separate from
+ * `sameAs`.
+ *
+ * Rules:
+ * - empty input becomes `''`
+ * - `urn:multibase:z...` stays unchanged
+ * - bare `z...` becomes `urn:multibase:z...`
+ * - plain phone-like values are compacted through `normalizePhone(...)`
+ *   before hashing
+ *
+ * @param value Plain or already-normalized public telephone alias.
+ */
+export function normalizeTelephoneHash(value) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed)
+        return '';
+    if (trimmed.toLowerCase().startsWith('urn:multibase:')) {
+        const suffix = trimmed.slice('urn:multibase:'.length).trim();
+        return looksLikeBase58Multibase(suffix) ? `urn:multibase:${suffix}` : trimmed;
+    }
+    if (looksLikeBase58Multibase(trimmed)) {
+        return `urn:multibase:${trimmed}`;
+    }
+    const normalizedPhone = normalizePhone(trimmed);
+    if (!normalizedPhone)
+        return '';
+    return `urn:multibase:${multibase58MultihashSha3_256(normalizedPhone)}`;
+}
 /**
  * Compares two public controller aliases after ICA-compatible normalization.
  *

package/dist/utils/unified-health-id.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Computes the Damm check digit for one decimal payload.
+ *
+ * Canonical input:
+ * - decimal digits only
+ *
+ * Algorithm:
+ * - Damm check digit over the full normalized sequence
+ *
+ * Compatibility:
+ * - this helper is intentionally strict about the normalized payload so the
+ *   same digits always produce the same digit, regardless of presentation
+ */
+export declare function computeDammCheckDigit(payloadDigits: string): string;
+/**
+ * Computes the provider-scoped Unified Health ID control digit.
+ *
+ * Canonical input:
+ * - `providerId` normalized to digits only
+ * - `personalIdWithoutCheckDigit` normalized to digits only
+ * - the check digit is computed over `providerId + personalIdWithoutCheckDigit`
+ *
+ * Algorithm:
+ * - Damm check digit over the concatenated normalized digits
+ *
+ * Compatibility:
+ * - separators such as `:` and `-` are ignored
+ * - the same personal payload can produce a different digit in another
+ *   provider because the provider digits are part of the normalized sequence
+ *
+ * @param providerId Provider-scoped numeric identifier. Presentation separators are ignored.
+ * @param personalIdWithoutCheckDigit Personal identifier payload without its final control digit.
+ * @returns One decimal check digit as a string.
+ */
+export declare function computeUnifiedHealthIdCheckDigit(providerId: string, personalIdWithoutCheckDigit: string): string;
+/**
+ * Builds the provider-scoped Unified Health ID personal digits including the
+ * final control digit.
+ *
+ * Canonical input:
+ * - `providerId` normalized to digits only
+ * - `personalIdWithoutCheckDigit` normalized to digits only
+ *
+ * Output:
+ * - the normalized personal digits followed by the computed control digit
+ *
+ * @param providerId Provider-scoped numeric identifier. Presentation separators are ignored.
+ * @param personalIdWithoutCheckDigit Personal identifier payload without its final control digit.
+ * @returns The normalized personal digits plus the final control digit.
+ */
+export declare function buildUnifiedHealthIdPersonalDigits(providerId: string, personalIdWithoutCheckDigit: string): string;

package/dist/utils/unified-health-id.js

@@ -0,0 +1,92 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+/**
+ * Computes the Damm check digit for one decimal payload.
+ *
+ * Canonical input:
+ * - decimal digits only
+ *
+ * Algorithm:
+ * - Damm check digit over the full normalized sequence
+ *
+ * Compatibility:
+ * - this helper is intentionally strict about the normalized payload so the
+ *   same digits always produce the same digit, regardless of presentation
+ */
+export function computeDammCheckDigit(payloadDigits) {
+    const normalized = normalizeDigitsOnly(payloadDigits, 'payloadDigits');
+    const table = [
+        [0, 3, 1, 7, 5, 9, 8, 6, 4, 2],
+        [7, 0, 9, 2, 1, 5, 4, 8, 6, 3],
+        [4, 2, 0, 6, 8, 7, 1, 3, 5, 9],
+        [1, 7, 5, 0, 9, 8, 3, 4, 2, 6],
+        [6, 1, 2, 3, 0, 4, 5, 9, 7, 8],
+        [3, 6, 7, 4, 2, 0, 9, 5, 8, 1],
+        [5, 8, 6, 9, 7, 2, 0, 1, 3, 4],
+        [8, 9, 4, 5, 3, 6, 2, 0, 1, 7],
+        [9, 4, 3, 8, 6, 1, 7, 2, 0, 5],
+        [2, 5, 8, 1, 4, 3, 6, 7, 9, 0],
+    ];
+    let interim = 0;
+    for (const digit of normalized) {
+        interim = table[interim][Number(digit)];
+    }
+    return String(interim);
+}
+/**
+ * Computes the provider-scoped Unified Health ID control digit.
+ *
+ * Canonical input:
+ * - `providerId` normalized to digits only
+ * - `personalIdWithoutCheckDigit` normalized to digits only
+ * - the check digit is computed over `providerId + personalIdWithoutCheckDigit`
+ *
+ * Algorithm:
+ * - Damm check digit over the concatenated normalized digits
+ *
+ * Compatibility:
+ * - separators such as `:` and `-` are ignored
+ * - the same personal payload can produce a different digit in another
+ *   provider because the provider digits are part of the normalized sequence
+ *
+ * @param providerId Provider-scoped numeric identifier. Presentation separators are ignored.
+ * @param personalIdWithoutCheckDigit Personal identifier payload without its final control digit.
+ * @returns One decimal check digit as a string.
+ */
+export function computeUnifiedHealthIdCheckDigit(providerId, personalIdWithoutCheckDigit) {
+    const normalizedProviderId = normalizeDigitsOnly(providerId, 'providerId');
+    const normalizedPersonalId = normalizeDigitsOnly(personalIdWithoutCheckDigit, 'personalIdWithoutCheckDigit');
+    return computeDammCheckDigit(`${normalizedProviderId}${normalizedPersonalId}`);
+}
+/**
+ * Builds the provider-scoped Unified Health ID personal digits including the
+ * final control digit.
+ *
+ * Canonical input:
+ * - `providerId` normalized to digits only
+ * - `personalIdWithoutCheckDigit` normalized to digits only
+ *
+ * Output:
+ * - the normalized personal digits followed by the computed control digit
+ *
+ * @param providerId Provider-scoped numeric identifier. Presentation separators are ignored.
+ * @param personalIdWithoutCheckDigit Personal identifier payload without its final control digit.
+ * @returns The normalized personal digits plus the final control digit.
+ */
+export function buildUnifiedHealthIdPersonalDigits(providerId, personalIdWithoutCheckDigit) {
+    const normalizedPersonalId = normalizeDigitsOnly(personalIdWithoutCheckDigit, 'personalIdWithoutCheckDigit');
+    return `${normalizedPersonalId}${computeUnifiedHealthIdCheckDigit(providerId, normalizedPersonalId)}`;
+}
+function normalizeDigitsOnly(value, name) {
+    const normalized = String(value || '').trim();
+    if (!normalized) {
+        throw new Error(`${name} must not be empty`);
+    }
+    if (!/^[0-9:\-\s]+$/.test(normalized)) {
+        throw new Error(`${name} must contain only digits, spaces, colons, or hyphens`);
+    }
+    const digits = normalized.replace(/\D/g, '');
+    if (!digits) {
+        throw new Error(`${name} must contain at least one digit`);
+    }
+    return digits;
+}

package/dist/utils/vital-sign-day-batch.d.ts

@@ -0,0 +1,25 @@
+import type { BundleEntry, BundleJsonApi } from '../models/bundle';
+export declare const VitalSignDayBatchClaim: Readonly<{
+    readonly Identifier: "VitalSignDayBatch.identifier";
+    readonly Subject: "VitalSignDayBatch.subject";
+    readonly Actor: "VitalSignDayBatch.actor";
+    readonly Day: "VitalSignDayBatch.day";
+    readonly CreatedAtTimestamp: "VitalSignDayBatch.createdAtTimestamp";
+}>;
+export type VitalSignDayBatchEntryInput = Readonly<{
+    subject: string;
+    actor: string;
+    date: string | Date;
+    createdAtTimestamp?: number;
+    entry?: BundleEntry;
+    bundle?: BundleJsonApi<BundleEntry>;
+}>;
+export type VitalSignDayBatchResult = Readonly<{
+    batchId: string;
+    day: string;
+    reused: boolean;
+    bundle: BundleJsonApi<BundleEntry>;
+}>;
+export declare function buildVitalSignDayBatchClaims(input: Pick<VitalSignDayBatchEntryInput, 'subject' | 'actor' | 'date' | 'createdAtTimestamp'>): Record<string, unknown>;
+export declare function resolveVitalSignDayBatchId(input: VitalSignDayBatchEntryInput): VitalSignDayBatchResult;
+export declare function openOrCreateVitalSignDayBatchBundle(input: VitalSignDayBatchEntryInput): BundleJsonApi<BundleEntry>;

package/dist/utils/vital-sign-day-batch.js

@@ -0,0 +1,115 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { createCanonicalIdentifierUrn } from './bundle-editor-helpers.js';
+import { BundleQuery } from './bundle-query.js';
+export const VitalSignDayBatchClaim = Object.freeze({
+    Identifier: 'VitalSignDayBatch.identifier',
+    Subject: 'VitalSignDayBatch.subject',
+    Actor: 'VitalSignDayBatch.actor',
+    Day: 'VitalSignDayBatch.day',
+    CreatedAtTimestamp: 'VitalSignDayBatch.createdAtTimestamp',
+});
+export function buildVitalSignDayBatchClaims(input) {
+    const day = resolveDayKey(input.date);
+    const claims = {
+        [VitalSignDayBatchClaim.Subject]: asTrimmedString(input.subject),
+        [VitalSignDayBatchClaim.Actor]: asTrimmedString(input.actor),
+        [VitalSignDayBatchClaim.Day]: day,
+    };
+    if (typeof input.createdAtTimestamp === 'number' && Number.isFinite(input.createdAtTimestamp)) {
+        claims[VitalSignDayBatchClaim.CreatedAtTimestamp] = input.createdAtTimestamp;
+    }
+    return claims;
+}
+export function resolveVitalSignDayBatchId(input) {
+    const baseBundle = cloneBundle(input.bundle || createEmptyBundle());
+    const day = resolveDayKey(input.date);
+    const dayRange = resolveDayRange(day);
+    const existingClaims = asRecord(baseBundle.meta?.claims);
+    const query = new BundleQuery(baseBundle);
+    const dayEntryIds = query.getResourceIds({ dateFrom: dayRange.from, dateTo: dayRange.to });
+    const dayEntries = query.getResourceEntriesByIds(dayEntryIds);
+    const matchingDayEntry = dayEntries.find((entry) => matchesBatchOwner(entry, input.subject, input.actor));
+    const sameOwner = matchesBatchOwnerClaims(existingClaims, input.subject, input.actor);
+    const sameDay = asTrimmedString(existingClaims[VitalSignDayBatchClaim.Day]) === day;
+    const existingBatchId = asTrimmedString(baseBundle.id || existingClaims[VitalSignDayBatchClaim.Identifier]);
+    const reused = Boolean(existingBatchId && sameOwner && sameDay && (dayEntryIds.length > 0 || matchingDayEntry));
+    const batchId = reused ? existingBatchId : createCanonicalIdentifierUrn();
+    const bundle = {
+        ...baseBundle,
+        id: batchId,
+        meta: {
+            ...(baseBundle.meta || {}),
+            claims: {
+                ...existingClaims,
+                ...buildVitalSignDayBatchClaims(input),
+                [VitalSignDayBatchClaim.Identifier]: batchId,
+            },
+        },
+        data: [...(baseBundle.data || [])],
+    };
+    if (input.entry) {
+        bundle.data.push(cloneEntry(input.entry));
+    }
+    return {
+        batchId,
+        day,
+        reused,
+        bundle,
+    };
+}
+export function openOrCreateVitalSignDayBatchBundle(input) {
+    return resolveVitalSignDayBatchId(input).bundle;
+}
+function matchesBatchOwner(entry, subject, actor) {
+    const claims = asRecord(entry.resource?.meta?.claims || entry.meta?.claims);
+    return matchesBatchOwnerClaims(claims, subject, actor);
+}
+function matchesBatchOwnerClaims(claims, subject, actor) {
+    return asTrimmedString(claims[VitalSignDayBatchClaim.Subject]) === asTrimmedString(subject)
+        && asTrimmedString(claims[VitalSignDayBatchClaim.Actor]) === asTrimmedString(actor);
+}
+function resolveDayKey(value) {
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+    }
+    const raw = asTrimmedString(value);
+    if (!raw) {
+        return new Date().toISOString().slice(0, 10);
+    }
+    const parsed = Date.parse(raw);
+    if (Number.isNaN(parsed)) {
+        return raw.slice(0, 10);
+    }
+    return new Date(parsed).toISOString().slice(0, 10);
+}
+function resolveDayRange(day) {
+    return {
+        from: `${day}T00:00:00.000Z`,
+        to: `${day}T23:59:59.999Z`,
+    };
+}
+function asTrimmedString(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    return String(value).trim();
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function cloneBundle(bundle) {
+    return JSON.parse(JSON.stringify(bundle));
+}
+function cloneEntry(entry) {
+    return JSON.parse(JSON.stringify(entry));
+}
+function createEmptyBundle() {
+    return {
+        resourceType: 'Bundle',
+        type: 'collection',
+        data: [],
+    };
+}

package/dist/utils/vital-sign-entry-editor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { ObservationComponentEntryEditor } from './observation-component-entry-editor';
+/**
+ * Typed editor for one staged VitalSign resource entry.
+ *
+ * Use this surface when the frontend needs a simple authoring path for common
+ * measurements such as heart rate, temperature, or blood pressure.
+ */
+export declare class VitalSignEntryEditor extends ObservationComponentEntryEditor {
+    /** 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 vital-sign 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 vital-sign observation. */
+    setSubject(subject: string): this;
+    /** Returns the subject/patient reference for this vital-sign observation. */
+    getSubject(): string | undefined;
+    /** Sets the observation status. */
+    setStatus(status: string): this;
+    /** Returns the observation status. */
+    getStatus(): string | undefined;
+    /** Sets the observation category, usually one of the shared vital-sign category descriptors. */
+    setCategory(category: CodingDescriptor | string): this;
+    /** Returns the observation category token. */
+    getCategory(): string | undefined;
+    /** Sets the observation date/effective time. */
+    setDate(date: string): this;
+    /** Returns the observation date/effective time. */
+    getDate(): string | undefined;
+    /** Sets one free-text note for the vital sign. */
+    setNote(note: string): this;
+    /** Returns the free-text note for the vital sign. */
+    getNote(): string | undefined;
+    /** Seeds the observation code and optional quantity unit for the selected vital-sign family. */
+    setVitalSignType(code: CodingDescriptor, unit?: CodingDescriptor): this;
+    /** Convenience helper for heart-rate authoring using the shared code/unit catalog. */
+    setHeartRate(value: number): this;
+    /** Returns the heart-rate numeric value. */
+    getHeartRate(): number | undefined;
+    /** Convenience helper for body-temperature authoring using the shared code/unit catalog. */
+    setBodyTemperature(value: number): this;
+    /** Returns the body-temperature numeric value. */
+    getBodyTemperature(): number | undefined;
+    /** Convenience helper for systolic blood-pressure authoring. */
+    setSystolicBloodPressure(value: number): this;
+    /** Returns the systolic blood-pressure numeric value. */
+    getSystolicBloodPressure(): number | undefined;
+    /** Convenience helper for diastolic blood-pressure authoring. */
+    setDiastolicBloodPressure(value: number): this;
+    /** Returns the diastolic blood-pressure numeric value. */
+    getDiastolicBloodPressure(): number | undefined;
+}

package/dist/utils/vital-sign-entry-editor.js

@@ -0,0 +1,152 @@
+/**
+ * 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 { ObservationCategoryCodes, VitalSignsCodes, VitalSignsUnits } from '../constants/vital-signs.js';
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { createCanonicalIdentifierUrn, normalizeOptionalIdentifier } from './bundle-editor-helpers.js';
+import { ObservationComponentEntryEditor } from './observation-component-entry-editor.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged VitalSign resource entry.
+ *
+ * Use this surface when the frontend needs a simple authoring path for common
+ * measurements such as heart rate, temperature, or blood pressure.
+ */
+export class VitalSignEntryEditor extends ObservationComponentEntryEditor {
+    /** Overrides the canonical identifier when import or migration logic needs one explicit public id. */
+    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;
+    }
+    /** Returns the canonical identifier currently exposed for this vital-sign entry. */
+    getIdentifier() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Identifier)
+            || this.getResourceId()
+            || this.getFullUrl());
+    }
+    /** Ensures the entry has one synchronized canonical identifier across public claim, `resource.id`, and `fullUrl`. */
+    ensureIdentifier() {
+        const existing = this.getIdentifier();
+        if (existing)
+            return existing;
+        const generated = createCanonicalIdentifierUrn();
+        this.setIdentifier(generated);
+        return generated;
+    }
+    /** Sets the subject/patient reference for this vital-sign observation. */
+    setSubject(subject) {
+        const normalized = String(subject).trim();
+        this.setClaim(ObservationClaim.Subject, normalized);
+        this.setClaim(ObservationClaim.Patient, normalized);
+        return this;
+    }
+    /** Returns the subject/patient reference for this vital-sign observation. */
+    getSubject() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Subject)
+            || this.getClaim(ObservationClaim.Patient));
+    }
+    /** Sets the observation status. */
+    setStatus(status) {
+        return this.setClaim(ObservationClaim.Status, String(status).trim());
+    }
+    /** Returns the observation status. */
+    getStatus() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Status));
+    }
+    /** Sets the observation category, usually one of the shared vital-sign category descriptors. */
+    setCategory(category) {
+        const normalized = typeof category === 'string' ? category.trim() : category.claim;
+        return this.setClaim(ObservationClaim.Category, normalized);
+    }
+    /** Returns the observation category token. */
+    getCategory() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Category));
+    }
+    /** Sets the observation date/effective time. */
+    setDate(date) {
+        const normalized = String(date).trim();
+        this.setClaim(ObservationClaim.Date, normalized);
+        this.setClaim(ObservationClaim.EffectiveDateTime, normalized);
+        return this;
+    }
+    /** Returns the observation date/effective time. */
+    getDate() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Date)
+            || this.getClaim(ObservationClaim.EffectiveDateTime));
+    }
+    /** Sets one free-text note for the vital sign. */
+    setNote(note) {
+        return this.setClaim(ObservationClaim.Note, String(note).trim());
+    }
+    /** Returns the free-text note for the vital sign. */
+    getNote() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Note));
+    }
+    /** Seeds the observation code and optional quantity unit for the selected vital-sign family. */
+    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.setCodeTextLocal(code.display);
+        }
+        if (unit) {
+            this.setValueQuantityUnit(unit);
+        }
+        return this;
+    }
+    /** Convenience helper for heart-rate authoring using the shared code/unit catalog. */
+    setHeartRate(value) {
+        this.setVitalSignType(VitalSignsCodes.HeartRate, VitalSignsUnits.BeatsPerMinute);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the heart-rate numeric value. */
+    getHeartRate() {
+        return this.getValueQuantityNumber();
+    }
+    /** Convenience helper for body-temperature authoring using the shared code/unit catalog. */
+    setBodyTemperature(value) {
+        this.setVitalSignType(VitalSignsCodes.BodyTemperature, VitalSignsUnits.Celsius);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the body-temperature numeric value. */
+    getBodyTemperature() {
+        return this.getValueQuantityNumber();
+    }
+    /** Convenience helper for systolic blood-pressure authoring. */
+    setSystolicBloodPressure(value) {
+        this.setVitalSignType(VitalSignsCodes.SystolicBloodPressure, VitalSignsUnits.MillimeterOfMercury);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the systolic blood-pressure numeric value. */
+    getSystolicBloodPressure() {
+        return this.getValueQuantityNumber();
+    }
+    /** Convenience helper for diastolic blood-pressure authoring. */
+    setDiastolicBloodPressure(value) {
+        this.setVitalSignType(VitalSignsCodes.DiastolicBloodPressure, VitalSignsUnits.MillimeterOfMercury);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the diastolic blood-pressure numeric value. */
+    getDiastolicBloodPressure() {
+        return this.getValueQuantityNumber();
+    }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.vitalSign, VitalSignEntryEditor);

package/dist/utils/wallet-mem.d.ts

@@ -0,0 +1,93 @@
+import { CryptographyService } from '../CryptographyService';
+import type { ICryptoHelper } from '../interfaces/ICryptoHelper';
+import type { IWallet } from '../interfaces/IWallet';
+import type { IWalletQueue } from '../interfaces/IWalletQueue';
+import type { JWK, JwkSet } from '../models/jwk';
+import { type WalletEnqueueMessageInput, type WalletManagedEntityDescriptor, type WalletQueuedMessage } from '../models/wallet';
+export type WalletMemOptions = Readonly<{
+    cryptoHelper: ICryptoHelper;
+    cryptography?: CryptographyService;
+    queue?: IWalletQueue;
+}>;
+/**
+ * In-memory wallet implementation intended for:
+ * - common low-level tests
+ * - GW template integration tests
+ * - frontend-like and BFF-like local transport simulations
+ *
+ * Design rule:
+ * - keep this class below actor-specific SDK facades
+ * - compose cryptography, key cache, local queue, and DIDComm-style
+ *   pack/unpack in one portable runtime-neutral helper
+ */
+export declare class WalletMem implements IWallet {
+    private readonly cryptoHelper;
+    private readonly cryptography;
+    private readonly entities;
+    private readonly queue;
+    constructor(options: WalletMemOptions);
+    /**
+     * Computes one digest through the injected platform helper.
+     */
+    digest(data: string, algorithm: string): Promise<string>;
+    /**
+     * Provisions one deterministic signing key, one deterministic encryption key,
+     * and one deterministic storage key for the provided entity id.
+     */
+    provisionKeys(entityId: string): Promise<JwkSet>;
+    /**
+     * Returns the public signing/encryption keys currently provisioned for one entity.
+     */
+    getPublicKeys(entityId: string): Promise<WalletManagedEntityDescriptor>;
+    /**
+     * Protects one document in memory using the entity-specific at-rest key.
+     */
+    protectConfidentialData(doc: unknown, entityId?: string): Promise<unknown>;
+    /**
+     * Unprotects one document previously encrypted through `protectConfidentialData(...)`.
+     */
+    unprotectConfidentialData(doc: unknown, entityId?: string): Promise<unknown>;
+    /**
+     * Signs one JSON payload into a compact JWS carrying the sender public JWK.
+     */
+    signCompactJws(entityId: string, claims: Record<string, unknown>): Promise<string>;
+    /**
+     * Encrypts one plaintext for the provided recipient public JWK.
+     */
+    buildCompactJwe(entityId: string, plaintext: string | Uint8Array, recipientJwk: JWK, contentType?: string): Promise<string>;
+    /**
+     * Packs one payload as nested compact JWS inside compact JWE.
+     */
+    pack(content: Record<string, unknown>, recipientJwk: JWK, entityId: string): Promise<string>;
+    /**
+     * Unpacks one compact JWE and, when present, verifies the nested compact JWS.
+     */
+    unpack(packedMessage: string, entityId?: string): Promise<{
+        content: unknown;
+        meta: Record<string, unknown>;
+    }>;
+    /**
+     * Enqueues one message in the local in-memory outbox/queue.
+     */
+    enqueueMessage(input: WalletEnqueueMessageInput): Promise<WalletQueuedMessage>;
+    /**
+     * Returns the highest-priority pending message without mutating queue state.
+     */
+    peekNextMessage(): Promise<WalletQueuedMessage | undefined>;
+    /**
+     * Marks one queued message as delivered.
+     */
+    markMessageDelivered(messageId: string): Promise<WalletQueuedMessage>;
+    /**
+     * Marks one queued message as failed while preserving it in the local queue.
+     */
+    markMessageFailed(messageId: string, errorMessage: string): Promise<WalletQueuedMessage>;
+    /**
+     * Lists all queued messages in priority/FIFO processing order.
+     */
+    listMessages(): Promise<WalletQueuedMessage[]>;
+    private deriveSeedBytes;
+    private requireEntityId;
+    private resolveEntityId;
+    private requireEntityState;
+}