gdc-common-utils-ts 1.4.14 → 1.4.15

package/dist/models/bundle.d.ts

@@ -64,6 +64,7 @@ export interface BundleEntryResource {
         [key: string]: any;
     };
     resourceType?: string;
+    [key: string]: any;
 }
 /**
  * @deprecated Use `BundleEntry` instead. This will be removed in a future version.

package/dist/models/interoperable-claims/allergy-intolerance-claims.d.ts

@@ -0,0 +1,24 @@
+import type { ClaimSpec } from './types';
+export declare const AllergyIntoleranceClaim: {
+    readonly Identifier: "AllergyIntolerance.identifier";
+    readonly Subject: "AllergyIntolerance.subject";
+    /**
+     * @deprecated Use `AllergyIntolerance.subject`.
+     * Kept as compatibility alias because FHIR native field is `patient`.
+     */
+    readonly Patient: "AllergyIntolerance.patient";
+    readonly Code: "AllergyIntolerance.code";
+    readonly ClinicalStatus: "AllergyIntolerance.clinical-status";
+    readonly VerificationStatus: "AllergyIntolerance.verification-status";
+    readonly Category: "AllergyIntolerance.category";
+    readonly Criticality: "AllergyIntolerance.criticality";
+    readonly OnsetDateTime: "AllergyIntolerance.onset-datetime";
+    readonly Recorder: "AllergyIntolerance.recorder";
+};
+export type AllergyIntoleranceClaimKey = typeof AllergyIntoleranceClaim[keyof typeof AllergyIntoleranceClaim];
+/**
+ * http://hl7.org/fhir/uv/ips/ValueSet/allergies-intolerances-uv-ips
+ * Snomed IPS codes for allergy and intolerance categories: food, medication, environment, biologic.
+ * WHO ATC codes V01AA for Allergen extracts
+ */
+export declare const AllergyIntoleranceClaimSpecs: ClaimSpec[];

package/dist/models/interoperable-claims/allergy-intolerance-claims.js

@@ -0,0 +1,35 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/models/interoperable-claims/allergy-intolerance-claims.ts
+export const AllergyIntoleranceClaim = {
+    Identifier: 'AllergyIntolerance.identifier',
+    Subject: 'AllergyIntolerance.subject',
+    /**
+     * @deprecated Use `AllergyIntolerance.subject`.
+     * Kept as compatibility alias because FHIR native field is `patient`.
+     */
+    Patient: 'AllergyIntolerance.patient',
+    Code: 'AllergyIntolerance.code',
+    ClinicalStatus: 'AllergyIntolerance.clinical-status',
+    VerificationStatus: 'AllergyIntolerance.verification-status',
+    Category: 'AllergyIntolerance.category',
+    Criticality: 'AllergyIntolerance.criticality',
+    OnsetDateTime: 'AllergyIntolerance.onset-datetime',
+    Recorder: 'AllergyIntolerance.recorder',
+};
+/**
+ * http://hl7.org/fhir/uv/ips/ValueSet/allergies-intolerances-uv-ips
+ * Snomed IPS codes for allergy and intolerance categories: food, medication, environment, biologic.
+ * WHO ATC codes V01AA for Allergen extracts
+ */
+export const AllergyIntoleranceClaimSpecs = [
+    { key: AllergyIntoleranceClaim.Identifier, meaning: 'Business identifier for allergy record.', example: 'ALG-0001' },
+    { key: AllergyIntoleranceClaim.Subject, meaning: 'Canonical subject reference (maps to FHIR AllergyIntolerance.patient.reference).', example: 'urn:uuid:<UUID-V4>' },
+    { key: AllergyIntoleranceClaim.Patient, meaning: 'Deprecated alias of subject for compatibility.', example: 'urn:uuid:<UUID-V4>' },
+    { key: AllergyIntoleranceClaim.Code, meaning: 'Allergy or intolerance code.', example: 'http://snomed.info/sct|227493005' },
+    { key: AllergyIntoleranceClaim.ClinicalStatus, meaning: 'Clinical status code.', example: 'active' },
+    { key: AllergyIntoleranceClaim.VerificationStatus, meaning: 'Verification status code.', example: 'confirmed' },
+    { key: AllergyIntoleranceClaim.Category, meaning: 'Category value.', example: 'food' },
+    { key: AllergyIntoleranceClaim.Criticality, meaning: 'Criticality level.', example: 'high' },
+    { key: AllergyIntoleranceClaim.OnsetDateTime, meaning: 'Onset date/time.', example: '2026-01-10T10:00:00Z' },
+    { key: AllergyIntoleranceClaim.Recorder, meaning: 'Recorder reference.', example: 'did:web:<domain>:organization:taxid:<TAXID>:member:<MEMBER_ID>:<roleCode>' },
+];

