gdc-common-utils-ts 2.0.17 → 2.1.0

package/dist/utils/communication-attached-bundle-session-helpers.d.ts

@@ -0,0 +1,54 @@
+import { type HealthcareCanonicalSectionFamily } from '../constants/healthcare';
+import type { BundleEntry, BundleEntryResource, BundleJsonApi } from '../models/bundle';
+import type { CommunicationAttachedBundleSessionMode, ConsentEditorClassifiedActorRole, ConsentEditorClassifiedActors, ConsentEditorClassifiedOrganization, ConsentEditorClassifiedPurpose, ConsentEditorClassifiedRole, ConsentEditorClassifiedRoles, ConsentEditorClassifiedTarget, ConsentViewModel, ConsentEditorScopeCode, ConsentEditorTargetKind } from '../models/communication-attached-bundle-session';
+export declare const CSV_SEPARATOR = ",";
+export declare function ensureEntryResource(entry: BundleEntry, mode: CommunicationAttachedBundleSessionMode): BundleEntryResource;
+export declare function validateBundleLike(bundle: BundleJsonApi<BundleEntry>, mode: CommunicationAttachedBundleSessionMode): void;
+export declare function createEmptyBundle(): BundleJsonApi<BundleEntry>;
+export declare function encodeBundleToBase64(bundle: BundleJsonApi<BundleEntry>): string;
+export declare function cloneBundle(bundle: BundleJsonApi<BundleEntry>): BundleJsonApi<BundleEntry>;
+export declare function cloneEntry(entry: BundleEntry): BundleEntry;
+export declare function cloneUnknownValue<T>(value: T): T;
+export declare function asTrimmedString(value: unknown): string;
+export declare function resolveContainedDocumentsClaimKey(resourceType: string): string;
+export declare function resolveSubjectFromClaims(claims: Record<string, unknown>): string;
+/**
+ * Resolves the canonical resource-scoped identifier used for upsert matching.
+ */
+export declare function resolveBundleEntryIdentifier(claims: Record<string, unknown>): string;
+/**
+ * Resolves the stable entry id value stored in `BundleEntry.id`.
+ */
+export declare function resolveBundleEntryCanonicalIdValue(claims: Record<string, unknown>): string;
+export declare function setIfMissing(target: Record<string, unknown>, key: string, value: unknown): void;
+export declare function runtimeUuid(prefix: string): string;
+export declare function splitCsv(value: unknown): string[];
+export declare function normalizeCsvValues(values: readonly unknown[]): string[];
+export declare function buildClassifiedConsentTarget(kind: ConsentEditorTargetKind, code: string, scopeCodes: readonly ConsentEditorScopeCode[], sectionFamily?: HealthcareCanonicalSectionFamily): ConsentEditorClassifiedTarget;
+export declare function buildSectionCatalogOptions(sectionKind: HealthcareCanonicalSectionFamily): ConsentEditorClassifiedTarget[];
+export declare function normalizeScopeCodes(scopeCodes: readonly ConsentEditorScopeCode[]): ConsentEditorScopeCode[];
+export declare function normalizeClassifiedTargets(targets: readonly ConsentEditorClassifiedTarget[]): ConsentEditorClassifiedTarget[];
+export declare function resolveConsentTargetDisplay(kind: ConsentEditorTargetKind, code: string): string | undefined;
+export declare function resolveConsentScopeDisplay(scopeCode: ConsentEditorScopeCode): string;
+export declare function resolveConsentPurposeDisplay(code: string): string;
+export declare function looksLikeEmailToken(value: string): boolean;
+export declare function looksLikePhoneToken(value: string): boolean;
+export declare function looksLikeJurisdictionToken(value: string): boolean;
+export declare function parseDidWebOrganizationToken(value: string): ConsentEditorClassifiedOrganization | undefined;
+export declare function parseConsentActorRole(value: string): ConsentEditorClassifiedActorRole | undefined;
+export declare function flattenClassifiedActors(classifiedActors: ConsentEditorClassifiedActors): string[];
+export declare function serializeClassifiedOrganization(organization: ConsentEditorClassifiedOrganization): string;
+export declare function flattenClassifiedRoles(classifiedRoles: ConsentEditorClassifiedRoles): string[];
+export declare function serializeClassifiedRole(role: ConsentEditorClassifiedRole): string;
+export declare function flattenClassifiedTargets(classifiedTargets: readonly ConsentEditorClassifiedTarget[]): Readonly<{
+    coreSections: readonly string[];
+    kindOfDocuments: readonly string[];
+    typeOfServices: readonly string[];
+    subjectMatterDomains: readonly string[];
+    resourceTypes: readonly string[];
+}>;
+export declare function classifyConsentTargetsFromClaims(claims: Record<string, unknown>): ConsentEditorClassifiedTarget[];
+export declare function classifyConsentPurposes(purposeCodes: readonly string[]): ConsentEditorClassifiedPurpose[];
+export declare function classifyConsentRoles(roleTokens: readonly string[]): ConsentEditorClassifiedRoles;
+export declare function classifyConsentActors(actorTokens: readonly string[], actorRoleToken?: string): ConsentEditorClassifiedActors;
+export declare function buildConsentViewModel(activeEntry: BundleEntry | null, decision: string, classifiedActors: ConsentEditorClassifiedActors, classifiedRoles: ConsentEditorClassifiedRoles, classifiedPurposes: readonly ConsentEditorClassifiedPurpose[], classifiedTargets: readonly ConsentEditorClassifiedTarget[]): ConsentViewModel;

