gdc-common-utils-ts 2.1.0 → 2.3.0

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

@@ -1,6 +1,10 @@
 export type ProfessionalEmployeeCredentialInput = Readonly<{
     actorDid: string;
     role: string;
+    email?: string;
+    sameAs?: string | readonly string[];
+    telephone?: string;
+    credentialMaterial?: string;
     additionalCredentialSubject?: Record<string, unknown>;
     additionalCredential?: Record<string, unknown>;
 }>;
@@ -8,14 +12,97 @@ export type ProfessionalSmartVpPayloadInput = Readonly<{
     clientId: string;
     actorDid: string;
     role: string;
+    email?: string;
+    sameAs?: string | readonly string[];
+    telephone?: string;
+    credentialMaterial?: string;
     verifiableCredential?: string | Record<string, unknown> | ReadonlyArray<string | Record<string, unknown>>;
     additionalVp?: Record<string, unknown>;
     additionalPayload?: Record<string, unknown>;
 }>;
+/**
+ * Returns the normalized public continuity aliases for one professional
+ * identity VC.
+ *
+ * The canonical source is:
+ * - explicit `sameAs` values when present
+ * - otherwise the public employee email
+ *
+ * When both are present they are merged and deduplicated after normalization.
+ *
+ * @param input Professional identity source values.
+ */
+export declare function getProfessionalIdentitySameAs(input: Readonly<Pick<ProfessionalEmployeeCredentialInput, 'sameAs' | 'email'>>): string[];
+/**
+ * Returns the normalized public telephone continuity value for one
+ * professional identity VC.
+ *
+ * Telephone continuity is kept separate from `sameAs` so callers can reuse
+ * ICA-compatible hashing without overloading the public alias slot.
+ *
+ * @param input Professional identity source values.
+ */
+export declare function getProfessionalIdentityTelephone(input: Readonly<Pick<ProfessionalEmployeeCredentialInput, 'telephone'>>): string | undefined;
+/**
+ * Builds the canonical professional identity VC payload reused by SMART VP
+ * token helpers and higher SDK facades.
+ *
+ * Current projection rules:
+ * - `credentialSubject.sameAs` stores one CSV string to preserve compatibility
+ *   with the current flat/shared claim style
+ * - `credentialSubject.telephone` stores the hashed public phone continuity
+ *   value when present
+ * - `credentialSubject.hasCredential.material` carries the public signing/bind
+ *   material when present
+ *
+ * @param input Professional identity source values.
+ */
+export declare function getProfessionalIdentityVC(input: ProfessionalEmployeeCredentialInput): Record<string, unknown>;
+/**
+ * Backwards-compatible alias kept for existing SMART demo callers.
+ *
+ * @param input Professional identity source values.
+ */
 export declare function buildProfessionalEmployeeCredential(input: ProfessionalEmployeeCredentialInput): Record<string, unknown>;
+/**
+ * Builds one SMART/OpenID4VP payload for the current professional identity
+ * contract.
+ *
+ * When no credential is supplied explicitly, the payload embeds the canonical
+ * professional identity VC built from the current actor identity input.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ */
 export declare function buildProfessionalSmartVpPayload(input: ProfessionalSmartVpPayloadInput): Record<string, unknown>;
+/**
+ * Alias that makes the VC/VP naming more explicit for consumers that want one
+ * identity-oriented surface rather than the historical SMART-specific helper
+ * names.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ */
+export declare function buildProfessionalIdentityVpPayload(input: ProfessionalSmartVpPayloadInput): Record<string, unknown>;
+/**
+ * Builds one unsigned compact VP JWT for the canonical professional identity
+ * payload.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ * @param options Optional unsigned JWT timing controls.
+ */
 export declare function buildUnsignedProfessionalSmartVpJwt(input: ProfessionalSmartVpPayloadInput, options?: Readonly<{
     nowSeconds?: number;
     ttlSeconds?: number;
     nonce?: string;
 }>): string;
+/**
+ * Alias that makes the unsigned identity VP helper explicit for shared SDK
+ * facades.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ * @param options Optional unsigned JWT timing controls.
+ */
+export declare function buildUnsignedProfessionalIdentityVpJwt(input: ProfessionalSmartVpPayloadInput, options?: Readonly<{
+    nowSeconds?: number;
+    ttlSeconds?: number;
+    nonce?: string;
+}>): string;

package/dist/utils/professional-smart.js

@@ -1,27 +1,114 @@
+import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
 import { ProfessionalCredentialTypes, W3cCredentialTypes, } from '../constants/verifiable-credentials.js';
+import { normalizeSameAsHashCsv, normalizeSameAsHashList, normalizeTelephoneHash } from './same-as.js';
 import { buildUnsignedVpJwt } from './jwt.js';
