gdc-common-utils-ts 2.9.9 → 2.9.11

package/README.md

@@ -283,13 +283,23 @@ blockchain asset.
 
 ### Convert
 
-The `convert` export exposes resource-specific FHIR R4 conversion helpers such as:
+The `convert` export exposes resource-specific FHIR conversion helpers such as:
 
 - `medicationStatementFlatToFhirR4`
 - `medicationStatementFhirR4ToFlat`
 - `observationFromFlatToFhirR4`
 - `documentReferenceFlatToFhirR4`
 - `compositionFlatToFhirR4`
+- `consentFlatToFhirR4` / `consentFhirR4ToFlat`
+- `consentFlatToFhirR5` / `consentFhirR5ToFlat`
+
+Consent claims are version-neutral. Consent validity, data validity, grantor,
+grantee, manager, enforcer, actor role, action, purpose, resource/content codes
+and an optional source attachment stay in `resource.meta.claims`. Explicit R4
+or R5 export maps only concepts supported by that version. For example, R5
+exports `Consent.controller`, while R4 does not invent an equivalent field.
+Computable policy content such as ODRL remains in `sourceAttachment`; its
+profile must validate semantic parity before projection.
 
 Example:
 
@@ -554,8 +564,12 @@ The canonical API contract should live in JSDoc on exported code. The README act
     the document author; a registered PractitionerRole or RelatedPerson is the
     attester, including for content entered by that authenticated person.
 - [`normalizeClinicalCreatorBinding(...)`](src/utils/fhir-ips-creator-identity.ts)
-  - Accept stable UUIDs and governed bare role codes at the BFF boundary, then
-    add canonical UUID URNs and HL7/ISCO coding systems before transport.
+  - Accept stable person, assignment and owner UUIDs plus governed bare role
+    codes at the BFF boundary, then add canonical UUID URNs and HL7/ISCO coding
+    systems before transport. Use `assignmentIdentifier` for the registered
+    `RelatedPerson`/`PractitionerRole`; the deprecated wire property
+    `authorIdentifier` names that assignment and does not decide
+    `Composition.author`.
 - [`src/examples/frontend-session.ts`](src/examples/frontend-session.ts)
   - Frontend profile/session bootstrap examples.
 - [`src/examples/lifecycle.ts`](src/examples/lifecycle.ts)
@@ -673,6 +687,9 @@ when the active runtime variable is really the subject identifier.
 - [`__tests__/utils-consent-claim-helpers.test.ts`](__tests__/utils-consent-claim-helpers.test.ts)
 
 These helpers are the shared base for consent claim construction across GW and SDKs.
+The canonical claim catalogue also distinguishes `Consent.period-*` (the
+Consent's effective period) from `Consent.data-period-*` (the period of the
+governed data).
 
 ### Public module surfaces
 

package/dist/constants/fhir-resource-types.d.ts

@@ -41,6 +41,7 @@ export declare const ResourceTypesFhirR4: Readonly<{
     readonly PractitionerRole: "PractitionerRole";
     readonly Procedure: "Procedure";
     readonly RelatedPerson: "RelatedPerson";
+    readonly ResearchStudy: "ResearchStudy";
     readonly ResearchSubject: "ResearchSubject";
     readonly Specimen: "Specimen";
 }>;
@@ -89,6 +90,7 @@ export declare const FhirResourceTypes: Readonly<{
     readonly PractitionerRole: "PractitionerRole";
     readonly Procedure: "Procedure";
     readonly RelatedPerson: "RelatedPerson";
+    readonly ResearchStudy: "ResearchStudy";
     readonly ResearchSubject: "ResearchSubject";
     readonly Specimen: "Specimen";
 }>;
@@ -131,6 +133,7 @@ export declare const ResourceTypesFhirR5: Readonly<{
     readonly PractitionerRole: "PractitionerRole";
     readonly Procedure: "Procedure";
     readonly RelatedPerson: "RelatedPerson";
+    readonly ResearchStudy: "ResearchStudy";
     readonly ResearchSubject: "ResearchSubject";
     readonly Specimen: "Specimen";
 }>;

package/dist/constants/fhir-resource-types.js

