gdc-common-utils-ts 2.0.18 → 2.2.2

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/profile-manager-mem.d.ts

@@ -0,0 +1,69 @@
+import type { IWallet } from '../interfaces/IWallet';
+import type { IProfileOutboxRepository } from '../interfaces/IProfileOutboxRepository';
+import type { BackendMessageResponseRecord, BackendMessageTransport, ProfileOutboxMessageRecord, ProfileManagerMemProfile, QueueProfileMessageInput } from '../models/profile-manager';
+import type { WalletQueuedMessage } from '../models/wallet';
+import { BackendMessageManagerMem } from './backend-message-manager-mem';
+export type ProfileManagerMemOptions = Readonly<{
+    profile: ProfileManagerMemProfile;
+    wallet: IWallet;
+    transport: BackendMessageTransport;
+    outboxRepository?: IProfileOutboxRepository;
+}>;
+/**
+ * Minimal memory-backed profile manager for low-level tests.
+ *
+ * Responsibility:
+ * - own one logical profile
+ * - ensure the profile keys exist in the wallet
+ * - delegate queue/submit/response operations to `BackendMessageManagerMem`
+ *
+ * Non-goal:
+ * - actor-specific orchestration belongs to higher SDK layers
+ */
+export declare class ProfileManagerMem {
+    readonly profile: ProfileManagerMemProfile;
+    readonly wallet: IWallet;
+    readonly messageManager: BackendMessageManagerMem;
+    readonly outboxRepository: IProfileOutboxRepository;
+    constructor(options: ProfileManagerMemOptions);
+    /**
+     * Provisions the local profile keys before any queue or transport operation.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Queues one outbound profile payload.
+     */
+    queueMessage(input: QueueProfileMessageInput): Promise<WalletQueuedMessage>;
+    /**
+     * Returns the current queued messages in processing order.
+     */
+    listQueuedMessages(): Promise<WalletQueuedMessage[]>;
+    /**
+     * Submits the next pending message and optionally stores the decoded response.
+     */
+    submitNextPendingMessage(recipientEncryptionJwk: Record<string, unknown>): Promise<{
+        message: WalletQueuedMessage;
+        response?: BackendMessageResponseRecord;
+        pending?: boolean;
+    }>;
+    /**
+     * Reads the latest decoded response for one thread id.
+     */
+    getResponseByThreadId(thid: string): BackendMessageResponseRecord | undefined;
+    /**
+     * Reads one decoded response by thread id from memory or repository storage.
+     */
+    readResponseByThreadId(thid: string): Promise<BackendMessageResponseRecord | undefined>;
+    /**
+     * Lists historical outbox records already submitted through this profile manager.
+     */
+    listOutboxHistory(): Promise<ProfileOutboxMessageRecord[]>;
+    /**
+     * Polls one asynchronous outbox record by id.
+     */
+    pollSubmittedMessage(messageId: string): Promise<{
+        pending: boolean;
+        response?: BackendMessageResponseRecord;
+        record: ProfileOutboxMessageRecord;
+    }>;
+}

package/dist/utils/profile-manager-mem.js

@@ -0,0 +1,79 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { BackendMessageManagerMem } from './backend-message-manager-mem.js';
+import { MemoryProfileOutboxRepository } from './profile-outbox-memory-repository.js';
+/**
+ * Minimal memory-backed profile manager for low-level tests.
+ *
+ * Responsibility:
+ * - own one logical profile
+ * - ensure the profile keys exist in the wallet
+ * - delegate queue/submit/response operations to `BackendMessageManagerMem`
+ *
+ * Non-goal:
+ * - actor-specific orchestration belongs to higher SDK layers
+ */
+export class ProfileManagerMem {
+    profile;
+    wallet;
+    messageManager;
+    outboxRepository;
+    constructor(options) {
+        this.profile = options.profile;
+        this.wallet = options.wallet;
+        this.outboxRepository = options.outboxRepository ?? new MemoryProfileOutboxRepository();
+        this.messageManager = new BackendMessageManagerMem({
+            wallet: options.wallet,
+            entityId: options.profile.profileId,
+            transport: options.transport,
+            outboxRepository: this.outboxRepository,
+        });
+    }
+    /**
+     * Provisions the local profile keys before any queue or transport operation.
+     */
+    async initialize() {
+        await this.wallet.provisionKeys(this.profile.profileId);
+    }
+    /**
+     * Queues one outbound profile payload.
+     */
+    async queueMessage(input) {
+        return this.messageManager.queueMessage(input);
+    }
+    /**
+     * Returns the current queued messages in processing order.
+     */
+    async listQueuedMessages() {
+        return this.messageManager.listQueuedMessages();
+    }
+    /**
+     * Submits the next pending message and optionally stores the decoded response.
+     */
+    async submitNextPendingMessage(recipientEncryptionJwk) {
+        return this.messageManager.submitNextPendingMessage(recipientEncryptionJwk);
+    }
+    /**
+     * Reads the latest decoded response for one thread id.
+     */
+    getResponseByThreadId(thid) {
+        return this.messageManager.getResponseByThreadId(thid);
+    }
+    /**
+     * Reads one decoded response by thread id from memory or repository storage.
+     */
+    async readResponseByThreadId(thid) {
+        return this.messageManager.readResponseByThreadId(thid);
+    }
+    /**
+     * Lists historical outbox records already submitted through this profile manager.
+     */
+    async listOutboxHistory() {
+        return this.messageManager.listOutboxHistory();
+    }
+    /**
+     * Polls one asynchronous outbox record by id.
+     */
+    async pollSubmittedMessage(messageId) {
+        return this.messageManager.pollSubmittedMessage(messageId);
+    }
+}

