gdc-common-utils-ts 2.0.17 → 2.1.0

package/dist/utils/communication-consent-access-editor.d.ts

@@ -0,0 +1,85 @@
+import { type HealthcareActorRoleDescriptor, type HealthcareSectionDescriptor } from '../constants/healthcare';
+import type { DataspaceSector } from '../constants/sectors';
+import type { CommunicationAttachedBundleSessionOptions, ConsentEditorClassifiedActors, ConsentEditorClassifiedPurpose, ConsentEditorClassifiedRoles, ConsentEditorClassifiedTarget, ConsentViewModel } from '../models/communication-attached-bundle-session';
+import type { ConsentDuplicateRuleConflict } from './consent-duplicate-rules';
+import { CommunicationAttachedBundleSession } from './communication-attached-bundle-session';
+/**
+ * High-level consent-access editor alias for onboarding and app-facing code.
+ *
+ * This keeps the business intent explicit for developers who are editing
+ * Consent access rules inside a Communication-carried bundle and should not
+ * need to start from the lower-level generic session name.
+ */
+export declare class ConsentAccessEditor extends CommunicationAttachedBundleSession {
+    /** Returns duplicate atomic consent-rule conflicts across the current bundle. */
+    getConsentRuleDuplicateConflicts(): ConsentDuplicateRuleConflict[];
+    /** Returns duplicate atomic consent-rule conflicts affecting the active Consent entry. */
+    getActiveConsentRuleDuplicateConflicts(): ConsentDuplicateRuleConflict[];
+    /** Returns one frontend-facing editable view model for the active Consent entry. */
+    getConsentViewModel(): ConsentViewModel;
+    /** Applies one frontend-facing editable view model back into the active Consent entry. */
+    applyConsentViewModel(viewModel: ConsentViewModel): this;
+    /** Returns the canonical permit/deny decision from the active Consent entry. */
+    getDecision(): string;
+    /** @deprecated Use `getDecision()`. */
+    getPermit(): string;
+    /** Returns target classification derived from the current consent claim contract. */
+    getTargetsClassified(): ConsentEditorClassifiedTarget[];
+    getCoreSectionOptions(): readonly ConsentEditorClassifiedTarget[];
+    getCoreSectionCatalog(): Readonly<Record<string, HealthcareSectionDescriptor>>;
+    getKindOfDocumentOptions(): readonly ConsentEditorClassifiedTarget[];
+    getKindOfDocumentCatalog(): Readonly<Record<string, HealthcareSectionDescriptor>>;
+    getTypeOfServiceOptions(): readonly ConsentEditorClassifiedTarget[];
+    getTypeOfServiceCatalog(): Readonly<Record<string, HealthcareSectionDescriptor>>;
+    getSubjectMatterDomainOptions(): readonly ConsentEditorClassifiedTarget[];
+    getSubjectMatterDomainCatalog(): Readonly<Record<string, HealthcareSectionDescriptor>>;
+    getResourceTypeOptions(): readonly ConsentEditorClassifiedTarget[];
+    getResourceTypeCatalog(): readonly string[];
+    getAvailableProfessionalRolesBySector(sector: DataspaceSector): Readonly<Record<string, HealthcareActorRoleDescriptor>>;
+    getAvailableRelationshipRoles(): Readonly<Record<string, HealthcareActorRoleDescriptor>>;
+    getSelectedCoreSections(): string[];
+    getSelectedKindOfDocuments(): string[];
+    getSelectedTypeOfServices(): string[];
+    getSelectedSubjectMatterDomains(): string[];
+    getSelectedResourceTypes(): string[];
+    setSelectedCoreSections(codes: readonly string[]): this;
+    setSelectedKindOfDocuments(codes: readonly string[]): this;
+    setSelectedTypeOfServices(codes: readonly string[]): this;
+    setSelectedSubjectMatterDomains(codes: readonly string[]): this;
+    setSelectedResourceTypes(codes: readonly string[]): this;
+    addCoreSections(codes: readonly string[]): this;
+    removeCoreSections(codes: readonly string[]): this;
+    addKindOfDocuments(codes: readonly string[]): this;
+    removeKindOfDocuments(codes: readonly string[]): this;
+    addTypeOfServices(codes: readonly string[]): this;
+    removeTypeOfServices(codes: readonly string[]): this;
+    addSubjectMatterDomains(codes: readonly string[]): this;
+    removeSubjectMatterDomains(codes: readonly string[]): this;
+    addResourceTypes(codes: readonly string[]): this;
+    removeResourceTypes(codes: readonly string[]): this;
+    getPurposesClassified(): ConsentEditorClassifiedPurpose[];
+    getSelectedPurposes(): string[];
+    setSelectedPurposes(codes: readonly string[]): this;
+    addPurposes(codes: readonly string[]): this;
+    removePurposes(codes: readonly string[]): this;
+    getRolesClassified(): ConsentEditorClassifiedRoles;
+    getSelectedRoles(): string[];
+    setSelectedRoles(codes: readonly string[]): this;
+    addRoles(codes: readonly string[]): this;
+    removeRoles(codes: readonly string[]): this;
+    getActorsClassified(): ConsentEditorClassifiedActors;
+    private getSelectedSectionCodesByFamily;
+    private setSelectedSectionCodesByFamily;
+    private addSectionCodesByFamily;
+    private removeSectionCodesByFamily;
+    private setActiveEntryClaimList;
+    private addActiveEntryClaimList;
+    private removeActiveEntryClaimList;
+}
+/**
+ * High-level factory for consent-access editing.
+ *
+ * Prefer this name in onboarding docs when the developer intent is:
+ * "edit a Consent access bundle carried by a Communication".
+ */
+export declare function createConsentAccessEditor(options?: CommunicationAttachedBundleSessionOptions): ConsentAccessEditor;