@@ -41,6 +41,7 @@ export const ResourceTypesFhirR4 = Object.freeze({
     PractitionerRole: 'PractitionerRole',
     Procedure: 'Procedure',
     RelatedPerson: 'RelatedPerson',
+    ResearchStudy: 'ResearchStudy',
     ResearchSubject: 'ResearchSubject',
     Specimen: 'Specimen',
 });

package/dist/convert/convert-consent.d.ts

@@ -1,3 +1,9 @@
 import type { FhirResource, FlatClaims } from './convert-shared';
+/** Converts native FHIR R4 Consent into the canonical flat claims contract. */
 export declare function consentFhirR4ToFlat(resource: FhirResource, context?: string): FlatClaims;
+/** Projects canonical Consent claims to native FHIR R4. ODRL stays in sourceAttachment. */
 export declare function consentFlatToFhirR4(claims: FlatClaims): FhirResource;
+/** Converts native FHIR R5 Consent into the same version-neutral flat claims contract. */
+export declare function consentFhirR5ToFlat(resource: FhirResource, context?: string): FlatClaims;
+/** Projects canonical Consent claims to native FHIR R5. ODRL stays in sourceAttachment. */
+export declare function consentFlatToFhirR5(claims: FlatClaims): FhirResource;

package/dist/convert/convert-consent.js

@@ -1,78 +1,174 @@
 // Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
 import { ClaimConsent } from '../models/consent-rule.js';
-import { codingFromValue, codingToValue, referenceToValue, } from './convert-shared.js';
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { codingFromValue, codingToValue, referenceToValue } from './convert-shared.js';
+const firstReference = (value) => referenceToValue(value?.[0]);
+const conceptFromClaim = (value, display) => {
+    const coding = codingFromValue(value)?.map((item) => ({ ...item, ...(display ? { display } : {}) }));
+    return coding ? [{ coding }] : undefined;
+};
+const referencesFromClaim = (value) => value ? value.split(',').filter(Boolean).map((reference) => ({ reference })) : undefined;
+const codingsFromClaim = (value) => {
+    const codings = value?.split(',').filter(Boolean).flatMap((token) => codingFromValue(token) || []);
+    return codings?.length ? codings : undefined;
+};
+const codingsToClaim = (value) => {
+    const tokens = (value || []).map((coding) => codingToValue(coding)).filter(Boolean);
+    return tokens.length ? tokens.join(',') : undefined;
+};
+const conceptsToClaim = (value) => {
+    const tokens = (value || []).flatMap((concept) => concept.coding || []).map((coding) => codingToValue(coding)).filter(Boolean);
+    return tokens.length ? tokens.join(',') : undefined;
+};
+const conceptsFromClaim = (value, display) => codingsFromClaim(value)?.map((coding) => ({ coding: [{ ...coding, ...(display ? { display } : {}) }] }));
+const conceptWithCodingsFromClaim = (value) => {
+    const coding = codingsFromClaim(value);
+    return coding ? { coding } : undefined;
+};
+const attachmentFromClaims = (claims) => claims[ClaimConsent.attachmentContentType] || claims[ClaimConsent.attachmentData]
+    ? { contentType: claims[ClaimConsent.attachmentContentType], data: claims[ClaimConsent.attachmentData] }
+    : undefined;
+const periodFromClaims = (claims, start, end) => claims[start] || claims[end] ? { start: claims[start], end: claims[end] } : undefined;
+/** Converts native FHIR R4 Consent into the canonical flat claims contract. */
 export function consentFhirR4ToFlat(resource, context = 'org.hl7.fhir.api') {
-    const concept = resource.category?.[0];
+    const category = resource.category?.[0];
     const provision = resource.provision;
+    const attachment = resource.sourceAttachment;
     const scope = resource.scope;
     const policyRule = resource.policyRule;
     return {
         '@context': context,
-        [ClaimConsent.identifier]: resource.identifier?.[0]?.value
-            || resource.id,
+        [ClaimConsent.identifier]: resource.identifier?.[0]?.value || resource.id,
         [ClaimConsent.status]: resource.status,
         [ClaimConsent.subject]: referenceToValue(resource.patient),
         [ClaimConsent.patient]: referenceToValue(resource.patient),
         [ClaimConsent.date]: resource.dateTime,
         [ClaimConsent.decision]: provision?.type,
-        [ClaimConsent.action]: codingToValue(provision?.action?.[0]?.coding?.[0]),
         [ClaimConsent.periodStart]: provision?.period?.start,
         [ClaimConsent.periodEnd]: provision?.period?.end,
-        [ClaimConsent.purpose]: codingToValue(provision?.purpose?.[0]),
+        [ClaimConsent.dataPeriodStart]: provision?.dataPeriod?.start,
+        [ClaimConsent.dataPeriodEnd]: provision?.dataPeriod?.end,
+        [ClaimConsent.grantor]: firstReference(resource.performer),
+        [ClaimConsent.grantee]: referenceToValue(provision?.actor?.[0]?.reference),
+        [ClaimConsent.manager]: firstReference(resource.organization),
+        [ClaimConsent.actorIdentifier]: referenceToValue(provision?.actor?.[0]?.reference),
+        [ClaimConsent.actorRole]: codingsToClaim(provision?.actor?.[0]?.role?.coding),
+        [ClaimConsent.action]: conceptsToClaim(provision?.action),
+        [ClaimConsent.purpose]: codingsToClaim(provision?.purpose),
+        [ClaimConsent.securityLabel]: codingsToClaim(provision?.securityLabel),
+        [ClaimConsent.resourceType]: codingsToClaim(provision?.class),
+        [ClaimConsent.provisionCode]: conceptsToClaim(provision?.code),
+        [ClaimConsent.provisionCodeDisplay]: provision?.code?.[0]?.coding?.[0]?.display,
         [ClaimConsent.sourceReference]: referenceToValue(resource.sourceReference),
-        [ClaimConsent.category]: codingToValue(concept?.coding?.[0]),
-        [ClaimConsent.categoryText]: concept?.text,
-        [ClaimConsent.categoryDisplay]: concept?.coding?.[0]?.display,
+        [ClaimConsent.attachmentContentType]: attachment?.contentType,
+        [ClaimConsent.attachmentData]: attachment?.data,
+        [ClaimConsent.category]: codingToValue(category?.coding?.[0]),
+        [ClaimConsent.categoryText]: category?.text,
+        [ClaimConsent.categoryDisplay]: category?.coding?.[0]?.display,
         [ClaimConsent.scope]: codingToValue(scope?.coding?.[0]),
         [ClaimConsent.scopeDisplay]: scope?.coding?.[0]?.display,
         [ClaimConsent.policyRule]: codingToValue(policyRule?.coding?.[0]),
-        [ClaimConsent.provisionCode]: codingToValue(provision?.code?.[0]?.coding?.[0]),
-        [ClaimConsent.provisionCodeDisplay]: provision?.code?.[0]?.coding?.[0]?.display,
     };
 }
