gdc-common-utils-ts 2.1.0 → 2.2.2

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[];
+}

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

@@ -0,0 +1,75 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor.js';
+import { ProcedureClaim } from '../models/interoperable-claims/procedure-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * 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 class ProcedureEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical procedure identifier. */
+    setIdentifier(identifier) { return this.setIdentifierValue(ProcedureClaim.Identifier, identifier); }
+    /** Reads the canonical procedure identifier. */
+    getIdentifier() { return this.getIdentifierValue(ProcedureClaim.Identifier); }
+    /** Ensures the procedure entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier() { return this.ensureIdentifierValue(ProcedureClaim.Identifier); }
+    /** Writes the subject/patient reference. */
+    setSubject(subject) { return this.setSubjectClaims(ProcedureClaim.Subject, ProcedureClaim.Patient, subject); }
+    /** Reads the subject/patient reference. */
+    getSubject() { return this.getSubjectClaims(ProcedureClaim.Subject, ProcedureClaim.Patient); }
+    /** Writes the procedure status. */
+    setStatus(status) { return this.setScalarClaim(ProcedureClaim.Status, status); }
+    /** Reads the procedure status. */
+    getStatus() { return this.getScalarClaim(ProcedureClaim.Status); }
+    /** Writes the procedure date. */
+    setDate(date) { return this.setScalarClaim(ProcedureClaim.Date, date); }
+    /** Reads the procedure date. */
+    getDate() { return this.getScalarClaim(ProcedureClaim.Date); }
+    /** Writes the procedure code. */
+    setCode(code) { return this.setScalarClaim(ProcedureClaim.Code, code); }
+    /** Reads the procedure code. */
+    getCode() { return this.getScalarClaim(ProcedureClaim.Code); }
+    /** Writes the local code text. */
+    setCodeTextLocal(text) { return this.setScalarClaim(ProcedureClaim.CodeText, text); }
+    /** Reads the local code text. */
+    getCodeTextLocal() { return this.getScalarClaim(ProcedureClaim.CodeText); }
+    /** Writes the code display text. */
+    setCodeDisplay(display) { return this.setScalarClaim(ProcedureClaim.CodeDisplay, display); }
+    /** Reads the code display text. */
+    getCodeDisplay() { return this.getScalarClaim(ProcedureClaim.CodeDisplay); }
+    /** Writes the encounter reference. */
+    setEncounter(reference) { return this.setScalarClaim(ProcedureClaim.Encounter, reference); }
+    /** Reads the encounter reference. */
+    getEncounter() { return this.getScalarClaim(ProcedureClaim.Encounter); }
+    /** Writes the location reference. */
+    setLocation(reference) { return this.setScalarClaim(ProcedureClaim.Location, reference); }
+    /** Reads the location reference. */
+    getLocation() { return this.getScalarClaim(ProcedureClaim.Location); }
+    /** Writes the reason code. */
+    setReasonCode(code) { return this.setScalarClaim(ProcedureClaim.ReasonCode, code); }
+    /** Reads the reason code. */
+    getReasonCode() { return this.getScalarClaim(ProcedureClaim.ReasonCode); }
+    /** Writes the note text. */
+    setNote(note) { return this.setScalarClaim(ProcedureClaim.Note, note); }
+    /** Reads the note text. */
+    getNote() { return this.getScalarClaim(ProcedureClaim.Note); }
+    /** Alias for `setNote(...)` used by callers that expect clinical wording. */
+    setClinicalNote(note) { return this.setNote(note); }
+    /** Alias for `getNote()` used by callers that expect clinical wording. */
+    getClinicalNote() { return this.getNote(); }
+    /** Writes the performer list. */
+    setPerformerList(references) { return this.setCsvClaimList(ProcedureClaim.Performer, references); }
+    /** Reads the performer list. */
+    getPerformerList() { return this.getCsvClaimList(ProcedureClaim.Performer); }
+    /** Writes the based-on list. */
+    setBasedOnList(references) { return this.setCsvClaimList(ProcedureClaim.BasedOn, references); }
+    /** Reads the based-on list. */
+    getBasedOnList() { return this.getCsvClaimList(ProcedureClaim.BasedOn); }
+    /** Writes the reason-reference list. */
+    setReasonReferenceList(references) { return this.setCsvClaimList(ProcedureClaim.ReasonReference, references); }
+    /** Reads the reason-reference list. */
+    getReasonReferenceList() { return this.getCsvClaimList(ProcedureClaim.ReasonReference); }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.procedure, ProcedureEntryEditor);

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