package/dist/utils/communication-consent-access-editor.js

@@ -0,0 +1,244 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { getHealthcareProfessionalRolesBySector, getHealthcareRolesByFamily, getHealthcareSectionsByFamily, getHealthcareSectionFamilyByCode, HealthcareRoleFamilies, HealthcareCanonicalSectionFamilies, } from '../constants/healthcare.js';
+import { ClaimConsent } from '../models/consent-rule.js';
+import { ConsentEditorScopeCodes, ConsentEditorTargetKinds, } from '../models/communication-attached-bundle-session.js';
+import { detectDuplicateConsentRuleConflicts } from './consent-duplicate-rules.js';
+import { CommunicationAttachedBundleSession } from './communication-attached-bundle-session.js';
+import { asTrimmedString, buildClassifiedConsentTarget, buildConsentViewModel, buildSectionCatalogOptions, classifyConsentActors, classifyConsentPurposes, classifyConsentRoles, classifyConsentTargetsFromClaims, CSV_SEPARATOR, flattenClassifiedActors, flattenClassifiedRoles, flattenClassifiedTargets, normalizeCsvValues, splitCsv, } from './communication-attached-bundle-session-helpers.js';
+/**
+ * High-level consent-access editor alias for onboarding and app-facing code.
+ *
+ * This keeps the business intent explicit for developers who are editing
+ * Consent access rules inside a Communication-carried bundle and should not
+ * need to start from the lower-level generic session name.
+ */
+export class ConsentAccessEditor extends CommunicationAttachedBundleSession {
+    /** Returns duplicate atomic consent-rule conflicts across the current bundle. */
+    getConsentRuleDuplicateConflicts() {
+        return detectDuplicateConsentRuleConflicts(this.getBundleInMemory().data);
+    }
+    /** Returns duplicate atomic consent-rule conflicts affecting the active Consent entry. */
+    getActiveConsentRuleDuplicateConflicts() {
+        const activeEntryIndex = this.getActiveEntryIndex();
+        if (activeEntryIndex === null) {
+            return [];
+        }
+        return this.getConsentRuleDuplicateConflicts()
+            .filter((conflict) => conflict.affectedEntries.some((entry) => entry.entryIndex === activeEntryIndex));
+    }
+    /** Returns one frontend-facing editable view model for the active Consent entry. */
+    getConsentViewModel() {
+        return buildConsentViewModel(this.getActiveEntry(), this.getDecision(), this.getActorsClassified(), this.getRolesClassified(), this.getPurposesClassified(), this.getTargetsClassified());
+    }
+    /** Applies one frontend-facing editable view model back into the active Consent entry. */
+    applyConsentViewModel(viewModel) {
+        this.setActiveEntryClaim(ClaimConsent.identifier, viewModel.identifier);
+        this.setActiveEntryClaim(ClaimConsent.subject, viewModel.subject);
+        this.setActiveEntryClaim(ClaimConsent.decision, viewModel.decision);
+        this.setActiveEntryClaimList(ClaimConsent.actorIdentifier, flattenClassifiedActors(viewModel.classifiedActors));
+        this.setSelectedRoles(flattenClassifiedRoles(viewModel.classifiedRoles));
+        this.setSelectedPurposes(viewModel.classifiedPurposes.map((purpose) => purpose.code));
+        const flattenedTargets = flattenClassifiedTargets(viewModel.classifiedTargets);
+        this.setSelectedCoreSections(flattenedTargets.coreSections);
+        this.setSelectedKindOfDocuments(flattenedTargets.kindOfDocuments);
+        this.setSelectedTypeOfServices(flattenedTargets.typeOfServices);
+        this.setSelectedSubjectMatterDomains(flattenedTargets.subjectMatterDomains);
+        this.setSelectedResourceTypes(flattenedTargets.resourceTypes);
+        return this;
+    }
+    /** Returns the canonical permit/deny decision from the active Consent entry. */
+    getDecision() {
+        return asTrimmedString(this.getActiveEntryClaim(ClaimConsent.decision));
+    }
+    /** @deprecated Use `getDecision()`. */
+    getPermit() {
+        return this.getDecision();
+    }
+    /** Returns target classification derived from the current consent claim contract. */
+    getTargetsClassified() {
+        return classifyConsentTargetsFromClaims({
+            ...(this.getActiveEntry()?.resource?.meta?.claims || {}),
+        });
+    }
+    getCoreSectionOptions() {
+        return buildSectionCatalogOptions(HealthcareCanonicalSectionFamilies.CoreSection);
+    }
+    getCoreSectionCatalog() {
+        return getHealthcareSectionsByFamily(HealthcareCanonicalSectionFamilies.CoreSection);
+    }
+    getKindOfDocumentOptions() {
+        return buildSectionCatalogOptions(HealthcareCanonicalSectionFamilies.KindOfDocument);
+    }
+    getKindOfDocumentCatalog() {
+        return getHealthcareSectionsByFamily(HealthcareCanonicalSectionFamilies.KindOfDocument);
+    }
+    getTypeOfServiceOptions() {
+        return buildSectionCatalogOptions(HealthcareCanonicalSectionFamilies.TypeOfService);
+    }
+    getTypeOfServiceCatalog() {
+        return getHealthcareSectionsByFamily(HealthcareCanonicalSectionFamilies.TypeOfService);
+    }
+    getSubjectMatterDomainOptions() {
+        return buildSectionCatalogOptions(HealthcareCanonicalSectionFamilies.SubjectMatterDomain);
+    }
+    getSubjectMatterDomainCatalog() {
+        return getHealthcareSectionsByFamily(HealthcareCanonicalSectionFamilies.SubjectMatterDomain);
+    }
+    getResourceTypeOptions() {
+        return this.getSelectedResourceTypes().map((code) => buildClassifiedConsentTarget(ConsentEditorTargetKinds.ResourceType, code, [ConsentEditorScopeCodes.Read]));
+    }
+    getResourceTypeCatalog() {
+        return Object.values(ResourceTypesFhirR4).filter((resourceType) => resourceType !== ResourceTypesFhirR4.Bundle);
+    }
+    getAvailableProfessionalRolesBySector(sector) {
+        return getHealthcareProfessionalRolesBySector(sector);
+    }
+    getAvailableRelationshipRoles() {
+        return getHealthcareRolesByFamily(HealthcareRoleFamilies.PersonalRelationshipHl7);
+    }
+    getSelectedCoreSections() {
+        return this.getSelectedSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.CoreSection);
+    }
+    getSelectedKindOfDocuments() {
+        return splitCsv(this.getActiveEntryClaim(ClaimConsent.category));
+    }
+    getSelectedTypeOfServices() {
+        return this.getSelectedSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.TypeOfService);
+    }
+    getSelectedSubjectMatterDomains() {
+        return this.getSelectedSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.SubjectMatterDomain);
+    }
+    getSelectedResourceTypes() {
+        return splitCsv(this.getActiveEntryClaim(ClaimConsent.resourceType));
+    }
+    setSelectedCoreSections(codes) {
+        return this.setSelectedSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.CoreSection, codes);
+    }
+    setSelectedKindOfDocuments(codes) {
+        return this.setActiveEntryClaimList(ClaimConsent.category, codes);
+    }
+    setSelectedTypeOfServices(codes) {
+        return this.setSelectedSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.TypeOfService, codes);
+    }
+    setSelectedSubjectMatterDomains(codes) {
+        return this.setSelectedSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.SubjectMatterDomain, codes);
+    }
+    setSelectedResourceTypes(codes) {
+        return this.setActiveEntryClaimList(ClaimConsent.resourceType, codes);
+    }
+    addCoreSections(codes) {
+        return this.addSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.CoreSection, codes);
+    }
+    removeCoreSections(codes) {
+        return this.removeSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.CoreSection, codes);
+    }
+    addKindOfDocuments(codes) {
+        return this.addActiveEntryClaimList(ClaimConsent.category, codes);
+    }
+    removeKindOfDocuments(codes) {
+        return this.removeActiveEntryClaimList(ClaimConsent.category, codes);
+    }
+    addTypeOfServices(codes) {
+        return this.addSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.TypeOfService, codes);
+    }
+    removeTypeOfServices(codes) {
+        return this.removeSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.TypeOfService, codes);
+    }
+    addSubjectMatterDomains(codes) {
+        return this.addSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.SubjectMatterDomain, codes);
+    }
+    removeSubjectMatterDomains(codes) {
+        return this.removeSectionCodesByFamily(ClaimConsent.action, HealthcareCanonicalSectionFamilies.SubjectMatterDomain, codes);
+    }
+    addResourceTypes(codes) {
+        return this.addActiveEntryClaimList(ClaimConsent.resourceType, codes);
+    }
+    removeResourceTypes(codes) {
+        return this.removeActiveEntryClaimList(ClaimConsent.resourceType, codes);
+    }
+    getPurposesClassified() {
+        return classifyConsentPurposes(this.getSelectedPurposes());
+    }
+    getSelectedPurposes() {
+        return splitCsv(this.getActiveEntryClaim(ClaimConsent.purpose));
+    }
+    setSelectedPurposes(codes) {
+        return this.setActiveEntryClaimList(ClaimConsent.purpose, codes);
+    }
+    addPurposes(codes) {
+        return this.addActiveEntryClaimList(ClaimConsent.purpose, codes);
+    }
+    removePurposes(codes) {
+        return this.removeActiveEntryClaimList(ClaimConsent.purpose, codes);
+    }
+    getRolesClassified() {
+        return classifyConsentRoles(this.getSelectedRoles());
+    }
+    getSelectedRoles() {
+        return splitCsv(this.getActiveEntryClaim(ClaimConsent.actorRole));
+    }
+    setSelectedRoles(codes) {
+        return this.setActiveEntryClaimList(ClaimConsent.actorRole, codes);
+    }
+    addRoles(codes) {
+        return this.addActiveEntryClaimList(ClaimConsent.actorRole, codes);
+    }
+    removeRoles(codes) {
+        return this.removeActiveEntryClaimList(ClaimConsent.actorRole, codes);
+    }
+    getActorsClassified() {
+        const claims = {
+            ...(this.getActiveEntry()?.resource?.meta?.claims || {}),
+        };
+        return classifyConsentActors(splitCsv(claims[ClaimConsent.actorIdentifier]), splitCsv(claims[ClaimConsent.actorRole])[0] || '');
+    }
+    getSelectedSectionCodesByFamily(claimKey, family) {
+        return splitCsv(this.getActiveEntryClaim(claimKey))
+            .filter((code) => getHealthcareSectionFamilyByCode(code) === family);
+    }
+    setSelectedSectionCodesByFamily(claimKey, family, codes) {
+        const preserved = splitCsv(this.getActiveEntryClaim(claimKey))
+            .filter((code) => getHealthcareSectionFamilyByCode(code) !== family);
+        return this.setActiveEntryClaimList(claimKey, [...preserved, ...codes]);
+    }
+    addSectionCodesByFamily(claimKey, family, codes) {
+        const next = [...this.getSelectedSectionCodesByFamily(claimKey, family), ...codes];
+        return this.setSelectedSectionCodesByFamily(claimKey, family, next);
+    }
+    removeSectionCodesByFamily(claimKey, family, codes) {
+        const codesToRemove = new Set(normalizeCsvValues(codes));
+        const next = this.getSelectedSectionCodesByFamily(claimKey, family)
+            .filter((code) => !codesToRemove.has(code));
+        return this.setSelectedSectionCodesByFamily(claimKey, family, next);
+    }
+    setActiveEntryClaimList(key, values) {
+        const normalized = normalizeCsvValues(values);
+        if (normalized.length === 0) {
+            return this.removeActiveEntryClaim(key);
+        }
+        return this.setActiveEntryClaim(key, normalized.join(CSV_SEPARATOR));
+    }
+    addActiveEntryClaimList(key, values) {
+        const next = normalizeCsvValues([
+            ...splitCsv(this.getActiveEntryClaim(key)),
+            ...values,
+        ]);
+        return this.setActiveEntryClaimList(key, next);
+    }
+    removeActiveEntryClaimList(key, values) {
+        const valuesToRemove = new Set(normalizeCsvValues(values));
+        const next = splitCsv(this.getActiveEntryClaim(key))
+            .filter((value) => !valuesToRemove.has(value));
+        return this.setActiveEntryClaimList(key, next);
+    }
+}
+/**
+ * High-level factory for consent-access editing.
+ *
+ * Prefer this name in onboarding docs when the developer intent is:
+ * "edit a Consent access bundle carried by a Communication".
+ */
+export function createConsentAccessEditor(options = {}) {
+    return new ConsentAccessEditor(options);
+}