+/** Projects canonical Consent claims to native FHIR R4. ODRL stays in sourceAttachment. */
 export function consentFlatToFhirR4(claims) {
-    const coding = codingFromValue(claims[ClaimConsent.category])?.map((item) => ({
-        ...item,
-        ...(claims[ClaimConsent.categoryDisplay]
-            ? { display: claims[ClaimConsent.categoryDisplay] }
-            : {}),
-    }));
-    const actionCoding = codingFromValue(claims[ClaimConsent.action]);
-    const purposeCoding = codingFromValue(claims[ClaimConsent.purpose]);
-    const scopeCoding = codingFromValue(claims[ClaimConsent.scope])?.map((item) => ({ ...item, ...(claims[ClaimConsent.scopeDisplay] ? { display: claims[ClaimConsent.scopeDisplay] } : {}) }));
-    const provisionCodeCoding = codingFromValue(claims[ClaimConsent.provisionCode])?.map((item) => ({ ...item, ...(claims[ClaimConsent.provisionCodeDisplay] ? { display: claims[ClaimConsent.provisionCodeDisplay] } : {}) }));
+    const actorRole = conceptWithCodingsFromClaim(claims[ClaimConsent.actorRole]);
+    const actorReference = claims[ClaimConsent.grantee] || claims[ClaimConsent.actorIdentifier];
+    const provisionCode = conceptsFromClaim(claims[ClaimConsent.provisionCode], claims[ClaimConsent.provisionCodeDisplay]);
+    const attachment = attachmentFromClaims(claims);
     return {
-        resourceType: 'Consent',
+        resourceType: ResourceTypesFhirR4.Consent,
         identifier: claims[ClaimConsent.identifier] ? [{ value: claims[ClaimConsent.identifier] }] : undefined,
         status: claims[ClaimConsent.status],
-        scope: scopeCoding ? { coding: scopeCoding } : undefined,
-        policyRule: claims[ClaimConsent.policyRule] ? { coding: codingFromValue(claims[ClaimConsent.policyRule]) } : undefined,
-        patient: claims[ClaimConsent.subject] || claims[ClaimConsent.patient]
-            ? { reference: claims[ClaimConsent.subject] || claims[ClaimConsent.patient] }
-            : undefined,
+        scope: conceptFromClaim(claims[ClaimConsent.scope], claims[ClaimConsent.scopeDisplay])?.[0],
+        category: conceptFromClaim(claims[ClaimConsent.category], claims[ClaimConsent.categoryDisplay]),
+        patient: claims[ClaimConsent.subject] || claims[ClaimConsent.patient] ? { reference: claims[ClaimConsent.subject] || claims[ClaimConsent.patient] } : undefined,
         dateTime: claims[ClaimConsent.date],
-        sourceReference: claims[ClaimConsent.sourceReference]
-            ? { reference: claims[ClaimConsent.sourceReference] }
-            : undefined,
-        category: coding || claims[ClaimConsent.categoryText] ? [{
-                ...(coding ? { coding } : {}),
-                ...(claims[ClaimConsent.categoryText] ? { text: claims[ClaimConsent.categoryText] } : {}),
-            }] : undefined,
-        provision: claims[ClaimConsent.decision]
-            || claims[ClaimConsent.periodStart]
-            || claims[ClaimConsent.periodEnd]
-            || actionCoding
-            || purposeCoding
-            || provisionCodeCoding
-            ? {
-                type: claims[ClaimConsent.decision],
-                period: claims[ClaimConsent.periodStart] || claims[ClaimConsent.periodEnd]
-                    ? { start: claims[ClaimConsent.periodStart], end: claims[ClaimConsent.periodEnd] }
-                    : undefined,
-                action: actionCoding ? [{ coding: actionCoding }] : undefined,
-                purpose: purposeCoding,
-                code: provisionCodeCoding ? [{ coding: provisionCodeCoding }] : undefined,
-            }
-            : undefined,
+        performer: referencesFromClaim(claims[ClaimConsent.grantor]),
+        organization: referencesFromClaim(claims[ClaimConsent.manager]),
+        sourceAttachment: attachment,
+        sourceReference: claims[ClaimConsent.sourceReference] ? { reference: claims[ClaimConsent.sourceReference] } : undefined,
+        policyRule: conceptFromClaim(claims[ClaimConsent.policyRule])?.[0],
+        provision: {
+            type: claims[ClaimConsent.decision],
+            period: periodFromClaims(claims, ClaimConsent.periodStart, ClaimConsent.periodEnd),
+            actor: actorReference ? [{ role: actorRole, reference: { reference: actorReference } }] : undefined,
+            action: conceptsFromClaim(claims[ClaimConsent.action]),
+            purpose: codingsFromClaim(claims[ClaimConsent.purpose]),
+            securityLabel: codingsFromClaim(claims[ClaimConsent.securityLabel]),
+            class: codingsFromClaim(claims[ClaimConsent.resourceType]),
+            code: provisionCode,
+            dataPeriod: periodFromClaims(claims, ClaimConsent.dataPeriodStart, ClaimConsent.dataPeriodEnd),
+        },
+    };
+}
+/** Converts native FHIR R5 Consent into the same version-neutral flat claims contract. */
+export function consentFhirR5ToFlat(resource, context = 'org.hl7.fhir.api') {
+    const categories = resource.category;
+    const scopeConcept = categories?.find((item) => item.coding?.[0]?.system?.includes('consentscope'));
+    const categoryConcept = categories?.find((item) => item !== scopeConcept);
+    const provision = resource.provision?.[0];
+    const attachment = resource.sourceAttachment?.[0];
+    return {
+        '@context': context,
+        [ClaimConsent.identifier]: resource.identifier?.[0]?.value || resource.id,
+        [ClaimConsent.status]: resource.status,
+        [ClaimConsent.subject]: referenceToValue(resource.subject),
+        [ClaimConsent.date]: resource.date,
+        [ClaimConsent.decision]: resource.decision,
+        [ClaimConsent.periodStart]: resource.period?.start,
+        [ClaimConsent.periodEnd]: resource.period?.end,
+        [ClaimConsent.grantor]: firstReference(resource.grantor),
+        [ClaimConsent.grantee]: firstReference(resource.grantee),
+        [ClaimConsent.manager]: firstReference(resource.manager),
+        [ClaimConsent.controller]: firstReference(resource.controller),
+        [ClaimConsent.actorIdentifier]: referenceToValue(provision?.actor?.[0]?.reference) || firstReference(resource.grantee),
+        [ClaimConsent.actorRole]: codingsToClaim(provision?.actor?.[0]?.role?.coding),
+        [ClaimConsent.action]: conceptsToClaim(provision?.action),
+        [ClaimConsent.purpose]: codingsToClaim(provision?.purpose),
+        [ClaimConsent.securityLabel]: codingsToClaim(provision?.securityLabel),
+        [ClaimConsent.documentType]: codingsToClaim(provision?.documentType),
+        [ClaimConsent.resourceType]: codingsToClaim(provision?.resourceType),
+        [ClaimConsent.provisionCode]: conceptsToClaim(provision?.code),
+        [ClaimConsent.dataPeriodStart]: provision?.dataPeriod?.start,
+        [ClaimConsent.dataPeriodEnd]: provision?.dataPeriod?.end,
+        [ClaimConsent.attachmentContentType]: attachment?.contentType,
+        [ClaimConsent.attachmentData]: attachment?.data,
+        [ClaimConsent.sourceReference]: firstReference(resource.sourceReference),
+        [ClaimConsent.scope]: codingToValue(scopeConcept?.coding?.[0]),
+        [ClaimConsent.category]: codingToValue(categoryConcept?.coding?.[0] || categories?.[0]?.coding?.[0]),
+    };
+}
+/** Projects canonical Consent claims to native FHIR R5. ODRL stays in sourceAttachment. */
+export function consentFlatToFhirR5(claims) {
+    const category = conceptFromClaim(claims[ClaimConsent.category], claims[ClaimConsent.categoryDisplay]);
+    const scope = conceptFromClaim(claims[ClaimConsent.scope], claims[ClaimConsent.scopeDisplay]);
+    const actorReference = claims[ClaimConsent.grantee] || claims[ClaimConsent.actorIdentifier];
+    const attachment = attachmentFromClaims(claims);
+    return {
+        resourceType: ResourceTypesFhirR4.Consent,
+        identifier: claims[ClaimConsent.identifier] ? [{ value: claims[ClaimConsent.identifier] }] : undefined,
+        status: claims[ClaimConsent.status],
+        category: [...(scope || []), ...(category || [])],
+        subject: claims[ClaimConsent.subject] ? { reference: claims[ClaimConsent.subject] } : undefined,
+        date: claims[ClaimConsent.date],
+        period: periodFromClaims(claims, ClaimConsent.periodStart, ClaimConsent.periodEnd),
+        grantor: referencesFromClaim(claims[ClaimConsent.grantor]),
+        grantee: referencesFromClaim(claims[ClaimConsent.grantee] || claims[ClaimConsent.actorIdentifier]),
+        manager: referencesFromClaim(claims[ClaimConsent.manager]),
+        controller: referencesFromClaim(claims[ClaimConsent.controller]),
+        sourceAttachment: attachment ? [attachment] : undefined,
+        sourceReference: referencesFromClaim(claims[ClaimConsent.sourceReference]),
+        decision: claims[ClaimConsent.decision],
+        provision: [{
+                actor: actorReference ? [{ role: conceptWithCodingsFromClaim(claims[ClaimConsent.actorRole]), reference: { reference: actorReference } }] : undefined,
+                action: conceptsFromClaim(claims[ClaimConsent.action]),
+                securityLabel: codingsFromClaim(claims[ClaimConsent.securityLabel]),
+                purpose: codingsFromClaim(claims[ClaimConsent.purpose]),
+                documentType: codingsFromClaim(claims[ClaimConsent.documentType]),
+                resourceType: codingsFromClaim(claims[ClaimConsent.resourceType]),
+                code: conceptsFromClaim(claims[ClaimConsent.provisionCode], claims[ClaimConsent.provisionCodeDisplay]),
+                dataPeriod: periodFromClaims(claims, ClaimConsent.dataPeriodStart, ClaimConsent.dataPeriodEnd),
+            }],
     };
 }