package/dist/models/interoperable-claims/communication-claims.d.ts

@@ -10,6 +10,5 @@ export declare const CommunicationClaim: {
     readonly ContentAttachmentType: "Communication.content-attachment-type";
     readonly ContentAttachmentTitle: "Communication.content-attachment-title";
     readonly PartOf: "Communication.part-of";
-    readonly PartOfLegacy: "Communication.partOf";
 };
 export type CommunicationClaimKey = typeof CommunicationClaim[keyof typeof CommunicationClaim];

package/dist/models/interoperable-claims/communication-claims.js

@@ -11,6 +11,5 @@ export const CommunicationClaim = {
     ContentAttachmentData: 'Communication.content-attachment-data',
     ContentAttachmentType: 'Communication.content-attachment-type',
     ContentAttachmentTitle: 'Communication.content-attachment-title',
-    PartOf: 'Communication.part-of',
-    PartOfLegacy: 'Communication.partOf',
+    PartOf: 'Communication.part-of'
 };

package/dist/models/interoperable-claims/condition-claims.d.ts

@@ -0,0 +1,14 @@
+import type { ClaimSpec } from './types';
+export declare const ConditionClaim: {
+    readonly Identifier: "Condition.identifier";
+    readonly Subject: "Condition.subject";
+    readonly ClinicalStatus: "Condition.clinical-status";
+    readonly VerificationStatus: "Condition.verification-status";
+    readonly Category: "Condition.category";
+    readonly Code: "Condition.code";
+    readonly Severity: "Condition.severity";
+    readonly OnsetDateTime: "Condition.onset-datetime";
+    readonly Recorder: "Condition.recorder";
+};
+export type ConditionClaimKey = typeof ConditionClaim[keyof typeof ConditionClaim];
+export declare const ConditionClaimSpecs: ClaimSpec[];

package/dist/models/interoperable-claims/condition-claims.js

@@ -0,0 +1,24 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/models/interoperable-claims/condition-claims.ts
+export const ConditionClaim = {
+    Identifier: 'Condition.identifier',
+    Subject: 'Condition.subject',
+    ClinicalStatus: 'Condition.clinical-status',
+    VerificationStatus: 'Condition.verification-status',
+    Category: 'Condition.category',
+    Code: 'Condition.code',
+    Severity: 'Condition.severity',
+    OnsetDateTime: 'Condition.onset-datetime',
+    Recorder: 'Condition.recorder',
+};
+export const ConditionClaimSpecs = [
+    { key: ConditionClaim.Identifier, meaning: 'Business identifier for condition record.', example: 'COND-0001' },
+    { key: ConditionClaim.Subject, meaning: 'Patient subject reference.', example: 'Patient/pat-123' },
+    { key: ConditionClaim.ClinicalStatus, meaning: 'Clinical status code.', example: 'active' },
+    { key: ConditionClaim.VerificationStatus, meaning: 'Verification status code.', example: 'confirmed' },
+    { key: ConditionClaim.Category, meaning: 'Condition category code.', example: 'problem-list-item' },
+    { key: ConditionClaim.Code, meaning: 'Condition code.', example: 'http://snomed.info/sct|44054006' },
+    { key: ConditionClaim.Severity, meaning: 'Condition severity code.', example: 'http://snomed.info/sct|24484000' },
+    { key: ConditionClaim.OnsetDateTime, meaning: 'Onset date/time.', example: '2026-01-03T09:30:00Z' },
+    { key: ConditionClaim.Recorder, meaning: 'Recorder reference.', example: 'Practitioner/prac-2' },
+];

package/dist/models/interoperable-claims/device-use-statement-claims.d.ts

@@ -0,0 +1,13 @@
+import type { ClaimSpec } from './types';
+export declare const DeviceUseStatementClaim: {
+    readonly Identifier: "DeviceUseStatement.identifier";
+    readonly Subject: "DeviceUseStatement.subject";
+    readonly Status: "DeviceUseStatement.status";
+    readonly Device: "DeviceUseStatement.device";
+    readonly RecordedOn: "DeviceUseStatement.recordedon";
+    readonly TimingDateTime: "DeviceUseStatement.timing-datetime";
+    readonly ReasonCode: "DeviceUseStatement.reasoncode";
+    readonly Source: "DeviceUseStatement.source";
+};
+export type DeviceUseStatementClaimKey = typeof DeviceUseStatementClaim[keyof typeof DeviceUseStatementClaim];
+export declare const DeviceUseStatementClaimSpecs: ClaimSpec[];