package/dist/utils/communication-didcomm-payload.d.ts

@@ -0,0 +1,33 @@
+import type { IDecodedDidcommPayload } from '../models/confidential-message';
+export declare const CommunicationDidcommEntryTypes: Readonly<{
+    readonly AttachedBundle: "Communication-attached-bundle-v1.0";
+}>;
+/**
+ * Input contract for wrapping canonical Communication claims as one low-level
+ * DIDComm-style batch payload.
+ */
+export type BuildDidcommPayloadFromCommunicationClaimsInput = Readonly<{
+    communicationClaims: Record<string, unknown>;
+    iss: string;
+    aud: string;
+    jti: string;
+    thid: string;
+    entryType?: string;
+}>;
+/**
+ * Builds the low-level DIDComm-style batch payload that carries one FHIR-like
+ * `Communication` resource authored from canonical communication claims.
+ *
+ * This helper intentionally stays below actor-specific SDK facades so frontend,
+ * BFF, and GW-like tests can reuse the same wrapping contract.
+ */
+export declare function buildDidcommPayloadFromCommunicationClaims(input: BuildDidcommPayloadFromCommunicationClaimsInput): IDecodedDidcommPayload;
+/**
+ * Reads canonical communication claims from the first `body.data[]` entry of
+ * one DIDComm-style payload.
+ */
+export declare function getFirstCommunicationClaimsFromDidcommPayload(payload: IDecodedDidcommPayload): Record<string, unknown>;
+/**
+ * Decodes the attached bundle carried in `Communication.content-attachment-data`.
+ */
+export declare function decodeAttachedBundleFromCommunicationClaims(communicationClaims: Record<string, unknown>): Record<string, unknown>;

