gdc-sdk-front-ts 0.6.2 → 0.6.6

package/dist/gdc-sdk-core-ts/src/communication-resource-helpers.js

@@ -0,0 +1,455 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ResourceTypesFhirR4, } from 'gdc-common-utils-ts/constants/fhir-resource-types';
+import { FhirVersions, } from 'gdc-common-utils-ts/constants/fhir-versions';
+function cloneRecord(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function toArray(value) {
+    if (value === undefined)
+        return [];
+    return Array.isArray(value) ? [...value] : [value];
+}
+function encodeBase64Utf8(value) {
+    const anyGlobal = globalThis;
+    if (anyGlobal.Buffer) {
+        return anyGlobal.Buffer.from(value, 'utf8').toString('base64');
+    }
+    if (typeof anyGlobal.btoa === 'function') {
+        const utf8 = encodeURIComponent(value).replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+        return anyGlobal.btoa(utf8);
+    }
+    throw new Error('No base64 encoder available in this runtime.');
+}
+function decodeBase64Utf8(value) {
+    const anyGlobal = globalThis;
+    if (anyGlobal.Buffer) {
+        return anyGlobal.Buffer.from(value, 'base64').toString('utf8');
+    }
+    if (typeof anyGlobal.atob === 'function') {
+        const decoded = anyGlobal.atob(value);
+        const percentEncoded = decoded
+            .split('')
+            .map((char) => `%${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+            .join('');
+        return decodeURIComponent(percentEncoded);
+    }
+    throw new Error('No base64 decoder available in this runtime.');
+}
+function extractCodingToken(coding) {
+    if (!coding)
+        return undefined;
+    const system = typeof coding.system === 'string' ? coding.system.trim() : '';
+    const code = typeof coding.code === 'string' ? coding.code.trim() : '';
+    if (system && code)
+        return `${system}|${code}`;
+    return code || undefined;
+}
+function getFirstCodingToken(value) {
+    const coding = (Array.isArray(value) ? value : [])
+        .flatMap((item) => (isPlainObject(item) && Array.isArray(item.coding) ? item.coding : []))
+        .find(isPlainObject);
+    return extractCodingToken(coding);
+}
+function getCanonicalDate(resource) {
+    const candidates = [
+        resource.effectiveDateTime,
+        resource.issued,
+        resource.authoredOn,
+        resource.performedDateTime,
+        resource.recordedDate,
+        resource.date,
+        resource.sent,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim())
+            return candidate.trim();
+    }
+    return undefined;
+}
+function buildAttachmentFromResource(resource, options = {}) {
+    const attachment = {
+        contentType: options.contentType || 'application/fhir+json',
+    };
+    if (options.title)
+        attachment.title = options.title;
+    if (options.url)
+        attachment.url = options.url;
+    if (options.dataBase64) {
+        attachment.data = options.dataBase64;
+    }
+    else {
+        attachment.data = encodeBase64Utf8(JSON.stringify(resource));
+    }
+    return attachment;
+}
+function parseAttachmentResource(attachment) {
+    if (!attachment)
+        return undefined;
+    if (typeof attachment.data !== 'string' || !attachment.data.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(decodeBase64Utf8(attachment.data));
+        return isPlainObject(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getPayloadAttachment(payload) {
+    const contentAttachment = payload.contentAttachment;
+    return isPlainObject(contentAttachment) ? contentAttachment : undefined;
+}
+function getPayloadReference(payload) {
+    const contentReference = payload.contentReference;
+    if (!isPlainObject(contentReference))
+        return undefined;
+    return typeof contentReference.reference === 'string' ? contentReference.reference : undefined;
+}
+function getCommunicationNoteTexts(communication) {
+    return Array.isArray(communication.note)
+        ? communication.note
+            .map((item) => (isPlainObject(item) && typeof item.text === 'string' ? item.text.trim() : ''))
+            .filter(Boolean)
+        : [];
+}
+function ensureCommunicationResource(communication) {
+    if (communication.resourceType !== ResourceTypesFhirR4.Communication) {
+        throw new TypeError('Expected a FHIR Communication resource.');
+    }
+    return communication;
+}
+function buildCategory(category) {
+    if (!category || category.length === 0)
+        return undefined;
+    const categoryItems = [...category];
+    const codings = categoryItems
+        .map((item) => {
+        if (typeof item === 'string') {
+            const [system, code] = item.includes('|') ? item.split('|', 2) : ['', item];
+            return code ? { system: system || undefined, code } : undefined;
+        }
+        if (item && typeof item.code === 'string' && item.code.trim()) {
+            return { system: item.system, code: item.code };
+        }
+        return undefined;
+    })
+        .filter((item) => Boolean(item));
+    return codings.length ? [{ coding: codings }] : undefined;
+}
+function resolveNoteText(options) {
+    const value = typeof options.noteText === 'string' ? options.noteText.trim() : '';
+    return value || undefined;
+}
+function appendNoteText(communication, noteText) {
+    if (!noteText || !noteText.trim())
+        return communication;
+    const next = cloneRecord(communication);
+    const notes = Array.isArray(next.note) ? [...next.note] : [];
+    notes.push({ text: noteText.trim() });
+    next.note = notes;
+    return next;
+}
+function appendPayload(communication, payloadEntry) {
+    const next = cloneRecord(communication);
+    const payload = Array.isArray(next.payload) ? [...next.payload] : [];
+    payload.push(payloadEntry);
+    next.payload = payload;
+    return next;
+}
+/**
+ * Creates a minimal FHIR `Communication` resource ready to receive payloads.
+ *
+ * @param options.subject Subject reference carried by `Communication.subject.reference`.
+ * @param options.sender Optional sender reference.
+ * @param options.recipient Optional recipient reference or references.
+ * @param options.sent Optional sent timestamp.
+ * @param options.status Optional FHIR communication status. Defaults to `completed`.
+ * @param options.category Optional coding tokens or coding descriptors.
+ * @param options.noteText Optional message note text. FHIR allows markdown here.
+ * @param options.claims Optional `resource.meta.claims` payload to preserve.
+ */
+export function createCommunicationResource(options) {
+    const communication = {
+        resourceType: ResourceTypesFhirR4.Communication,
+        status: options.status || 'completed',
+        subject: { reference: options.subject },
+    };
+    if (options.sender)
+        communication.sender = { reference: options.sender };
+    if (options.recipient) {
+        communication.recipient = toArray(options.recipient).map((reference) => ({ reference }));
+    }
+    if (options.sent)
+        communication.sent = options.sent;
+    const category = buildCategory(options.category);
+    if (category)
+        communication.category = category;
+    const noteText = resolveNoteText(options);
+    if (noteText) {
+        communication.note = [{ text: noteText }];
+    }
+    if (options.claims) {
+        communication.meta = { claims: cloneRecord(options.claims) };
+    }
+    return communication;
+}
+/**
+ * Wraps a FHIR `Communication` into a batch message payload suitable for
+ * the legacy/FHIR ingestion routes used by the GW.
+ *
+ * @param communication FHIR `Communication` resource to submit.
+ * @param options.thid Optional thread id for the envelope.
+ * @param options.jti Optional envelope id.
+ * @param options.iss Optional issuer DID.
+ * @param options.aud Optional audience DID.
+ * @param options.requestUrl Optional FHIR batch request URL.
+ * @param options.entryType Optional business type for the batch entry.
+ * @param options.messageType Optional outer message MIME type.
+ * @param options.fhirVersion Optional FHIR version parameter used in the MIME type.
+ */
+export function buildCommunicationBatchMessage(communication, options = {}) {
+    const communicationResource = ensureCommunicationResource(communication);
+    const thid = options.thid || `communication-${Date.now()}`;
+    const fhirVersion = options.fhirVersion || FhirVersions.R4;
+    return {
+        ...(options.jti ? { jti: options.jti } : {}),
+        ...(options.iss ? { iss: options.iss } : {}),
+        ...(options.aud ? { aud: options.aud } : {}),
+        thid,
+        type: options.messageType || `application/fhir+json; fhirVersion=${fhirVersion}`,
+        body: {
+            resourceType: ResourceTypesFhirR4.Bundle,
+            type: 'batch',
+            entry: [
+                {
+                    request: {
+                        method: 'POST',
+                        url: options.requestUrl || `individual/org.hl7.fhir.r4/${ResourceTypesFhirR4.Communication}`,
+                    },
+                    type: options.entryType || 'Communication-ingestion-request-v1.0',
+                    resource: cloneRecord(communicationResource),
+                },
+            ],
+        },
+    };
+}
+/**
+ * Adds a FHIR resource as a `Communication.payload` attachment.
+ *
+ * When `options.asDocumentReference` is enabled, the resource is first
+ * wrapped into a FHIR `DocumentReference` whose `content.attachment`
+ * contains the serialized resource.
+ *
+ * @param communication Target FHIR `Communication` resource.
+ * @param resource FHIR resource to attach.
+ * @param options.noteText Optional note text appended to `Communication.note`. FHIR allows markdown here.
+ * @param options.asDocumentReference Whether to wrap the resource into `DocumentReference`.
+ * @param options.documentReferenceIdentifier Optional `DocumentReference.identifier`.
+ * @param options.attachmentTitle Optional attachment filename/title.
+ * @param options.attachmentContentType Optional attachment MIME type.
+ * @param options.documentDescription Optional `DocumentReference.description`.
+ * @param options.documentDate Optional `DocumentReference.date`.
+ * @param options.documentSubject Optional `DocumentReference.subject.reference`.
+ */
+export function addFhirResourceToCommunication(communication, resource, options = {}) {
+    const nextCommunication = ensureCommunicationResource(communication);
+    const subjectReference = options.documentSubject
+        || (typeof nextCommunication.subject?.reference === 'string'
+            ? String(nextCommunication.subject.reference)
+            : undefined);
+    let payloadEntry;
+    if (options.asDocumentReference) {
+        const documentReference = {
+            resourceType: ResourceTypesFhirR4.DocumentReference,
+            content: [{
+                    attachment: buildAttachmentFromResource(resource, {
+                        contentType: options.attachmentContentType || 'application/fhir+json',
+                        title: options.attachmentTitle || `${String(resource.resourceType || 'resource').toLowerCase()}.json`,
+                    }),
+                }],
+        };
+        if (subjectReference)
+            documentReference.subject = { reference: subjectReference };
+        if (options.documentDate || getCanonicalDate(resource)) {
+            documentReference.date = options.documentDate || getCanonicalDate(resource);
+        }
+        if (options.documentDescription)
+            documentReference.description = options.documentDescription;
+        if (options.documentReferenceIdentifier) {
+            documentReference.identifier = [{ value: options.documentReferenceIdentifier }];
+        }
+        payloadEntry = {
+            contentAttachment: buildAttachmentFromResource(documentReference, {
+                contentType: 'application/fhir+json',
+                title: options.attachmentTitle || 'document-reference.json',
+            }),
+        };
+    }
+    else {
+        payloadEntry = {
+            contentAttachment: buildAttachmentFromResource(resource, {
+                contentType: options.attachmentContentType || 'application/fhir+json',
+                title: options.attachmentTitle || `${String(resource.resourceType || 'resource').toLowerCase()}.json`,
+            }),
+        };
+    }
+    return appendNoteText(appendPayload(nextCommunication, payloadEntry), resolveNoteText(options));
+}
+/**
+ * Adds a claims-only pseudo-resource into `Communication.payload`.
+ *
+ * The resource is created with `resourceType` plus `resource.meta.claims`
+ * and then attached using the same logic as `addFhirResourceToCommunication(...)`.
+ *
+ * @param communication Target FHIR `Communication` resource.
+ * @param resourceType FHIR `resourceType` name to materialize.
+ * @param claims Canonical interoperable claims to place under `meta.claims`.
+ * @param options Attachment/document wrapping options.
+ */
+export function addClaimsResourceToCommunication(communication, resourceType, claims, options = {}) {
+    const resource = {
+        resourceType,
+        meta: {
+            claims: cloneRecord(claims),
+        },
+    };
+    return addFhirResourceToCommunication(communication, resource, options);
+}
+/**
+ * Resolves every `Communication.payload[]` entry into a normalized shape.
+ *
+ * The resolver abstracts:
+ * - direct resource attachment
+ * - embedded `DocumentReference`
+ * - embedded `Bundle document`
+ * - best-effort note text associated to the payload slot
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export function resolveCommunicationPayloads(communication) {
+    const communicationResource = ensureCommunicationResource(communication);
+    const payload = Array.isArray(communicationResource.payload) ? communicationResource.payload : [];
+    const noteTexts = getCommunicationNoteTexts(communicationResource);
+    return payload.map((item, index) => {
+        const payloadEntry = isPlainObject(item) ? item : {};
+        const attachment = getPayloadAttachment(payloadEntry);
+        const directResource = parseAttachmentResource(attachment);
+        if (directResource?.resourceType === ResourceTypesFhirR4.DocumentReference) {
+            const documentReference = directResource;
+            const contentEntries = Array.isArray(documentReference.content)
+                ? documentReference.content
+                : [];
+            const innerAttachment = contentEntries.length
+                ? contentEntries
+                    .map((contentItem) => (isPlainObject(contentItem) ? contentItem.attachment : undefined))
+                    .find(isPlainObject)
+                : undefined;
+            const innerResource = parseAttachmentResource(innerAttachment);
+            return {
+                payloadIndex: index,
+                payloadType: attachment ? 'attachment' : 'reference',
+                documentReference,
+                bundle: innerResource?.resourceType === ResourceTypesFhirR4.Bundle ? innerResource : undefined,
+                resource: innerResource,
+                noteText: noteTexts[index] || noteTexts[0],
+            };
+        }
+        return {
+            payloadIndex: index,
+            payloadType: attachment ? 'attachment' : 'reference',
+            bundle: directResource?.resourceType === ResourceTypesFhirR4.Bundle ? directResource : undefined,
+            resource: directResource,
+            noteText: noteTexts[index] || noteTexts[0],
+            ...(getPayloadReference(payloadEntry) ? { documentReference: { reference: getPayloadReference(payloadEntry) } } : {}),
+        };
+    });
+}
+/**
+ * Returns the first FHIR `Bundle document` reachable from a `Communication`.
+ *
+ * It transparently supports direct bundle attachments and bundles wrapped
+ * inside `DocumentReference.content.attachment`.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export function getFirstBundleDocumentFromCommunication(communication) {
+    return resolveCommunicationPayloads(communication).find((entry) => entry.bundle)?.bundle;
+}
+/**
+ * Extracts concrete FHIR resources from a `Bundle.entry[].resource` list.
+ *
+ * @param bundle FHIR `Bundle` document.
+ */
+export function getBundleDocumentEntries(bundle) {
+    if (!bundle || bundle.resourceType !== ResourceTypesFhirR4.Bundle || !Array.isArray(bundle.entry))
+        return [];
+    return bundle.entry
+        .map((entry) => (isPlainObject(entry) && isPlainObject(entry.resource) ? entry.resource : undefined))
+        .filter((resource) => Boolean(resource));
+}
+/**
+ * Returns bundle resources filtered by `resourceType`.
+ *
+ * @param bundle FHIR `Bundle` document.
+ * @param resourceType FHIR `resourceType` name to keep.
+ */
+export function getBundleDocumentResourcesByType(bundle, resourceType) {
+    return getBundleDocumentEntries(bundle).filter((resource) => resource.resourceType === resourceType);
+}
+/**
+ * Extracts `MedicationStatement.meta.claims` rows from the first document
+ * bundle found inside a `Communication`.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export function getMedicationClaimsFromCommunicationDocument(communication) {
+    const bundle = getFirstBundleDocumentFromCommunication(communication);
+    return getBundleDocumentResourcesByType(bundle, ResourceTypesFhirR4.MedicationStatement)
+        .map((resource) => (isPlainObject(resource.meta) && isPlainObject(resource.meta.claims)
+        ? cloneRecord(resource.meta.claims)
+        : {}))
+        .filter((claims) => Object.keys(claims).length > 0);
+}
+/**
+ * Sorts FHIR resources by their first canonical clinical date descending.
+ *
+ * The helper inspects common date fields such as `effectiveDateTime`,
+ * `issued`, `authoredOn`, `performedDateTime`, `recordedDate`, `date`, and `sent`.
+ *
+ * @param resources Resources to sort.
+ */
+export function sortFhirResourcesByDateDescending(resources) {
+    return [...resources].sort((left, right) => {
+        const leftDate = getCanonicalDate(left) || '';
+        const rightDate = getCanonicalDate(right) || '';
+        return rightDate.localeCompare(leftDate);
+    });
+}
+/**
+ * Returns `Observation` resources from a communication document filtered by code.
+ *
+ * Accepted filter values may be bare codes or `<system>|<code>` tokens.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ * @param filter.code Optional single code filter.
+ * @param filter.codes Optional list of accepted codes.
+ */
+export function getObservationsByCodeFromCommunicationDocument(communication, filter) {
+    const accepted = new Set([filter.code, ...(filter.codes || [])]
+        .filter((value) => Boolean(value && value.trim()))
+        .map((value) => value.trim()));
+    const bundle = getFirstBundleDocumentFromCommunication(communication);
+    const observations = getBundleDocumentResourcesByType(bundle, ResourceTypesFhirR4.Observation);
+    if (!accepted.size)
+        return observations;
+    return observations.filter((resource) => {
+        const codeToken = getFirstCodingToken(resource.code?.coding ? [{ coding: resource.code.coding }] : []);
+        const categoryToken = getFirstCodingToken(resource.category);
+        return Boolean((codeToken && accepted.has(codeToken))
+            || (codeToken && accepted.has(codeToken.split('|').pop() || ''))
+            || (categoryToken && accepted.has(categoryToken)));
+    });
+}

package/dist/gdc-sdk-core-ts/src/consent-access.d.ts

@@ -0,0 +1,73 @@
+import type { ActiveConsentView, ConsentActorDescriptor, ConsentCoverageRequest, ConsentRuleMatch, EffectiveAccessEvaluation, MissingPermissionSet } from 'gdc-common-utils-ts/models/consent-access';
+import type { ConsentRule } from 'gdc-common-utils-ts/models/consent-rule';
+import type { BundleSearchQuery, CommunicationInput } from './communication-bundle-contracts.js';
+export type PermissionRequestCommunicationInput = Readonly<{
+    subject: string;
+    requester: ConsentActorDescriptor;
+    requesterRole?: string;
+    purpose?: string;
+    missing: MissingPermissionSet;
+    communicationIdentifier?: string;
+    thid?: string;
+    sender?: string;
+    recipient?: string | string[];
+    justification?: string;
+    documentContentCid?: string;
+}>;
+export type PermissionRequestCommunicationLookup = Readonly<{
+    subject: string;
+    communicationIdentifier?: string;
+    thid?: string;
+    contentCid?: string;
+}>;
+/**
+ * Runtime-neutral interface for subject consent providers.
+ */
+export interface ActiveConsentProvider {
+    getActiveConsentsForSubject(subject: string): Promise<ConsentRule[]>;
+}
+/**
+ * Fetches active consent rules for a subject from an injected provider and
+ * groups them by target family for controller-facing inspection.
+ *
+ * @param provider Consent provider abstraction.
+ * @param subject Subject identifier whose active consents must be loaded.
+ * @param now Optional evaluation timestamp.
+ */
+export declare function groupConsentsForControllerView(provider: ActiveConsentProvider, subject: string, now?: string | Date): Promise<ActiveConsentView>;
+/**
+ * Evaluates requested access against the full active consent set for a subject.
+ *
+ * @param provider Consent provider abstraction.
+ * @param request Access request to evaluate.
+ */
+export declare function evaluateRequestedAccess(provider: ActiveConsentProvider, request: ConsentCoverageRequest): Promise<EffectiveAccessEvaluation>;
+/**
+ * Returns the missing-permission projection for a consent evaluation.
+ *
+ * @param evaluation Result returned by `evaluateRequestedAccess(...)` or `evaluateConsentCoverage(...)`.
+ */
+export declare function getMissingPermissions(evaluation: EffectiveAccessEvaluation): MissingPermissionSet;
+/**
+ * Builds the canonical `Communication` payload used to request additional
+ * subject-controlled permissions when the current SMART request is not covered.
+ *
+ * Push/email/SMS remain notification channels around this canonical
+ * `Communication`, not the primary contract.
+ *
+ * @param input Permission-request details to encode.
+ */
+export declare function buildPermissionRequestCommunication(input: PermissionRequestCommunicationInput): CommunicationInput;
+/**
+ * Builds a canonical subject-scoped `Bundle/_search` query for recovering a
+ * permission-request `Communication` by stable identifiers.
+ *
+ * Retrieval keys supported by the current helper:
+ * - `Communication.identifier`
+ * - `thid`
+ * - `DocumentReference.contenthash` (`z<base58>` CID)
+ *
+ * @param input Stable lookup keys for the permission request.
+ */
+export declare function buildPermissionRequestCommunicationLookupQuery(input: PermissionRequestCommunicationLookup): BundleSearchQuery;
+export type { ActiveConsentView, ConsentActorDescriptor, ConsentCoverageRequest, ConsentRuleMatch, EffectiveAccessEvaluation, MissingPermissionSet, };

package/dist/gdc-sdk-core-ts/src/consent-access.js

@@ -0,0 +1,109 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { evaluateConsentCoverage, groupActiveConsentsByTarget, } from 'gdc-common-utils-ts/utils/consent';
+import { ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants/fhir-resource-types';
+import { CommunicationClaim } from 'gdc-common-utils-ts/models/interoperable-claims/communication-claims';
+/**
+ * Fetches active consent rules for a subject from an injected provider and
+ * groups them by target family for controller-facing inspection.
+ *
+ * @param provider Consent provider abstraction.
+ * @param subject Subject identifier whose active consents must be loaded.
+ * @param now Optional evaluation timestamp.
+ */
+export async function groupConsentsForControllerView(provider, subject, now) {
+    const rules = await provider.getActiveConsentsForSubject(subject);
+    return groupActiveConsentsByTarget(rules, { subject, now });
+}
+/**
+ * Evaluates requested access against the full active consent set for a subject.
+ *
+ * @param provider Consent provider abstraction.
+ * @param request Access request to evaluate.
+ */
+export async function evaluateRequestedAccess(provider, request) {
+    const rules = await provider.getActiveConsentsForSubject(String(request.subject || '').trim());
+    return evaluateConsentCoverage(rules, request);
+}
+/**
+ * Returns the missing-permission projection for a consent evaluation.
+ *
+ * @param evaluation Result returned by `evaluateRequestedAccess(...)` or `evaluateConsentCoverage(...)`.
+ */
+export function getMissingPermissions(evaluation) {
+    return evaluation.missing;
+}
+function compact(values) {
+    return values.map((value) => String(value || '').trim()).filter(Boolean);
+}
+/**
+ * Builds the canonical `Communication` payload used to request additional
+ * subject-controlled permissions when the current SMART request is not covered.
+ *
+ * Push/email/SMS remain notification channels around this canonical
+ * `Communication`, not the primary contract.
+ *
+ * @param input Permission-request details to encode.
+ */
+export function buildPermissionRequestCommunication(input) {
+    const requester = input.requester;
+    const requesterTargets = compact([
+        requester.did,
+        requester.email,
+        requester.phone,
+        requester.organizationDid,
+        requester.organizationUrl,
+        requester.jurisdiction,
+    ]);
+    const text = input.justification
+        || `Missing consent coverage for ${input.missing.sections.join(', ') || 'requested sections'}`
+            + `${input.missing.resourceTypes.length ? ` and ${input.missing.resourceTypes.join(', ')}` : ''}.`;
+    const claims = {
+        '@context': 'org.hl7.fhir.r4',
+        [CommunicationClaim.Identifier]: input.communicationIdentifier,
+        [CommunicationClaim.Subject]: input.subject,
+        [CommunicationClaim.Recipient]: input.recipient,
+        [CommunicationClaim.Sender]: input.sender,
+        'AccessRequest.requester-target': requesterTargets.join(','),
+        'AccessRequest.requester-role': input.requesterRole,
+        'AccessRequest.purpose': input.purpose,
+        'AccessRequest.missing-sections': input.missing.sections.join(','),
+        'AccessRequest.missing-resource-types': input.missing.resourceTypes.join(','),
+        'AccessRequest.document-content-cid': input.documentContentCid,
+    };
+    return {
+        thid: input.thid,
+        subject: input.subject,
+        sender: input.sender,
+        recipient: input.recipient,
+        category: ['permission-request'],
+        text,
+        claims,
+    };
+}
+/**
+ * Builds a canonical subject-scoped `Bundle/_search` query for recovering a
+ * permission-request `Communication` by stable identifiers.
+ *
+ * Retrieval keys supported by the current helper:
+ * - `Communication.identifier`
+ * - `thid`
+ * - `DocumentReference.contenthash` (`z<base58>` CID)
+ *
+ * @param input Stable lookup keys for the permission request.
+ */
+export function buildPermissionRequestCommunicationLookupQuery(input) {
+    const searchParams = {};
+    if (input.communicationIdentifier)
+        searchParams[CommunicationClaim.Identifier] = input.communicationIdentifier;
+    if (input.contentCid)
+        searchParams['DocumentReference.contenthash'] = input.contentCid;
+    return {
+        subject: input.subject,
+        includedTypes: [
+            ResourceTypesFhirR4.Communication,
+            ResourceTypesFhirR4.DocumentReference,
+        ],
+        thid: input.thid,
+        searchParams,
+    };
+}

package/dist/gdc-sdk-core-ts/src/consent-claim-helpers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export consent claim helpers from common-utils so SDK CORE consumers can
+ * discover and use the canonical get/set/add consent claim APIs from one place.
+ */
+export { addActorIdentifierList, addActorRoleList, addActors, addCategories, addCategoryList, addClaimValues, addPurposeList, addPurposes, addRoles, addSections, getActorIdentifierList, getActorRoleList, getActors, getCategories, getCategoryList, getClaimValues, getConsentDate, getConsentIdentifier, getConsentPeriodEnd, getConsentPeriodStart, getPurposeList, getPurposes, getRoles, getSections, removeActorIdentifierList, removeActorRoleList, removeActors, removeCategories, removeCategoryList, removeClaimValues, removePurposeList, removePurposes, removeRoles, removeSections, setActorIdentifierList, setActorRoleList, setActors, setCategories, setCategoryList, setClaimValues, setConsentDate, setConsentIdentifier, setConsentPeriodEnd, setConsentPeriodStart, setPurposeList, setPurposes, setRoles, setSections, type InteroperableClaims as ConsentInteroperableClaims, } from 'gdc-common-utils-ts';

package/dist/gdc-sdk-core-ts/src/consent-claim-helpers.js

@@ -0,0 +1,6 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+/**
+ * Re-export consent claim helpers from common-utils so SDK CORE consumers can
+ * discover and use the canonical get/set/add consent claim APIs from one place.
+ */
+export { addActorIdentifierList, addActorRoleList, addActors, addCategories, addCategoryList, addClaimValues, addPurposeList, addPurposes, addRoles, addSections, getActorIdentifierList, getActorRoleList, getActors, getCategories, getCategoryList, getClaimValues, getConsentDate, getConsentIdentifier, getConsentPeriodEnd, getConsentPeriodStart, getPurposeList, getPurposes, getRoles, getSections, removeActorIdentifierList, removeActorRoleList, removeActors, removeCategories, removeCategoryList, removeClaimValues, removePurposeList, removePurposes, removeRoles, removeSections, setActorIdentifierList, setActorRoleList, setActors, setCategories, setCategoryList, setClaimValues, setConsentDate, setConsentIdentifier, setConsentPeriodEnd, setConsentPeriodStart, setPurposeList, setPurposes, setRoles, setSections, } from 'gdc-common-utils-ts';