package/dist/models/interoperable-claims/device-use-statement-claims.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/models/interoperable-claims/device-use-statement-claims.ts
+export const DeviceUseStatementClaim = {
+    Identifier: 'DeviceUseStatement.identifier',
+    Subject: 'DeviceUseStatement.subject',
+    Status: 'DeviceUseStatement.status',
+    Device: 'DeviceUseStatement.device',
+    RecordedOn: 'DeviceUseStatement.recordedon',
+    TimingDateTime: 'DeviceUseStatement.timing-datetime',
+    ReasonCode: 'DeviceUseStatement.reasoncode',
+    Source: 'DeviceUseStatement.source',
+};
+export const DeviceUseStatementClaimSpecs = [
+    { key: DeviceUseStatementClaim.Identifier, meaning: 'Business identifier for device-use record.', example: 'DUS-0001' },
+    { key: DeviceUseStatementClaim.Subject, meaning: 'Patient subject reference.', example: 'Patient/pat-123' },
+    { key: DeviceUseStatementClaim.Status, meaning: 'Use statement status.', example: 'active' },
+    { key: DeviceUseStatementClaim.Device, meaning: 'Device reference.', example: 'Device/dev-777' },
+    { key: DeviceUseStatementClaim.RecordedOn, meaning: 'Record creation date/time.', example: '2026-03-01T12:00:00Z' },
+    { key: DeviceUseStatementClaim.TimingDateTime, meaning: 'When the use happened.', example: '2026-03-01T08:00:00Z' },
+    { key: DeviceUseStatementClaim.ReasonCode, meaning: 'Reason code for use.', example: 'http://snomed.info/sct|182840001' },
+    { key: DeviceUseStatementClaim.Source, meaning: 'Source actor reference.', example: 'Practitioner/prac-8' },
+];

package/dist/models/interoperable-claims/document-reference-claims.d.ts