-export function buildProfessionalEmployeeCredential(input) {
+/**
+ * Returns the normalized public continuity aliases for one professional
+ * identity VC.
+ *
+ * The canonical source is:
+ * - explicit `sameAs` values when present
+ * - otherwise the public employee email
+ *
+ * When both are present they are merged and deduplicated after normalization.
+ *
+ * @param input Professional identity source values.
+ */
+export function getProfessionalIdentitySameAs(input) {
+    const sameAsCandidates = [];
+    if (input.sameAs) {
+        sameAsCandidates.push(...normalizeSameAsHashList(input.sameAs));
+    }
+    if (input.email) {
+        sameAsCandidates.push(...normalizeSameAsHashList(input.email));
+    }
+    return [...new Set(sameAsCandidates)];
+}
+/**
+ * Returns the normalized public telephone continuity value for one
+ * professional identity VC.
+ *
+ * Telephone continuity is kept separate from `sameAs` so callers can reuse
+ * ICA-compatible hashing without overloading the public alias slot.
+ *
+ * @param input Professional identity source values.
+ */
+export function getProfessionalIdentityTelephone(input) {
+    const normalized = normalizeTelephoneHash(String(input.telephone || ''));
+    return normalized || undefined;
+}
+/**
+ * Builds the canonical professional identity VC payload reused by SMART VP
+ * token helpers and higher SDK facades.
+ *
+ * Current projection rules:
+ * - `credentialSubject.sameAs` stores one CSV string to preserve compatibility
+ *   with the current flat/shared claim style
+ * - `credentialSubject.telephone` stores the hashed public phone continuity
+ *   value when present
+ * - `credentialSubject.hasCredential.material` carries the public signing/bind
+ *   material when present
+ *
+ * @param input Professional identity source values.
+ */
+export function getProfessionalIdentityVC(input) {
+    const normalizedSameAs = getProfessionalIdentitySameAs(input);
+    const normalizedTelephone = getProfessionalIdentityTelephone(input);
+    const normalizedCredentialMaterial = String(input.credentialMaterial || '').trim();
+    const canonicalCredentialSubject = {
+        id: String(input.actorDid || '').trim(),
+        hasOccupation: String(input.role || '').trim(),
+        ...(normalizedSameAs.length
+            ? { sameAs: normalizeSameAsHashCsv(normalizedSameAs) }
+            : {}),
+        ...(normalizedTelephone
+            ? { [ClaimsPersonSchemaorg.telephone]: normalizedTelephone }
+            : {}),
+        ...(normalizedCredentialMaterial
+            ? { [ClaimsPersonSchemaorg.hasCredentialMaterial]: normalizedCredentialMaterial }
+            : {}),
+    };
     return {
         type: [
             W3cCredentialTypes.VerifiableCredential,
             ProfessionalCredentialTypes.EmployeeCredential,
         ],
         credentialSubject: {
-            id: String(input.actorDid || '').trim(),
-            hasOccupation: String(input.role || '').trim(),
+            ...canonicalCredentialSubject,
             ...(input.additionalCredentialSubject || {}),
         },
         ...(input.additionalCredential || {}),
     };
 }
+/**
+ * Backwards-compatible alias kept for existing SMART demo callers.
+ *
+ * @param input Professional identity source values.
+ */
+export function buildProfessionalEmployeeCredential(input) {
+    return getProfessionalIdentityVC(input);
+}
+/**
+ * Builds one SMART/OpenID4VP payload for the current professional identity
+ * contract.
+ *
+ * When no credential is supplied explicitly, the payload embeds the canonical
+ * professional identity VC built from the current actor identity input.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ */
 export function buildProfessionalSmartVpPayload(input) {
     const credentials = Array.isArray(input.verifiableCredential)
         ? [...input.verifiableCredential]
         : input.verifiableCredential
             ? [input.verifiableCredential]
-            : [buildProfessionalEmployeeCredential({
+            : [getProfessionalIdentityVC({
                     actorDid: input.actorDid,
                     role: input.role,
+                    email: input.email,
+                    sameAs: input.sameAs,
+                    telephone: input.telephone,
+                    credentialMaterial: input.credentialMaterial,
                 })];
     return {
         ...(input.additionalPayload || {}),
@@ -32,6 +119,33 @@ export function buildProfessionalSmartVpPayload(input) {
         },
     };
 }
+/**
+ * Alias that makes the VC/VP naming more explicit for consumers that want one
+ * identity-oriented surface rather than the historical SMART-specific helper
+ * names.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ */
+export function buildProfessionalIdentityVpPayload(input) {
+    return buildProfessionalSmartVpPayload(input);
+}
+/**
+ * Builds one unsigned compact VP JWT for the canonical professional identity
+ * payload.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ * @param options Optional unsigned JWT timing controls.
+ */
 export function buildUnsignedProfessionalSmartVpJwt(input, options = {}) {
     return buildUnsignedVpJwt(buildProfessionalSmartVpPayload(input), options);
 }
+/**
+ * Alias that makes the unsigned identity VP helper explicit for shared SDK
+ * facades.
+ *
+ * @param input SMART/OpenID4VP actor payload input.
+ * @param options Optional unsigned JWT timing controls.
+ */
+export function buildUnsignedProfessionalIdentityVpJwt(input, options = {}) {
+    return buildUnsignedProfessionalSmartVpJwt(input, options);
+}

package/dist/utils/related-person-list.d.ts

@@ -2,11 +2,15 @@ export type RelatedPersonListRecord = Readonly<{
     identifier?: string;
     patient?: string;
     relationship?: string;
+    /** Functional `RelatedPerson.role` extension values, separate from kinship. */
+    roles: readonly string[];
     name?: string;
     telecom?: string;
     active?: string;
     status?: string;
     resourceId?: string;
+    relatedEntityType?: string;
+    actorIdentifiers: readonly string[];
     claims: Record<string, unknown>;
 }>;
 export type RelatedPersonListSelection = Readonly<{

package/dist/utils/related-person-list.js

@@ -12,6 +12,17 @@ function extractClaims(entry) {
     const resourceClaims = resourceMeta.claims && typeof resourceMeta.claims === 'object' ? resourceMeta.claims : undefined;
     return { ...(resourceClaims || {}), ...(metaClaims || {}) };
 }
+function readClaim(claims, claimKey) {
+    if (claims[claimKey] !== undefined)
+        return claims[claimKey];
+    const context = normalizeText(claims['@context']);
+    if (context && claims[`${context.replace(/\.$/, '')}.${claimKey}`] !== undefined) {
+        return claims[`${context.replace(/\.$/, '')}.${claimKey}`];
+    }
+    const suffix = `.${claimKey}`;
+    const matchedKey = Object.keys(claims).find((key) => key.endsWith(suffix));
+    return matchedKey ? claims[matchedKey] : undefined;
+}
 /**
  * Reads subject-side relationship records from one current GW-style result
  * body into one neutral list shape for frontend screens.
@@ -29,14 +40,23 @@ export function readRelatedPersonListRecords(body) {
         const meta = entry.meta && typeof entry.meta === 'object' ? entry.meta : {};
         const resource = entry.resource && typeof entry.resource === 'object' ? entry.resource : {};
         return {
-            identifier: normalizeText(claims[RelatedPersonClaim.IdentifierValue] ?? claims[RelatedPersonClaim.Identifier]),
-            patient: normalizeText(claims[RelatedPersonClaim.Patient]),
-            relationship: normalizeText(claims[RelatedPersonClaim.Relationship]),
-            name: normalizeText(claims[RelatedPersonClaim.Name]),
-            telecom: normalizeText(claims[RelatedPersonClaim.Telecom]),
-            active: normalizeText(claims[RelatedPersonClaim.Active]),
+            identifier: normalizeText(readClaim(claims, RelatedPersonClaim.IdentifierValue) ?? readClaim(claims, RelatedPersonClaim.Identifier)),
+            patient: normalizeText(readClaim(claims, RelatedPersonClaim.Patient)),
+            relationship: normalizeText(readClaim(claims, RelatedPersonClaim.Relationship)),
+            roles: String(readClaim(claims, RelatedPersonClaim.Role) ?? '')
+                .split(',')
+                .map((value) => value.trim().toUpperCase())
+                .filter(Boolean),
+            name: normalizeText(readClaim(claims, RelatedPersonClaim.Name)),
+            telecom: normalizeText(readClaim(claims, RelatedPersonClaim.Telecom)),
+            active: normalizeText(readClaim(claims, RelatedPersonClaim.Active)),
             status: normalizeText(meta.status),
             resourceId: normalizeText(resource.id || entry.id),
+            relatedEntityType: normalizeText(readClaim(claims, RelatedPersonClaim.RelatedEntityType)),
+            actorIdentifiers: String(readClaim(claims, RelatedPersonClaim.ActorIdentifier) ?? '')
+                .split(',')
+                .map((value) => value.trim())
+                .filter(Boolean),
             claims,
         };
     });

package/dist/utils/same-as.d.ts

@@ -32,6 +32,46 @@ export declare function multibase58MultihashSha3_256(value: string): string;
  * @param value Email, phone, DID, URN, or any other public alias string.
  */
 export declare function normalizeSameAsHash(value: string): string;
+/**
+ * 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 declare function normalizeSameAsHashList(value: string | readonly string[] | undefined): string[];
+/**
+ * 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 declare function normalizeSameAsHashCsv(value: string | readonly string[] | undefined): string;
+/**
+ * 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 declare function normalizeTelephoneHash(value: string): string;
 /**
  * Compares two public controller aliases after ICA-compatible normalization.
  *

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