package/dist/examples/consent-projection.d.ts

@@ -0,0 +1,28 @@
+/** Reusable, non-production identifiers for Consent R4/R5 projection tests. */
+export declare const CONSENT_PROJECTION_TEST_DATA: Readonly<{
+    identifier: "urn:uuid:9f4105a1-fca1-4b92-a38f-cd40f37da36e";
+    subject: "Patient/consent-subject-test";
+    grantor: "RelatedPerson/consent-grantor-test";
+    grantee: "Organization/consent-grantee-test";
+    manager: "Organization/consent-manager-test";
+    controller: "Organization/consent-enforcer-test";
+    createdAt: "2026-09-08";
+    consentPeriodStart: "2026-09-08T10:00:00Z";
+    consentPeriodEnd: "2026-10-08T10:00:00Z";
+    dataPeriodStart: "2025-09-08T00:00:00Z";
+    dataPeriodEnd: "2026-09-08T00:00:00Z";
+    actorRole: "http://terminology.hl7.org/CodeSystem/v3-RoleCode|PAYOR";
+    action: "http://terminology.hl7.org/CodeSystem/consentaction|access";
+    purpose: "http://terminology.hl7.org/CodeSystem/v3-ActReason|HPAYMT";
+    scope: "http://terminology.hl7.org/CodeSystem/consentscope|patient-privacy";
+    category: "http://loinc.org|59284-0";
+    resourceType: "http://hl7.org/fhir/fhir-types|Observation";
+    provisionCode: "http://loinc.org|85353-1";
+    secondProvisionCode: "http://loinc.org|8310-5";
+    provisionCodeList: "http://loinc.org|85353-1,http://loinc.org|8310-5";
+    securityLabel: "http://terminology.hl7.org/CodeSystem/v3-Confidentiality|R";
+    attachmentContentType: "application/odrl+json";
+    attachmentData: "eyJAdHlwZSI6IkFncmVlbWVudCJ9";
+    odrlOnlyConstraintName: "odrl.profile.max-query-count";
+    odrlOnlyConstraintValue: "1";
+}>;