package/dist/utils/communication-attached-bundle-session-helpers.js

@@ -0,0 +1,517 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { getHealthcareRoleByClaim, HealthcareRoleFamilies, getHealthcareSectionsByFamily, getHealthcareSectionByCode, getHealthcareSectionFamilyByCode, HealthcareConsentPurposes, HealthcareCanonicalSectionFamilies, } from '../constants/healthcare.js';
+import { ClaimConsent } from '../models/consent-rule.js';
+import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
+import { AppointmentClaim } from '../models/interoperable-claims/appointment-claims.js';
+import { AppointmentResponseClaim } from '../models/interoperable-claims/appointment-response-claims.js';
+import { CarePlanClaim } from '../models/interoperable-claims/care-plan-claims.js';
+import { ClinicalImpressionClaim } from '../models/interoperable-claims/clinical-impression-claims.js';
+import { ConditionClaim } from '../models/interoperable-claims/condition-claims.js';
+import { CompositionClaim } from '../models/interoperable-claims/composition-claims.js';
+import { CoverageClaim } from '../models/interoperable-claims/coverage-claims.js';
+import { DeviceClaim } from '../models/interoperable-claims/device-claims.js';
+import { DeviceUseStatementClaim } from '../models/interoperable-claims/device-use-statement-claims.js';
+import { DiagnosticReportClaim } from '../models/interoperable-claims/diagnostic-report-claims.js';
+import { DocumentReferenceClaim } from '../models/interoperable-claims/document-reference-claims.js';
+import { EncounterClaim } from '../models/interoperable-claims/encounter-claims.js';
+import { FlagClaim } from '../models/interoperable-claims/flag-claims.js';
+import { ImmunizationClaim } from '../models/interoperable-claims/immunization-claims.js';
+import { LocationClaim } from '../models/interoperable-claims/location-claims.js';
+import { MedicationStatementClaim, } from '../models/interoperable-claims/medication-statement-claims.js';
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
+import { OrganizationClaim } from '../models/interoperable-claims/organization-claims.js';
+import { ProcedureClaim } from '../models/interoperable-claims/procedure-claims.js';
+import { RelatedPersonClaim } from '../models/interoperable-claims/related-person-claims.js';
+import { AllergyIntoleranceClaim } from '../models/interoperable-claims/allergy-intolerance-claims.js';
+import { ConsentEditorScopeCodes, ConsentEditorTargetKinds, } from '../models/communication-attached-bundle-session.js';
+export const CSV_SEPARATOR = ',';
+const DID_WEB_PREFIX = 'did:web:';
+const PHONE_PREFIX = 'tel:';
+export function ensureEntryResource(entry, mode) {
+    const resource = entry.resource;
+    if (resource && typeof resource === 'object') {
+        return resource;
+    }
+    if (mode === 'normalize') {
+        return { meta: { claims: {} } };
+    }
+    throw new Error('Active entry does not contain a valid resource object.');
+}
+export function validateBundleLike(bundle, mode) {
+    const looksLikeBundle = bundle && bundle.resourceType === ResourceTypesFhirR4.Bundle && Array.isArray(bundle.data);
+    if (looksLikeBundle || mode === 'normalize') {
+        return;
+    }
+    throw new Error('Decoded attachment is not a valid BundleJsonApi payload.');
+}
+export function createEmptyBundle() {
+    return {
+        resourceType: ResourceTypesFhirR4.Bundle,
+        type: 'batch',
+        data: [],
+    };
+}
+export function encodeBundleToBase64(bundle) {
+    return Buffer.from(JSON.stringify(bundle), 'utf8').toString('base64');
+}
+export function cloneBundle(bundle) {
+    return JSON.parse(JSON.stringify(bundle));
+}
+export function cloneEntry(entry) {
+    return JSON.parse(JSON.stringify(entry));
+}
+export function cloneUnknownValue(value) {
+    if (value === undefined) {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+export function asTrimmedString(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    return String(value).trim();
+}
+export function resolveContainedDocumentsClaimKey(resourceType) {
+    if (resourceType === ResourceTypesFhirR4.Consent) {
+        return ClaimConsent.containedDocuments;
+    }
+    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
+        return MedicationStatementClaim.ContainedDocuments;
+    }
+    if (resourceType === ResourceTypesFhirR4.Condition) {
+        return ConditionClaim.ContainedDocuments;
+    }
+    if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
+        return AllergyIntoleranceClaim.ContainedDocuments;
+    }
+    if (resourceType === ResourceTypesFhirR4.DiagnosticReport) {
+        return DiagnosticReportClaim.ContainedDocuments;
+    }
+    return '';
+}
+export function resolveSubjectFromClaims(claims) {
+    return asTrimmedString(claims[ClaimConsent.subject]
+        || claims[MedicationStatementClaim.Subject]
+        || claims[MedicationStatementClaim.Patient]
+        || claims[DiagnosticReportClaim.Subject]
+        || claims[DiagnosticReportClaim.Patient]
+        || claims[CarePlanClaim.Subject]
+        || claims[CarePlanClaim.Patient]
+        || claims[ConditionClaim.Subject]
+        || claims[ProcedureClaim.Subject]
+        || claims[ProcedureClaim.Patient]
+        || claims[AllergyIntoleranceClaim.Subject]
+        || claims[AllergyIntoleranceClaim.Patient]
+        || claims[ImmunizationClaim.Subject]
+        || claims[ImmunizationClaim.Patient]
+        || claims[EncounterClaim.Subject]
+        || claims[EncounterClaim.Patient]
+        || claims[DocumentReferenceClaim.Subject]
+        || claims[ObservationClaim.Subject]
+        || claims[ObservationClaim.Patient]
+        || claims[FlagClaim.Subject]
+        || claims[FlagClaim.Patient]
+        || claims[ClinicalImpressionClaim.Subject]
+        || claims[DeviceClaim.Patient]
+        || claims[DeviceUseStatementClaim.Subject]
+        || claims[CoverageClaim.Beneficiary]
+        || claims[AppointmentResponseClaim.Patient]
+        || claims[CompositionClaim.Subject]
+        || claims[RelatedPersonClaim.Patient]);
+}
+/**
+ * Resolves the canonical resource-scoped identifier used for upsert matching.
+ */
+export function resolveBundleEntryIdentifier(claims) {
+    const identifierCandidates = [
+        [ResourceTypesFhirR4.Consent, ClaimConsent.identifier],
+        [ResourceTypesFhirR4.MedicationStatement, MedicationStatementClaim.Identifier],
+        [ResourceTypesFhirR4.DiagnosticReport, DiagnosticReportClaim.Identifier],
+        [ResourceTypesFhirR4.DocumentReference, DocumentReferenceClaim.Identifier],
+        [ResourceTypesFhirR4.Condition, ConditionClaim.Identifier],
+        [ResourceTypesFhirR4.AllergyIntolerance, AllergyIntoleranceClaim.Identifier],
+        [ResourceTypesFhirR4.Observation, ObservationClaim.Identifier],
+        [ResourceTypesFhirR4.Appointment, AppointmentClaim.Identifier],
+        [ResourceTypesFhirR4.AppointmentResponse, AppointmentResponseClaim.Identifier],
+        [ResourceTypesFhirR4.CarePlan, CarePlanClaim.Identifier],
+        [ResourceTypesFhirR4.Procedure, ProcedureClaim.Identifier],
+        [ResourceTypesFhirR4.Immunization, ImmunizationClaim.Identifier],
+        [ResourceTypesFhirR4.Encounter, EncounterClaim.Identifier],
+        [ResourceTypesFhirR4.Device, DeviceClaim.Identifier],
+        [ResourceTypesFhirR4.DeviceUseStatement, DeviceUseStatementClaim.Identifier],
+        [ResourceTypesFhirR4.Flag, FlagClaim.Identifier],
+        [ResourceTypesFhirR4.ClinicalImpression, ClinicalImpressionClaim.Identifier],
+        [ResourceTypesFhirR4.Coverage, CoverageClaim.Identifier],
+        [ResourceTypesFhirR4.Composition, CompositionClaim.Identifier],
+        [ResourceTypesFhirR4.Location, LocationClaim.Identifier],
+        [ResourceTypesFhirR4.Organization, OrganizationClaim.Identifier],
+        [ResourceTypesFhirR4.RelatedPerson, RelatedPersonClaim.IdentifierValue],
+        [ResourceTypesFhirR4.RelatedPerson, RelatedPersonClaim.Identifier],
+        [ResourceTypesFhirR4.Communication, CommunicationClaim.Identifier],
+    ];
+    for (const [resourceType, claimKey] of identifierCandidates) {
+        const identifier = asTrimmedString(claims[claimKey]);
+        if (identifier) {
+            return `${resourceType}:${identifier}`;
+        }
+    }
+    return '';
+}
+/**
+ * Resolves the stable entry id value stored in `BundleEntry.id`.
+ */
+export function resolveBundleEntryCanonicalIdValue(claims) {
+    const identifierCandidates = [
+        ClaimConsent.identifier,
+        MedicationStatementClaim.Identifier,
+        DiagnosticReportClaim.Identifier,
+        DocumentReferenceClaim.Identifier,
+        ConditionClaim.Identifier,
+        AllergyIntoleranceClaim.Identifier,
+        ObservationClaim.Identifier,
+        AppointmentClaim.Identifier,
+        AppointmentResponseClaim.Identifier,
+        CarePlanClaim.Identifier,
+        ProcedureClaim.Identifier,
+        ImmunizationClaim.Identifier,
+        EncounterClaim.Identifier,
+        DeviceClaim.Identifier,
+        DeviceUseStatementClaim.Identifier,
+        FlagClaim.Identifier,
+        ClinicalImpressionClaim.Identifier,
+        CoverageClaim.Identifier,
+        CompositionClaim.Identifier,
+        LocationClaim.Identifier,
+        OrganizationClaim.Identifier,
+        RelatedPersonClaim.IdentifierValue,
+        RelatedPersonClaim.Identifier,
+        CommunicationClaim.Identifier,
+    ];
+    for (const claimKey of identifierCandidates) {
+        const identifier = asTrimmedString(claims[claimKey]);
+        if (identifier) {
+            return identifier;
+        }
+    }
+    return '';
+}
+export function setIfMissing(target, key, value) {
+    if (target[key] !== undefined) {
+        return;
+    }
+    if (value === undefined || value === null || String(value).trim() === '') {
+        return;
+    }
+    target[key] = value;
+}
+export function runtimeUuid(prefix) {
+    const cryptoLike = globalThis;
+    if (typeof cryptoLike.crypto?.randomUUID === 'function') {
+        return cryptoLike.crypto.randomUUID();
+    }
+    return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+export function splitCsv(value) {
+    return normalizeCsvValues(String(value || '').split(CSV_SEPARATOR));
+}
+export function normalizeCsvValues(values) {
+    return Array.from(new Set(values
+        .map((item) => String(item || '').trim())
+        .filter(Boolean)));
+}
+export function buildClassifiedConsentTarget(kind, code, scopeCodes, sectionFamily) {
+    const normalizedCode = String(code || '').trim();
+    return {
+        target: {
+            kind,
+            code: normalizedCode,
+            display: resolveConsentTargetDisplay(kind, normalizedCode),
+            ...(kind === ConsentEditorTargetKinds.Section
+                ? { sectionFamily: sectionFamily || getHealthcareSectionFamilyByCode(normalizedCode) }
+                : {}),
+        },
+        scopes: normalizeScopeCodes(scopeCodes).map((scopeCode) => ({
+            code: scopeCode,
+            display: resolveConsentScopeDisplay(scopeCode),
+        })),
+    };
+}
+export function buildSectionCatalogOptions(sectionKind) {
+    return Object.values(getHealthcareSectionsByFamily(sectionKind)).map((descriptor) => buildClassifiedConsentTarget(ConsentEditorTargetKinds.Section, descriptor.attributeValue, [ConsentEditorScopeCodes.Read]));
+}
+export function normalizeScopeCodes(scopeCodes) {
+    const values = Array.from(new Set(scopeCodes.map((scopeCode) => String(scopeCode).trim()).filter(Boolean)));
+    return values.filter((scopeCode) => Object.values(ConsentEditorScopeCodes).includes(scopeCode));
+}
+export function normalizeClassifiedTargets(targets) {
+    const result = new Map();
+    for (const target of targets) {
+        const normalized = buildClassifiedConsentTarget(target.target.kind, String(target.target.code || '').trim(), target.scopes.map((scope) => scope.code), target.target.sectionFamily);
+        const key = `${normalized.target.kind}:${normalized.target.code}`;
+        result.set(key, normalized);
+    }
+    return Array.from(result.values());
+}
+export function resolveConsentTargetDisplay(kind, code) {
+    if (kind === ConsentEditorTargetKinds.ResourceType) {
+        return code;
+    }
+    if (kind === ConsentEditorTargetKinds.Section) {
+        const loincCode = code.includes('|') ? code.split('|').slice(-1)[0] : code;
+        return getHealthcareSectionByCode(loincCode)?.titleEn;
+    }
+    return undefined;
+}
+export function resolveConsentScopeDisplay(scopeCode) {
+    if (scopeCode === ConsentEditorScopeCodes.Search)
+        return 'search';
+    if (scopeCode === ConsentEditorScopeCodes.Read)
+        return 'read';
+    if (scopeCode === ConsentEditorScopeCodes.Create)
+        return 'create';
+    if (scopeCode === ConsentEditorScopeCodes.Update)
+        return 'update';
+    return 'delete';
+}
+export function resolveConsentPurposeDisplay(code) {
+    const normalized = String(code || '').trim();
+    if (normalized === HealthcareConsentPurposes.Treatment)
+        return 'Treatment';
+    if (normalized === HealthcareConsentPurposes.EmergencyTreatment)
+        return 'Emergency treatment';
+    if (normalized === HealthcareConsentPurposes.CareManagement)
+        return 'Care management';
+    if (normalized === HealthcareConsentPurposes.Operations)
+        return 'Operations';
+    if (normalized === HealthcareConsentPurposes.PatientAdministration)
+        return 'Patient administration';
+    if (normalized === HealthcareConsentPurposes.RecordsManagement)
+        return 'Records management';
+    return normalized;
+}
+export function looksLikeEmailToken(value) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value || '').trim().toLowerCase());
+}
+export function looksLikePhoneToken(value) {
+    return String(value || '').trim().startsWith(PHONE_PREFIX);
+}
+export function looksLikeJurisdictionToken(value) {
+    return /^[A-Z]{2}([\-:][A-Z0-9]+)?$/.test(String(value || '').trim());
+}
+export function parseDidWebOrganizationToken(value) {
+    const normalized = String(value || '').trim();
+    if (!normalized.startsWith(DID_WEB_PREFIX)) {
+        return undefined;
+    }
+    const segments = normalized.slice(DID_WEB_PREFIX.length).split(':').filter(Boolean);
+    if (segments.length === 0) {
+        return undefined;
+    }
+    const [domain, ...departmentSegments] = segments;
+    return {
+        domain,
+        display: domain,
+        departments: departmentSegments.map((segment) => ({
+            code: segment,
+            display: segment,
+        })),
+        locations: [],
+    };
+}
+export function parseConsentActorRole(value) {
+    const normalized = String(value || '').trim();
+    if (!normalized) {
+        return undefined;
+    }
+    const healthcareRole = getHealthcareRoleByClaim(normalized);
+    if (healthcareRole) {
+        return {
+            codingSystem: healthcareRole.codingSystem,
+            code: healthcareRole.code,
+            display: healthcareRole.titleEn,
+        };
+    }
+    const separatorIndex = normalized.indexOf('|');
+    if (separatorIndex < 0) {
+        return {
+            codingSystem: '',
+            code: normalized,
+            display: normalized,
+        };
+    }
+    return {
+        codingSystem: normalized.slice(0, separatorIndex),
+        code: normalized.slice(separatorIndex + 1),
+        display: normalized,
+    };
+}
+export function flattenClassifiedActors(classifiedActors) {
+    return normalizeCsvValues([
+        ...classifiedActors.jurisdictions.map((jurisdiction) => jurisdiction.code),
+        ...classifiedActors.organizations.map(serializeClassifiedOrganization),
+        ...classifiedActors.users.flatMap((user) => [user.email, user.phone]),
+    ]);
+}
+export function serializeClassifiedOrganization(organization) {
+    const domain = String(organization.domain || '').trim();
+    const departments = organization.departments
+        .map((department) => String(department.code || '').trim())
+        .filter(Boolean);
+    return [DID_WEB_PREFIX.replace(/:$/, ''), domain, ...departments].join(':');
+}
+export function flattenClassifiedRoles(classifiedRoles) {
+    return normalizeCsvValues([
+        ...classifiedRoles.professional.map(serializeClassifiedRole),
+        ...classifiedRoles.relationship.map(serializeClassifiedRole),
+        ...classifiedRoles.legalRepresentative.map(serializeClassifiedRole),
+        ...classifiedRoles.other.map(serializeClassifiedRole),
+    ]);
+}
+export function serializeClassifiedRole(role) {
+    const descriptor = getHealthcareRoleByClaim(`${String(role.codingSystem || '').trim()}|${String(role.code || '').trim()}`);
+    if (descriptor) {
+        return descriptor.claim;
+    }
+    return String(role.code || '').trim() || String(role.display || '').trim();
+}
+export function flattenClassifiedTargets(classifiedTargets) {
+    const coreSections = [];
+    const kindOfDocuments = [];
+    const typeOfServices = [];
+    const subjectMatterDomains = [];
+    const resourceTypes = [];
+    for (const entry of normalizeClassifiedTargets(classifiedTargets)) {
+        if (entry.target.kind === ConsentEditorTargetKinds.ResourceType) {
+            resourceTypes.push(entry.target.code);
+            continue;
+        }
+        const sectionFamily = entry.target.sectionFamily || getHealthcareSectionFamilyByCode(entry.target.code);
+        if (sectionFamily === HealthcareCanonicalSectionFamilies.KindOfDocument) {
+            kindOfDocuments.push(entry.target.code);
+            continue;
+        }
+        if (sectionFamily === HealthcareCanonicalSectionFamilies.TypeOfService) {
+            typeOfServices.push(entry.target.code);
+            continue;
+        }
+        if (sectionFamily === HealthcareCanonicalSectionFamilies.SubjectMatterDomain) {
+            subjectMatterDomains.push(entry.target.code);
+            continue;
+        }
+        coreSections.push(entry.target.code);
+    }
+    return {
+        coreSections: normalizeCsvValues(coreSections),
+        kindOfDocuments: normalizeCsvValues(kindOfDocuments),
+        typeOfServices: normalizeCsvValues(typeOfServices),
+        subjectMatterDomains: normalizeCsvValues(subjectMatterDomains),
+        resourceTypes: normalizeCsvValues(resourceTypes),
+    };
+}
+export function classifyConsentTargetsFromClaims(claims) {
+    const actionTargets = splitCsv(claims[ClaimConsent.action]).map((code) => buildClassifiedConsentTarget(ConsentEditorTargetKinds.Section, code, [ConsentEditorScopeCodes.Read]));
+    const categoryTargets = splitCsv(claims[ClaimConsent.category]).map((code) => buildClassifiedConsentTarget(ConsentEditorTargetKinds.Section, code, [ConsentEditorScopeCodes.Read], HealthcareCanonicalSectionFamilies.KindOfDocument));
+    const resourceTypes = splitCsv(claims[ClaimConsent.resourceType]).map((code) => buildClassifiedConsentTarget(ConsentEditorTargetKinds.ResourceType, code, [ConsentEditorScopeCodes.Read]));
+    return normalizeClassifiedTargets([
+        ...actionTargets,
+        ...categoryTargets,
+        ...resourceTypes,
+    ]);
+}
+export function classifyConsentPurposes(purposeCodes) {
+    return purposeCodes.map((code) => ({
+        code,
+        display: resolveConsentPurposeDisplay(code),
+    }));
+}
+export function classifyConsentRoles(roleTokens) {
+    const classified = {
+        professional: [],
+        relationship: [],
+        legalRepresentative: [],
+        other: [],
+    };
+    for (const roleToken of roleTokens) {
+        const role = getHealthcareRoleByClaim(roleToken);
+        if (!role) {
+            classified.other.push({
+                codingSystem: '',
+                code: roleToken,
+                display: roleToken,
+            });
+            continue;
+        }
+        const nextRole = {
+            kind: role.family,
+            codingSystem: role.codingSystem,
+            code: role.code,
+            display: role.titleEn,
+            definition: role.definition,
+        };
+        if (role.family === HealthcareRoleFamilies.ProfessionalOccupationIsco08) {
+            classified.professional.push(nextRole);
+        }
+        else if (role.family === HealthcareRoleFamilies.PersonalRelationshipHl7) {
+            classified.relationship.push(nextRole);
+        }
+        else if (role.family === HealthcareRoleFamilies.LegalRepresentativeHl7) {
+            classified.legalRepresentative.push(nextRole);
+        }
+        else {
+            classified.other.push(nextRole);
+        }
+    }
+    return classified;
+}
+export function classifyConsentActors(actorTokens, actorRoleToken) {
+    const actorRole = parseConsentActorRole(actorRoleToken || '');
+    const jurisdictions = new Map();
+    const organizations = new Map();
+    const users = new Map();
+    for (const token of actorTokens) {
+        if (looksLikeJurisdictionToken(token)) {
+            jurisdictions.set(token, { code: token, display: token });
+            continue;
+        }
+        if (looksLikeEmailToken(token)) {
+            users.set(`email:${token}`, {
+                email: token,
+                ...(actorRole ? { role: actorRole } : {}),
+            });
+            continue;
+        }
+        if (looksLikePhoneToken(token)) {
+            users.set(`phone:${token}`, {
+                phone: token,
+                ...(actorRole ? { role: actorRole } : {}),
+            });
+            continue;
+        }
+        const organization = parseDidWebOrganizationToken(token);
+        if (organization) {
+            organizations.set(organization.domain, organization);
+        }
+    }
+    return {
+        jurisdictions: Array.from(jurisdictions.values()),
+        organizations: Array.from(organizations.values()),
+        users: Array.from(users.values()),
+    };
+}
+export function buildConsentViewModel(activeEntry, decision, classifiedActors, classifiedRoles, classifiedPurposes, classifiedTargets) {
+    const claims = {
+        ...(activeEntry?.resource?.meta?.claims || {}),
+    };
+    return {
+        ...(activeEntry?.fullUrl ? { fullUrl: activeEntry.fullUrl } : {}),
+        identifier: asTrimmedString(claims[ClaimConsent.identifier]),
+        subject: asTrimmedString(claims[ClaimConsent.subject]),
+        decision,
+        classifiedActors,
+        classifiedRoles,
+        classifiedPurposes,
+        classifiedTargets,
+    };
+}