package/dist/utils/communication-didcomm-payload.js

@@ -0,0 +1,75 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
+import { transformCommunicationClaimsToResourceFhirR4 } from './communication-fhir-r4.js';
+export const CommunicationDidcommEntryTypes = Object.freeze({
+    AttachedBundle: 'Communication-attached-bundle-v1.0',
+});
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Builds the low-level DIDComm-style batch payload that carries one FHIR-like
+ * `Communication` resource authored from canonical communication claims.
+ *
+ * This helper intentionally stays below actor-specific SDK facades so frontend,
+ * BFF, and GW-like tests can reuse the same wrapping contract.
+ */
+export function buildDidcommPayloadFromCommunicationClaims(input) {
+    const claims = clone(input.communicationClaims);
+    const transformed = transformCommunicationClaimsToResourceFhirR4([claims], {
+        mode: 'strict',
+    });
+    const communicationResource = transformed.resources[0] || {};
+    return {
+        iss: String(input.iss || '').trim(),
+        aud: String(input.aud || '').trim(),
+        jti: String(input.jti || '').trim(),
+        thid: String(input.thid || '').trim(),
+        type: CommunicationDidcommEntryTypes.AttachedBundle,
+        body: {
+            data: [
+                {
+                    id: String(claims[CommunicationClaim.Identifier] || input.jti || '').trim(),
+                    type: String(input.entryType || CommunicationDidcommEntryTypes.AttachedBundle).trim(),
+                    meta: {
+                        claims,
+                    },
+                    resource: communicationResource,
+                },
+            ],
+        },
+    };
+}
+/**
+ * Reads canonical communication claims from the first `body.data[]` entry of
+ * one DIDComm-style payload.
+ */
+export function getFirstCommunicationClaimsFromDidcommPayload(payload) {
+    const first = Array.isArray(payload?.body?.data) ? payload.body.data[0] : undefined;
+    const metaClaims = first?.meta && typeof first.meta === 'object'
+        ? first.meta['claims']
+        : undefined;
+    if (metaClaims && typeof metaClaims === 'object') {
+        return clone(metaClaims);
+    }
+    const resource = first?.resource && typeof first.resource === 'object'
+        ? first.resource
+        : {};
+    const meta = resource.meta && typeof resource.meta === 'object'
+        ? resource.meta
+        : {};
+    const claims = meta.claims && typeof meta.claims === 'object'
+        ? meta.claims
+        : {};
+    return clone(claims);
+}
+/**
+ * Decodes the attached bundle carried in `Communication.content-attachment-data`.
+ */
+export function decodeAttachedBundleFromCommunicationClaims(communicationClaims) {
+    const encoded = String(communicationClaims[CommunicationClaim.ContentAttachmentData] || '').trim();
+    if (!encoded) {
+        throw new Error(`decodeAttachedBundleFromCommunicationClaims requires ${CommunicationClaim.ContentAttachmentData}.`);
+    }
+    return JSON.parse(Buffer.from(encoded, 'base64').toString('utf8'));
+}