package/dist/examples/consent-projection.js

@@ -0,0 +1,29 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+/** Reusable, non-production identifiers for Consent R4/R5 projection tests. */
+export const CONSENT_PROJECTION_TEST_DATA = Object.freeze({
+    identifier: 'urn:uuid:9f4105a1-fca1-4b92-a38f-cd40f37da36e',
+    subject: 'Patient/consent-subject-test',
+    grantor: 'RelatedPerson/consent-grantor-test',
+    grantee: 'Organization/consent-grantee-test',
+    manager: 'Organization/consent-manager-test',
+    controller: 'Organization/consent-enforcer-test',
+    createdAt: '2026-09-08',
+    consentPeriodStart: '2026-09-08T10:00:00Z',
+    consentPeriodEnd: '2026-10-08T10:00:00Z',
+    dataPeriodStart: '2025-09-08T00:00:00Z',
+    dataPeriodEnd: '2026-09-08T00:00:00Z',
+    actorRole: 'http://terminology.hl7.org/CodeSystem/v3-RoleCode|PAYOR',
+    action: 'http://terminology.hl7.org/CodeSystem/consentaction|access',
+    purpose: 'http://terminology.hl7.org/CodeSystem/v3-ActReason|HPAYMT',
+    scope: 'http://terminology.hl7.org/CodeSystem/consentscope|patient-privacy',
+    category: 'http://loinc.org|59284-0',
+    resourceType: 'http://hl7.org/fhir/fhir-types|Observation',
+    provisionCode: 'http://loinc.org|85353-1',
+    secondProvisionCode: 'http://loinc.org|8310-5',
+    provisionCodeList: 'http://loinc.org|85353-1,http://loinc.org|8310-5',
+    securityLabel: 'http://terminology.hl7.org/CodeSystem/v3-Confidentiality|R',
+    attachmentContentType: 'application/odrl+json',
+    attachmentData: 'eyJAdHlwZSI6IkFncmVlbWVudCJ9',
+    odrlOnlyConstraintName: 'odrl.profile.max-query-count',
+    odrlOnlyConstraintValue: '1',
+});