@@ -5,6 +5,7 @@ export declare const DocumentReferenceClaim: {
     readonly BasedOn: "DocumentReference.basedOn";
     readonly Category: "DocumentReference.category";
     readonly ContentData: "DocumentReference.contentdata";
+    readonly ContentHash: "DocumentReference.contenthash";
     readonly ContentType: "DocumentReference.contenttype";
     readonly Context: "DocumentReference.context";
     readonly Creation: "DocumentReference.creation";

package/dist/models/interoperable-claims/document-reference-claims.js

@@ -6,6 +6,7 @@ export const DocumentReferenceClaim = {
     BasedOn: 'DocumentReference.basedOn',
     Category: 'DocumentReference.category',
     ContentData: 'DocumentReference.contentdata',
+    ContentHash: 'DocumentReference.contenthash',
     ContentType: 'DocumentReference.contenttype',
     Context: 'DocumentReference.context',
     Creation: 'DocumentReference.creation',
@@ -33,6 +34,7 @@ export const DocumentReferenceClaimSpecs = [
     { key: DocumentReferenceClaim.BasedOn, meaning: 'URL of the source FHIR resource.', example: 'https://ehr.example.com/fhir/ServiceRequest/sr-991' },
     { key: DocumentReferenceClaim.Category, meaning: 'Higher-level document grouping.', example: 'http://hl7.org/fhir/ValueSet/document-classcodes|LP173418-7' },
     { key: DocumentReferenceClaim.ContentData, meaning: 'Embedded attachment as base64.', example: 'JVBERi0xLjc...' },
+    { key: DocumentReferenceClaim.ContentHash, meaning: 'Attachment content hash/CID used for retrieval and integrity checks.', example: 'z4EBG9jDwAxbThHs9AMGBy6dTN1P9fGEcXq6tCm1ugw3pV89Nsc' },
     { key: DocumentReferenceClaim.ContentType, meaning: 'Attachment MIME type.', example: 'application/pdf' },
     { key: DocumentReferenceClaim.Context, meaning: 'Context such as Appointment | Encounter | EpisodeOfCare.', example: 'Encounter/enc-123' },
     { key: DocumentReferenceClaim.Creation, meaning: 'When source information was created.', example: '2026-02-10T08:20:00Z' },
@@ -63,6 +65,10 @@ export const DocumentReferenceClaimToFhirPath = {
     [DocumentReferenceClaim.BasedOn]: 'DocumentReference.basedOn.reference',
     [DocumentReferenceClaim.Category]: 'DocumentReference.category.coding',
     [DocumentReferenceClaim.ContentData]: 'DocumentReference.content.attachment.data',
+    [DocumentReferenceClaim.ContentHash]: [
+        'DocumentReference.content.attachment.hash',
+        'DocumentReference.meta.versionId',
+    ],
     [DocumentReferenceClaim.ContentType]: 'DocumentReference.content.attachment.contentType',
     [DocumentReferenceClaim.Context]: 'DocumentReference.context',
     [DocumentReferenceClaim.Creation]: 'DocumentReference.content.attachment.creation',

package/dist/models/interoperable-claims/index.d.ts

@@ -3,5 +3,8 @@ export * from './composition-claims';
 export * from './communication-claims';
 export * from './document-reference-claims';
 export * from './medication-statement-claims';
+export * from './allergy-intolerance-claims';
+export * from './condition-claims';
+export * from './device-use-statement-claims';
 export * from './appointment-claims';
 export * from './appointment-response-claims';

package/dist/models/interoperable-claims/index.js

@@ -5,5 +5,8 @@ export * from './composition-claims.js';
 export * from './communication-claims.js';
 export * from './document-reference-claims.js';
 export * from './medication-statement-claims.js';
+export * from './allergy-intolerance-claims.js';
+export * from './condition-claims.js';
+export * from './device-use-statement-claims.js';
 export * from './appointment-claims.js';
 export * from './appointment-response-claims.js';

package/dist/utils/clinical-resource-converters.d.ts

@@ -0,0 +1,20 @@
+export type FlatClaims = Record<string, string | undefined>;
+export type FhirResource = Record<string, unknown> & {
+    resourceType: string;
+};
+/**
+ * Converts flat claims into a minimal MedicationStatement resource.
+ */
+export declare function medicationStatementFlatToFhir(claims: FlatClaims): FhirResource;
+/**
+ * Converts a minimal MedicationStatement resource to flat claims.
+ */
+export declare function medicationStatementFhirToFlat(resource: FhirResource): FlatClaims;
+export declare function allergyIntoleranceFlatToFhir(claims: FlatClaims): FhirResource;
+export declare function allergyIntoleranceFhirToFlat(resource: FhirResource): FlatClaims;
+export declare function conditionFlatToFhir(claims: FlatClaims): FhirResource;
+export declare function conditionFhirToFlat(resource: FhirResource): FlatClaims;
+export declare function deviceUseStatementFlatToFhir(claims: FlatClaims): FhirResource;
+export declare function deviceUseStatementFhirToFlat(resource: FhirResource): FlatClaims;
+export declare function documentReferenceFlatToFhir(claims: FlatClaims): FhirResource;
+export declare function documentReferenceFhirToFlat(resource: FhirResource): FlatClaims;

package/dist/utils/clinical-resource-converters.js

@@ -0,0 +1,179 @@
+// Copyright 2026 Conéctate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+// File: src/utils/clinical-resource-converters.ts
+import { DocumentReferenceClaim } from '../models/interoperable-claims/document-reference-claims.js';
+function codingFromValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    const [system, code] = value.split('|');
+    if (!code) {
+        return [{ code: system }];
+    }
+    return [{ system, code }];
+}
+function codingToValue(coding) {
+    if (!coding?.code) {
+        return undefined;
+    }
+    return coding.system ? `${coding.system}|${coding.code}` : coding.code;
+}
+function requireClaim(claims, key) {
+    const value = claims[key];
+    if (!value) {
+        throw new Error(`Missing required claim: ${key}`);
+    }
+    return value;
+}
+function requireSubjectIdentifier(value, key) {
+    if (!value.startsWith('urn:') && !value.startsWith('did:web:')) {
+        throw new Error(`Invalid ${key}: expected urn:* or did:web:*`);
+    }
+}
+function requireDidWeb(value, key) {
+    if (!value.startsWith('did:web:')) {
+        throw new Error(`Invalid ${key}: expected did:web:*`);
+    }
+}
+/**
+ * Converts flat claims into a minimal MedicationStatement resource.
+ */
+export function medicationStatementFlatToFhir(claims) {
+    const subject = requireClaim(claims, 'MedicationStatement.subject');
+    const status = requireClaim(claims, 'MedicationStatement.status');
+    return {
+        resourceType: 'MedicationStatement',
+        identifier: claims['MedicationStatement.identifier'] ? [{ value: claims['MedicationStatement.identifier'] }] : undefined,
+        status,
+        subject: { reference: subject },
+        effectiveDateTime: claims['MedicationStatement.effective'],
+        medicationCodeableConcept: claims['MedicationStatement.code']
+            ? { coding: codingFromValue(claims['MedicationStatement.code']) }
+            : undefined,
+    };
+}
+/**
+ * Converts a minimal MedicationStatement resource to flat claims.
+ */
+export function medicationStatementFhirToFlat(resource) {
+    return {
+        'MedicationStatement.identifier': resource.identifier?.[0]?.value,
+        'MedicationStatement.subject': resource.subject?.reference,
+        'MedicationStatement.status': resource.status,
+        'MedicationStatement.effective': resource.effectiveDateTime,
+        'MedicationStatement.code': codingToValue(resource.medicationCodeableConcept?.coding?.[0]),
+    };
+}
+export function allergyIntoleranceFlatToFhir(claims) {
+    const patient = claims['AllergyIntolerance.subject'] ?? claims['AllergyIntolerance.patient'];
+    if (!patient) {
+        throw new Error('Missing required claim: AllergyIntolerance.subject');
+    }
+    requireSubjectIdentifier(patient, 'AllergyIntolerance.subject');
+    if (claims['AllergyIntolerance.recorder']) {
+        requireDidWeb(claims['AllergyIntolerance.recorder'], 'AllergyIntolerance.recorder');
+    }
+    return {
+        resourceType: 'AllergyIntolerance',
+        identifier: claims['AllergyIntolerance.identifier'] ? [{ value: claims['AllergyIntolerance.identifier'] }] : undefined,
+        patient: { reference: patient },
+        code: claims['AllergyIntolerance.code'] ? { coding: codingFromValue(claims['AllergyIntolerance.code']) } : undefined,
+        clinicalStatus: claims['AllergyIntolerance.clinical-status']
+            ? { coding: [{ code: claims['AllergyIntolerance.clinical-status'] }] }
+            : undefined,
+        verificationStatus: claims['AllergyIntolerance.verification-status']
+            ? { coding: [{ code: claims['AllergyIntolerance.verification-status'] }] }
+            : undefined,
+        recorder: claims['AllergyIntolerance.recorder'] ? { reference: claims['AllergyIntolerance.recorder'] } : undefined,
+    };
+}
+export function allergyIntoleranceFhirToFlat(resource) {
+    const subject = resource.patient?.reference;
+    return {
+        'AllergyIntolerance.identifier': resource.identifier?.[0]?.value,
+        'AllergyIntolerance.subject': subject,
+        'AllergyIntolerance.patient': subject,
+        'AllergyIntolerance.code': codingToValue(resource.code?.coding?.[0]),
+        'AllergyIntolerance.clinical-status': resource.clinicalStatus?.coding?.[0]?.code,
+        'AllergyIntolerance.verification-status': resource.verificationStatus?.coding?.[0]?.code,
+        'AllergyIntolerance.recorder': resource.recorder?.reference,
+    };
+}
+export function conditionFlatToFhir(claims) {
+    const subject = requireClaim(claims, 'Condition.subject');
+    return {
+        resourceType: 'Condition',
+        identifier: claims['Condition.identifier'] ? [{ value: claims['Condition.identifier'] }] : undefined,
+        subject: { reference: subject },
+        code: claims['Condition.code'] ? { coding: codingFromValue(claims['Condition.code']) } : undefined,
+        clinicalStatus: claims['Condition.clinical-status'] ? { coding: [{ code: claims['Condition.clinical-status'] }] } : undefined,
+        verificationStatus: claims['Condition.verification-status'] ? { coding: [{ code: claims['Condition.verification-status'] }] } : undefined,
+    };
+}
+export function conditionFhirToFlat(resource) {
+    return {
+        'Condition.identifier': resource.identifier?.[0]?.value,
+        'Condition.subject': resource.subject?.reference,
+        'Condition.code': codingToValue(resource.code?.coding?.[0]),
+        'Condition.clinical-status': resource.clinicalStatus?.coding?.[0]?.code,
+        'Condition.verification-status': resource.verificationStatus?.coding?.[0]?.code,
+    };
+}
+export function deviceUseStatementFlatToFhir(claims) {
+    const subject = requireClaim(claims, 'DeviceUseStatement.subject');
+    const device = requireClaim(claims, 'DeviceUseStatement.device');
+    const status = requireClaim(claims, 'DeviceUseStatement.status');
+    return {
+        resourceType: 'DeviceUseStatement',
+        identifier: claims['DeviceUseStatement.identifier'] ? [{ value: claims['DeviceUseStatement.identifier'] }] : undefined,
+        subject: { reference: subject },
+        device: { reference: device },
+        status,
+        recordedOn: claims['DeviceUseStatement.recordedon'],
+        timingDateTime: claims['DeviceUseStatement.timing-datetime'],
+    };
+}
+export function deviceUseStatementFhirToFlat(resource) {
+    return {
+        'DeviceUseStatement.identifier': resource.identifier?.[0]?.value,
+        'DeviceUseStatement.subject': resource.subject?.reference,
+        'DeviceUseStatement.device': resource.device?.reference,
+        'DeviceUseStatement.status': resource.status,
+        'DeviceUseStatement.recordedon': resource.recordedOn,
+        'DeviceUseStatement.timing-datetime': resource.timingDateTime,
+    };
+}
+export function documentReferenceFlatToFhir(claims) {
+    const subject = requireClaim(claims, DocumentReferenceClaim.Subject);
+    return {
+        resourceType: 'DocumentReference',
+        identifier: claims[DocumentReferenceClaim.Identifier] ? [{ value: claims[DocumentReferenceClaim.Identifier] }] : undefined,
+        subject: { reference: subject },
+        description: claims[DocumentReferenceClaim.Description],
+        date: claims[DocumentReferenceClaim.Date],
+        content: [
+            {
+                attachment: {
+                    contentType: claims[DocumentReferenceClaim.ContentType],
+                    data: claims[DocumentReferenceClaim.ContentData],
+                    url: claims[DocumentReferenceClaim.Location],
+                    hash: claims[DocumentReferenceClaim.ContentHash],
+                    language: claims[DocumentReferenceClaim.Language],
+                },
+            },
+        ],
+    };
+}
+export function documentReferenceFhirToFlat(resource) {
+    const attachment = resource.content?.[0]?.attachment;
+    return {
+        [DocumentReferenceClaim.Identifier]: resource.identifier?.[0]?.value,
+        [DocumentReferenceClaim.Subject]: resource.subject?.reference,
+        [DocumentReferenceClaim.Description]: resource.description,
+        [DocumentReferenceClaim.Date]: resource.date,
+        [DocumentReferenceClaim.ContentType]: attachment?.contentType,
+        [DocumentReferenceClaim.ContentData]: attachment?.data,
+        [DocumentReferenceClaim.Location]: attachment?.url,
+        [DocumentReferenceClaim.ContentHash]: attachment?.hash,
+        [DocumentReferenceClaim.Language]: attachment?.language,
+    };
+}

package/dist/utils/communication-document-reference.d.ts

@@ -0,0 +1,29 @@
+import { EvidenceObjectDLT } from '../models/oidc4ida.evidence.model';
+export type AttachmentKind = 'fhir' | 'pdf' | 'png' | 'jpg' | 'binary';
+export type BuildMode = 'strict' | 'normalize';
+export type BuildDocumentReferenceOptions = {
+    /**
+     * strict: validation errors throw.
+     * normalize: best-effort defaults + warnings.
+     */
+    mode?: BuildMode;
+};
+export type BuildDocumentReferenceResult = {
+    /**
+     * Generated or normalized DocumentReference projection.
+     *
+     * Current simplified profile:
+     * - one Communication payload attachment -> one DocumentReference
+     * - one DocumentReference content[0].attachment
+     */
+    documentReference: Record<string, any>;
+    /**
+     * CID for the attached artifact content.
+     * Used as version-like content fingerprint in this profile.
+     */
+    contentCid: string;
+    evidence: EvidenceObjectDLT[];
+    warnings: string[];
+};
+export declare function detectAttachmentKind(contentType?: string): AttachmentKind;
+export declare function buildDocumentReferenceFromCommunicationPayload(communication: Record<string, any>, options?: BuildDocumentReferenceOptions): BuildDocumentReferenceResult;

package/dist/utils/communication-document-reference.js

@@ -0,0 +1,152 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import { utf8ToBytes } from '@noble/hashes/utils.js';
+import { encodeMultibase58btc } from './multibase58.js';
+import { canonicalizeFhirResource, fhirResourceToCid } from './fhir-cid.js';
+const CID_V1 = 0x01;
+const MULTICODEC_RAW = 0x55;
+const MULTIHASH_SHA2_256_CODE = 0x12;
+const MULTIHASH_SHA2_256_LEN = 32;
+function encodeVarint(value) {
+    const out = [];
+    let n = value >>> 0;
+    while (n >= 0x80) {
+        out.push((n & 0x7f) | 0x80);
+        n >>>= 7;
+    }
+    out.push(n);
+    return Uint8Array.from(out);
+}
+function concatBytes(...parts) {
+    const total = parts.reduce((acc, part) => acc + part.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+function cidFromBytes(bytes) {
+    const digest = sha256(bytes);
+    const multihash = concatBytes(Uint8Array.from([MULTIHASH_SHA2_256_CODE, MULTIHASH_SHA2_256_LEN]), digest);
+    const cidBytes = concatBytes(encodeVarint(CID_V1), encodeVarint(MULTICODEC_RAW), multihash);
+    return encodeMultibase58btc(cidBytes);
+}
+function decodeBase64(data) {
+    return Uint8Array.from(Buffer.from(data, 'base64'));
+}
+function toStringOrUndefined(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value).trim();
+    return text || undefined;
+}
+export function detectAttachmentKind(contentType) {
+    const ct = String(contentType || '').toLowerCase();
+    if (ct.includes('fhir') || ct.includes('application/json+fhir'))
+        return 'fhir';
+    if (ct === 'application/pdf')
+        return 'pdf';
+    if (ct === 'image/png')
+        return 'png';
+    if (ct === 'image/jpg' || ct === 'image/jpeg')
+        return 'jpg';
+    return 'binary';
+}
+function buildEvidenceForKind(kind, cid) {
+    if (kind === 'pdf') {
+        return {
+            type: 'electronic_signature',
+            signature_type: 'detached',
+            issuer: 'did:web:unknown',
+            serial_number: cid,
+            created_at: new Date().toISOString(),
+            attachments: [{ content_type: 'cid', content: cid }],
+        };
+    }
+    return {
+        type: 'electronic_record',
+        record: { type: kind.toUpperCase(), source: 'Communication.payload.contentAttachment', digest: { alg: 'sha-256', value: cid } },
+        check_details: [],
+    };
+}
+function isCidLike(value) {
+    return !!value && value.startsWith('z') && value.length > 10;
+}
+export function buildDocumentReferenceFromCommunicationPayload(communication, options = {}) {
+    /**
+     * Data model notes:
+     * - FHIR DocumentReference logical identifier and version are distinct concerns.
+     * - Current implementation uses content CID for claims identifier/version-like tracking.
+     * - Future target profile should keep stable DocumentReference.identifier (UUID/URN) and
+     *   store evolving content CID in meta.versionId/content hash fields across versions.
+     * - Multi-attachment DocumentReference content[i] is intentionally out of scope for now;
+     *   roadmap can introduce indexed flat claims such as DocumentReference.attachment[i]-*.
+     */
+    const mode = options.mode ?? 'strict';
+    const warnings = [];
+    const payload = communication?.payload?.[0];
+    const attachment = payload?.contentAttachment;
+    if (!attachment) {
+        throw new Error('Communication payload with contentAttachment is required.');
+    }
+    const contentType = toStringOrUndefined(attachment.contentType) || 'application/octet-stream';
+    if (!attachment.contentType && mode === 'normalize') {
+        warnings.push('Missing contentAttachment.contentType. Defaulting to application/octet-stream.');
+    }
+    const dataBase64 = toStringOrUndefined(attachment.data);
+    const url = toStringOrUndefined(attachment.url);
+    if (!dataBase64 && !url && mode === 'strict') {
+        throw new Error('contentAttachment requires data or url.');
+    }
+    const kind = detectAttachmentKind(contentType);
+    let contentCid = toStringOrUndefined(attachment.id);
+    if (!isCidLike(contentCid)) {
+        if (kind === 'fhir' && dataBase64) {
+            const json = Buffer.from(dataBase64, 'base64').toString('utf8');
+            const parsed = JSON.parse(json);
+            const canonical = canonicalizeFhirResource(parsed);
+            contentCid = fhirResourceToCid(JSON.parse(canonical)).cid;
+        }
+        else if (dataBase64) {
+            contentCid = cidFromBytes(decodeBase64(dataBase64));
+        }
+        else {
+            contentCid = cidFromBytes(utf8ToBytes(url || 'empty-content'));
+        }
+    }
+    if (!contentCid) {
+        throw new Error('Unable to generate content CID from attachment.');
+    }
+    const subject = communication?.meta?.claims?.['Communication.subject'];
+    const documentReference = {
+        resourceType: 'DocumentReference',
+        status: 'current',
+        meta: {
+            versionId: contentCid,
+            claims: {
+                'DocumentReference.subject': subject,
+                'DocumentReference.contenttype': contentType,
+                'DocumentReference.identifier': contentCid,
+            },
+        },
+        subject: subject ? { reference: subject } : undefined,
+        content: [
+            {
+                attachment: {
+                    id: contentCid,
+                    contentType,
+                    data: dataBase64,
+                    url,
+                    title: toStringOrUndefined(attachment.title),
+                },
+            },
+        ],
+    };
+    return {
+        documentReference,
+        contentCid,
+        evidence: [buildEvidenceForKind(kind, contentCid)],
+        warnings,
+    };
+}

package/dist/utils/index.d.ts

@@ -11,6 +11,8 @@ export * from './didcomm-submit-policy';
 export * from './format-converter';
 export * from './fhir-cid';
 export * from './communication-fhir-r4';
+export * from './communication-document-reference';
+export * from './clinical-resource-converters';
 export * from './fhir-validator';
 export * from './jwt';
 export * from './manager-error';

package/dist/utils/index.js

@@ -11,6 +11,8 @@ export * from './didcomm-submit-policy.js';
 export * from './format-converter.js';
 export * from './fhir-cid.js';
 export * from './communication-fhir-r4.js';
+export * from './communication-document-reference.js';
+export * from './clinical-resource-converters.js';
 export * from './fhir-validator.js';
 export * from './jwt.js';
 export * from './manager-error.js';

package/dist/utils/vp-token.d.ts

@@ -28,6 +28,9 @@ export declare function buildEpochWindow(ttlSeconds?: number): {
 };
 export declare function createVP(input?: Partial<VpTokenPayload>): VpTokenPayload;
 export declare function addVC(vpPayload: VpTokenPayload, vcJwt: string): VpTokenPayload;
+export declare function addVCs(vpPayload: VpTokenPayload, vcs: string[]): VpTokenPayload;
+export declare function addOrganizationCredential(vpPayload: VpTokenPayload, vc: string): VpTokenPayload;
+export declare function addLegalRepresentativeCredential(vpPayload: VpTokenPayload, vc: string): VpTokenPayload;
 export declare function prepareForSignature(header: VpTokenHeader, payload: VpTokenPayload): {
     encodedHeader: string;
     encodedPayload: string;

package/dist/utils/vp-token.js

@@ -42,6 +42,58 @@ export function addVC(vpPayload, vcJwt) {
     vpPayload.vp.verifiableCredential.push(v);
     return vpPayload;
 }
+export function addVCs(vpPayload, vcs) {
+    for (const vc of vcs || [])
+        addVC(vpPayload, vc);
+    return vpPayload;
+}
+function decodeVcPayload(vc) {
+    const raw = String(vc || '').trim();
+    if (!raw)
+        return undefined;
+    if (raw.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed && typeof parsed === 'object' ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const parts = raw.split('.');
+    if (parts.length !== 3 || !parts[1])
+        return undefined;
+    try {
+        const payloadJson = Buffer.from(parts[1], 'base64url').toString('utf8');
+        const parsed = JSON.parse(payloadJson);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function vcHasAnyType(vcPayload, acceptedTypes) {
+    if (!vcPayload)
+        return false;
+    const typeRaw = vcPayload?.type
+        ?? vcPayload?.vc?.type
+        ?? vcPayload?.credential?.type;
+    const types = Array.isArray(typeRaw) ? typeRaw.map(String) : [String(typeRaw || '')];
+    return acceptedTypes.some((t) => types.includes(t));
+}
+function addTypedVC(vpPayload, vc, acceptedTypes, label) {
+    const payload = decodeVcPayload(vc);
+    if (!vcHasAnyType(payload, acceptedTypes)) {
+        throw new Error(`${label} VC must include one of types: ${acceptedTypes.join(', ')}`);
+    }
+    return addVC(vpPayload, vc);
+}
+export function addOrganizationCredential(vpPayload, vc) {
+    return addTypedVC(vpPayload, vc, ['OrganizationCredential', 'LegalOrganizationCredential'], 'Organization');
+}
+export function addLegalRepresentativeCredential(vpPayload, vc) {
+    return addTypedVC(vpPayload, vc, ['LegalRepresentativeCredential', 'PersonCredential'], 'LegalRepresentative');
+}
 export function prepareForSignature(header, payload) {
     const encodedHeader = Content.objectToRawBase64UrlSafe(header);
     const encodedPayload = Content.objectToRawBase64UrlSafe(payload);

package/package.json

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