package/dist/utils/evidence-blockchain-references.d.ts

@@ -4,6 +4,8 @@ import type { EvidenceObjectDLT } from '../models/oidc4ida.evidence.model.js';
  *
  * Current shared rule:
  * - `z...` multibase base58 references are already public and stable
+ * - `sha3-384:...` references are already blockchain-safe and must pass
+ *   through unchanged
  * - any other identifier-like value is SHA3-384 hashed before persistence
  */
 export declare function sanitizeBlockchainReference(value: unknown): string | undefined;

package/dist/utils/evidence-blockchain-references.js

@@ -5,6 +5,8 @@ const SHA3_384_PREFIX = 'sha3-384:';
  *
  * Current shared rule:
  * - `z...` multibase base58 references are already public and stable
+ * - `sha3-384:...` references are already blockchain-safe and must pass
+ *   through unchanged
  * - any other identifier-like value is SHA3-384 hashed before persistence
  */
 export function sanitizeBlockchainReference(value) {
@@ -13,6 +15,8 @@ export function sanitizeBlockchainReference(value) {
         return undefined;
     if (/^z[1-9A-HJ-NP-Za-km-z]+$/.test(normalized))
         return normalized;
+    if (/^sha3-384:[a-f0-9]{96}$/i.test(normalized))
+        return normalized;
     return `${SHA3_384_PREFIX}${createHash('sha3-384').update(normalized, 'utf8').digest('hex')}`;
 }
 /**

package/dist/utils/index.d.ts

@@ -42,6 +42,9 @@ export * from './communication-participant-search';
 export * from './communication-participant-search-test-data';
 export * from './communication-retention-policy';
 export * from './communication-attached-bundle-session';
+export * from './communication-consent-access-editor';
+export * from './bundle-didcomm-payload';
+export * from './communication-didcomm-payload';
 export * from './confidential-storage-persistence';
 export * from './confidential-storage-test-data';
 export * from './permission-templates';
@@ -54,9 +57,11 @@ export * from './fhir-validator';
 export * from './family-registration-test-data';
 export * from './individual-form-pdf';
 export * from './individual-organization-claims';
+export * from './inter-tenant-access-contract';
 export * from './legal-organization-onboarding-editor';
 export * from './organization-lifecycle';
 export * from './organization-did-binding';
+export * from './organization-authorization-urn';
 export * from './individual-organization-lifecycle';
 export * from './individual-onboarding-editor';
 export * from './individual-onboarding-document-reference';
@@ -89,3 +94,8 @@ export * from './service-act-reasons';
 export * from './same-as';
 export * from './activation-request';
 export * from './vp-token';
+export * from './wallet-mem';
+export * from './wallet-memory-queue';
+export * from './profile-outbox-memory-repository';
+export * from './backend-message-manager-mem';
+export * from './profile-manager-mem';

package/dist/utils/index.js

@@ -42,6 +42,9 @@ export * from './communication-participant-search.js';
 export * from './communication-participant-search-test-data.js';
 export * from './communication-retention-policy.js';
 export * from './communication-attached-bundle-session.js';
+export * from './communication-consent-access-editor.js';
+export * from './bundle-didcomm-payload.js';
+export * from './communication-didcomm-payload.js';
 export * from './confidential-storage-persistence.js';
 export * from './confidential-storage-test-data.js';
 export * from './permission-templates.js';
@@ -54,9 +57,11 @@ export * from './fhir-validator.js';
 export * from './family-registration-test-data.js';
 export * from './individual-form-pdf.js';
 export * from './individual-organization-claims.js';
+export * from './inter-tenant-access-contract.js';
 export * from './legal-organization-onboarding-editor.js';
 export * from './organization-lifecycle.js';
 export * from './organization-did-binding.js';
+export * from './organization-authorization-urn.js';
 export * from './individual-organization-lifecycle.js';
 export * from './individual-onboarding-editor.js';
 export * from './individual-onboarding-document-reference.js';
@@ -89,3 +94,8 @@ export * from './service-act-reasons.js';
 export * from './same-as.js';
 export * from './activation-request.js';
 export * from './vp-token.js';
+export * from './wallet-mem.js';
+export * from './wallet-memory-queue.js';
+export * from './profile-outbox-memory-repository.js';
+export * from './backend-message-manager-mem.js';
+export * from './profile-manager-mem.js';

package/dist/utils/inter-tenant-access-contract.d.ts

@@ -0,0 +1,44 @@
+import type { InterTenantAccessContractClaims, InterTenantContractAuthorizationConsentCriteria, InterTenantAccessContractMatchCriteria, InterTenantAccessContractSummary } from '../models/inter-tenant-access-contract';
+import type { VerifiableCredentialV2 } from '../models/verifiable-credential';
+type ContractLike = Record<string, any>;
+export declare function buildInterTenantAccessContractResource(claims: InterTenantAccessContractClaims): ContractLike;
+export declare function buildInterTenantAccessContractCredential(input: Readonly<{
+    claims: InterTenantAccessContractClaims;
+    issuer: string;
+    validFrom: string;
+    validUntil?: string;
+    additionalCredential?: Record<string, unknown>;
+}>): VerifiableCredentialV2;
+export declare function summarizeInterTenantAccessContract(credential: unknown): InterTenantAccessContractSummary | undefined;
+export declare function isInterTenantAccessContractActive(summary: InterTenantAccessContractSummary | undefined, options?: Readonly<{
+    now?: string | Date;
+}>): boolean;
+export declare function matchesInterTenantAccessContract(summary: InterTenantAccessContractSummary | undefined, criteria: InterTenantAccessContractMatchCriteria): boolean;
+export declare function getMatchingInterTenantAccessContractFromVpToken(vpToken: string, criteria: InterTenantAccessContractMatchCriteria): Record<string, unknown> | undefined;
+/**
+ * Returns the public blockchain-safe reference that a reused consent-style
+ * authorization rule should store under `Consent.source-reference` when it
+ * delegates use of one inter-tenant contract VC to an employee/researcher.
+ *
+ * Source-of-truth order:
+ * - VC `id`
+ * - FHIR `Contract.identifier`
+ *
+ * In both cases the reference is normalized through the same blockchain-safe
+ * sanitization rule already used by consent-access assets.
+ */
+export declare function getInterTenantAccessContractBlockchainReference(credential: unknown): string | undefined;
+/**
+ * Evaluates one consent-style rule reused as an organization-to-employee
+ * delegation for inter-tenant contract usage.
+ *
+ * Shared semantic contract:
+ * - `Consent.subject` = consumer organization DID
+ * - `Consent.actor-identifier` = delegated employee/researcher identifier
+ * - `Consent.action` = allowed capabilities/scopes
+ * - `Consent.purpose` = allowed purpose
+ * - `Consent.source-reference` = blockchain-safe hash/reference of the
+ *   underlying contract VC
+ */
+export declare function matchesInterTenantContractAuthorizationConsentRule(rule: Record<string, unknown>, contractCredential: unknown, criteria: InterTenantContractAuthorizationConsentCriteria): boolean;
+export {};