package/dist/examples/index.d.ts

@@ -1,4 +1,5 @@
 export * from './shared';
+export * from './consent-projection';
 export * from './ica-activation-proof';
 export * from './ica-verify-response';
 export * from './dataspace-discovery';

package/dist/examples/index.js

@@ -1,4 +1,5 @@
 export * from './shared.js';
+export * from './consent-projection.js';
 export * from './ica-activation-proof.js';
 export * from './ica-verify-response.js';
 export * from './dataspace-discovery.js';

package/dist/models/consent-rule.d.ts

@@ -13,7 +13,12 @@ export declare enum ClaimConsent {
     'date' = "Consent.date",
     'periodStart' = "Consent.period-start",
     'periodEnd' = "Consent.period-end",
+    'dataPeriodStart' = "Consent.data-period-start",
+    'dataPeriodEnd' = "Consent.data-period-end",
+    'grantor' = "Consent.grantor",
     'grantee' = "Consent.grantee",
+    'manager' = "Consent.manager",
+    'controller' = "Consent.controller",
     'verifiedBy' = "Consent.verified-by",
     'verifiedDate' = "Consent.verified-date",
     'purpose' = "Consent.purpose",
@@ -25,6 +30,8 @@ export declare enum ClaimConsent {
     'policyRule' = "Consent.policy-rule",
     'provisionCode' = "Consent.provision-code",
     'provisionCodeDisplay' = "Consent.provision-code-display",
+    'securityLabel' = "Consent.security-label",
+    'documentType' = "Consent.document-type",
     'containedReferenceList' = "Consent.contained-reference-list",
     /**
      * @deprecated Use `containedReferenceList`.
@@ -137,6 +144,14 @@ export interface ConsentRule {
      * Derived from the end of the `org.hl7.fhir.api.Consent.period` claim.
      */
     'Consent.period-end'?: string;
+    /** Timeframe of the governed data; distinct from Consent validity. */
+    'Consent.data-period-start'?: string;
+    'Consent.data-period-end'?: string;
+    /** R5 grantor, grantee, workflow manager and enforcement controller references. */
+    'Consent.grantor'?: string;
+    'Consent.grantee'?: string;
+    'Consent.manager'?: string;
+    'Consent.controller'?: string;
     /**
      * The party to whom the consent is granted.
      * Use both 'Consent.actor-identifier' and 'Consent.actor-role' instead.
@@ -163,6 +178,11 @@ export interface ConsentRule {
      * Derived from the `org.hl7.fhir.api.Consent.identifier` claim.
      */
     'Consent.identifier': string;
+    /** Governed FHIR resource types and security/content classifications. */
+    'Consent.resource-type'?: string;
+    'Consent.security-label'?: string;
+    'Consent.document-type'?: string;
+    'Consent.provision-code'?: string;
     'Consent.contained-reference-list'?: string;
     'Consent.contained-resource-list'?: string;
     'Consent.contained-documents'?: string;

package/dist/models/consent-rule.js

@@ -15,7 +15,12 @@ export var ClaimConsent;
     ClaimConsent["date"] = "Consent.date";
     ClaimConsent["periodStart"] = "Consent.period-start";
     ClaimConsent["periodEnd"] = "Consent.period-end";
+    ClaimConsent["dataPeriodStart"] = "Consent.data-period-start";
+    ClaimConsent["dataPeriodEnd"] = "Consent.data-period-end";
+    ClaimConsent["grantor"] = "Consent.grantor";
     ClaimConsent["grantee"] = "Consent.grantee";
+    ClaimConsent["manager"] = "Consent.manager";
+    ClaimConsent["controller"] = "Consent.controller";
     ClaimConsent["verifiedBy"] = "Consent.verified-by";
     ClaimConsent["verifiedDate"] = "Consent.verified-date";
     ClaimConsent["purpose"] = "Consent.purpose";
@@ -27,6 +32,8 @@ export var ClaimConsent;
     ClaimConsent["policyRule"] = "Consent.policy-rule";
     ClaimConsent["provisionCode"] = "Consent.provision-code";
     ClaimConsent["provisionCodeDisplay"] = "Consent.provision-code-display";
+    ClaimConsent["securityLabel"] = "Consent.security-label";
+    ClaimConsent["documentType"] = "Consent.document-type";
     ClaimConsent["containedReferenceList"] = "Consent.contained-reference-list";
     /**
      * @deprecated Use `containedReferenceList`.

package/dist/utils/fhir-ips-creator-identity.d.ts

@@ -12,7 +12,11 @@ export type FhirIpsCreatorBundleEntry = Readonly<{
 type FhirIpsCreatorBase = Readonly<{
     /** Stable imported or locally generated actor identifier. */
     actorIdentifier: string;
-    /** Stable identifier referenced by Composition.author for this role/relationship. */
+    /**
+     * Historical API name for the stable role/relationship assignment identifier.
+     * Provenance uses this assignment as `Composition.attester.party`; it is not
+     * automatically the `Composition.author`.
+     */
     authorIdentifier: string;
 }>;
 export type FhirIpsCreatorAuthorInput = (FhirIpsCreatorBase & Readonly<{
@@ -93,8 +97,11 @@ type ClinicalCreatorChannelAliases = Readonly<{
 }>;
 /**
  * Durable clinical-creator identity stored behind the authenticated profile.
- * `actorIdentifier` identifies the person/member. `authorIdentifier` identifies
- * the concrete role or relationship assignment used as the FHIR author.
+ * `actorIdentifier` identifies the person/member. The historical wire property
+ * `authorIdentifier` identifies the concrete PractitionerRole/RelatedPerson
+ * assignment used as `Composition.attester.party`; it does not decide
+ * `Composition.author`. `ownerIdentifier` identifies the legal organization or
+ * individual organization/subject that owns that assignment.
  * Contacts, DCR clients, keys and operational DIDs are aliases only.
  */
 export type ClinicalCreatorBinding = ClinicalCreatorChannelAliases & Readonly<{
@@ -117,7 +124,10 @@ export type ClinicalCreatorBinding = ClinicalCreatorChannelAliases & Readonly<{
 export type ClinicalCreatorBindingInput = ClinicalCreatorChannelAliases & Readonly<{
     kind: FhirIpsCreatorKind;
     actorIdentifier: string;
-    authorIdentifier: string;
+    /** Preferred high-level name for the PractitionerRole/RelatedPerson UUID. */
+    assignmentIdentifier?: string;
+    /** @deprecated Historical DCR/profile wire name; use `assignmentIdentifier`. */
+    authorIdentifier?: string;
     ownerIdentifier: string;
     role: string;
 }>;

package/dist/utils/fhir-ips-creator-identity.js

@@ -129,13 +129,26 @@ export function buildFhirIpsCreatorAuthor(input) {
  */
 export function normalizeClinicalCreatorBinding(input) {
     const actorIdentifier = canonicalUuidUrn(input.actorIdentifier, 'actorIdentifier');
-    const authorIdentifier = canonicalUuidUrn(input.authorIdentifier, 'authorIdentifier');
+    const preferredAssignment = input.assignmentIdentifier
+        ? canonicalUuidUrn(input.assignmentIdentifier, 'assignmentIdentifier')
+        : undefined;
+    const legacyAssignment = input.authorIdentifier
+        ? canonicalUuidUrn(input.authorIdentifier, 'authorIdentifier')
+        : undefined;
+    if (preferredAssignment && legacyAssignment && preferredAssignment !== legacyAssignment) {
+        throw new TypeError('assignmentIdentifier and deprecated authorIdentifier must identify the same assignment.');
+    }
+    const authorIdentifier = preferredAssignment || legacyAssignment;
+    if (!authorIdentifier) {
+        throw new TypeError('assignmentIdentifier is required.');
+    }
     const ownerIdentifier = input.kind === FhirIpsCreatorKinds.Professional
         ? requireReference(input.ownerIdentifier, 'ownerIdentifier')
         : canonicalUuidUrn(input.ownerIdentifier, 'ownerIdentifier');
     const role = canonicalRoleClaim(input.role);
+    const { assignmentIdentifier: _assignmentIdentifier, ...wireInput } = input;
     return {
-        ...input,
+        ...wireInput,
         actorIdentifier,
         authorIdentifier,
         ownerIdentifier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "2.9.9",
+  "version": "2.9.11",
   "publishConfig": {
     "access": "public"
   },