gdc-common-utils-ts 2.0.18 → 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/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';
@@ -91,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';
@@ -91,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/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[]>;
+}