package/dist/utils/profile-outbox-memory-repository.d.ts

@@ -0,0 +1,34 @@
+import type { IProfileOutboxRepository } from '../interfaces/IProfileOutboxRepository';
+import type { BackendMessageResponseRecord, ProfileOutboxMessageRecord } from '../models/profile-manager';
+/**
+ * In-memory profile outbox repository used by low-level tests and as the
+ * default history/response store for `ProfileManagerMem`.
+ */
+export declare class MemoryProfileOutboxRepository implements IProfileOutboxRepository {
+    private readonly messages;
+    private readonly responses;
+    /**
+     * Stores one immutable message history record.
+     */
+    putMessage(record: ProfileOutboxMessageRecord): Promise<ProfileOutboxMessageRecord>;
+    /**
+     * Reads one message history record.
+     */
+    getMessage(messageId: string): Promise<ProfileOutboxMessageRecord | undefined>;
+    /**
+     * Lists all message history records in insertion order.
+     */
+    listMessages(): Promise<ProfileOutboxMessageRecord[]>;
+    /**
+     * Stores one decoded response record grouped by thread id.
+     */
+    putResponse(record: BackendMessageResponseRecord): Promise<BackendMessageResponseRecord>;
+    /**
+     * Returns the latest decoded response for the provided thread id.
+     */
+    getLatestResponseByThreadId(thid: string): Promise<BackendMessageResponseRecord | undefined>;
+    /**
+     * Lists all decoded responses across all threads.
+     */
+    listResponses(): Promise<BackendMessageResponseRecord[]>;
+}

package/dist/utils/profile-outbox-memory-repository.js

@@ -0,0 +1,57 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * In-memory profile outbox repository used by low-level tests and as the
+ * default history/response store for `ProfileManagerMem`.
+ */
+export class MemoryProfileOutboxRepository {
+    messages = new Map();
+    responses = new Map();
+    /**
+     * Stores one immutable message history record.
+     */
+    async putMessage(record) {
+        this.messages.set(record.id, clone(record));
+        return clone(record);
+    }
+    /**
+     * Reads one message history record.
+     */
+    async getMessage(messageId) {
+        const stored = this.messages.get(String(messageId || '').trim());
+        return stored ? clone(stored) : undefined;
+    }
+    /**
+     * Lists all message history records in insertion order.
+     */
+    async listMessages() {
+        return [...this.messages.values()].map((record) => clone(record));
+    }
+    /**
+     * Stores one decoded response record grouped by thread id.
+     */
+    async putResponse(record) {
+        const normalizedThreadId = String(record.thid || '').trim();
+        const current = this.responses.get(normalizedThreadId) || [];
+        current.push(clone(record));
+        this.responses.set(normalizedThreadId, current);
+        return clone(record);
+    }
+    /**
+     * Returns the latest decoded response for the provided thread id.
+     */
+    async getLatestResponseByThreadId(thid) {
+        const stored = this.responses.get(String(thid || '').trim());
+        const latest = stored?.[stored.length - 1];
+        return latest ? clone(latest) : undefined;
+    }
+    /**
+     * Lists all decoded responses across all threads.
+     */
+    async listResponses() {
+        return [...this.responses.values()]
+            .flatMap((records) => records.map((record) => clone(record)));
+    }
+}

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