fhir-data-utils-ts 0.6.11 → 0.6.13

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+- Add a reusable, data-only `CommunicationRequest` form schema backed by
+  canonical flat claims, including exact Patient, RelatedPerson or Group
+  recipients, information providers, Encounter context and referenced or
+  attached payloads. Projection adapters are deliberately limited to the
+  published FHIR R4 and R5 specifications; no R6 API is exposed.
+
+- Canonicalize native FHIR relative subject references at the shared clinical
+  editor boundary before claims-first operations, while preserving governed
+  URN and `did:web` identifiers unchanged.
+
 - Add the shared clinical-artifact editor boundary for native FHIR R4 imports:
   hydrate only schema-owned fields, materialize supported IPS resources from
   editor plus host-owned claims, and prove FHIR-to-form-to-FHIR semantic

package/README.md

@@ -216,6 +216,20 @@ CommunicationRequest against a frozen Group snapshot. See
 [the contract guide](docs/CARE_EMERGENCY_ALERT_CONTRACTS.md). Product policy,
 access, encryption and delivery do not belong in these builders.
 
+## Communication request authoring
+
+`FHIR_COMMUNICATION_REQUEST_FORM_SCHEMA` and its typed adapters are exported
+from `fhir-data-utils-ts/data`. They let Personal and Professional portals use
+the same fields while keeping UI labels, widgets and authorization outside this
+package. Recipients remain exact FHIR references, so a request can target the
+patient and only the authorized `RelatedPerson` records selected for that
+message. `requester` records who prepared the request and
+`informationProviders` records the professionals expected to supply or review
+its content; neither field grants permission by itself.
+
+The package exposes separate `CommunicationRequest` projections for published
+FHIR R4 and FHIR R5. It intentionally exposes no R6 or combined R5/R6 adapter.
+
 ## Clinical documents and Encounter journeys
 
 A FHIR document always starts with `Composition`; `Encounter` is its optional

package/dist/claims/communication-request-claims.d.ts

@@ -3,19 +3,31 @@ import type { ClaimSpec } from './claim-types.js';
 export declare const CommunicationRequestClaim: Readonly<{
     readonly Identifier: "CommunicationRequest.identifier";
     readonly BasedOn: "CommunicationRequest.based-on";
+    readonly Replaces: "CommunicationRequest.replaces";
+    readonly GroupIdentifier: "CommunicationRequest.group-identifier";
     readonly Status: "CommunicationRequest.status";
+    readonly StatusReason: "CommunicationRequest.status-reason";
+    readonly Intent: "CommunicationRequest.intent";
     readonly Priority: "CommunicationRequest.priority";
     readonly Category: "CommunicationRequest.category";
+    readonly DoNotPerform: "CommunicationRequest.do-not-perform";
+    readonly Medium: "CommunicationRequest.medium";
     readonly Subject: "CommunicationRequest.subject";
     readonly About: "CommunicationRequest.about";
     readonly Encounter: "CommunicationRequest.encounter";
     readonly Requester: "CommunicationRequest.requester";
     readonly Recipient: "CommunicationRequest.recipient";
+    readonly InformationProvider: "CommunicationRequest.information-provider";
     readonly AuthoredOn: "CommunicationRequest.authored-on";
     readonly Occurrence: "CommunicationRequest.occurrence";
     readonly ReasonCode: "CommunicationRequest.reason-code";
     readonly ReasonReference: "CommunicationRequest.reason-reference";
     readonly PayloadContent: "CommunicationRequest.payload-content";
+    readonly PayloadReference: "CommunicationRequest.payload-reference";
+    readonly PayloadAttachmentContentType: "CommunicationRequest.payload-attachment-content-type";
+    readonly PayloadAttachmentData: "CommunicationRequest.payload-attachment-data";
+    readonly PayloadAttachmentTitle: "CommunicationRequest.payload-attachment-title";
+    readonly Note: "CommunicationRequest.note";
 }>;
 export type CommunicationRequestClaimKey = typeof CommunicationRequestClaim[keyof typeof CommunicationRequestClaim];
 export declare const CommunicationRequestClaimSpecs: readonly ClaimSpec[];

package/dist/claims/communication-request-claims.js

@@ -2,26 +2,58 @@
 export const CommunicationRequestClaim = Object.freeze({
     Identifier: 'CommunicationRequest.identifier',
     BasedOn: 'CommunicationRequest.based-on',
+    Replaces: 'CommunicationRequest.replaces',
+    GroupIdentifier: 'CommunicationRequest.group-identifier',
     Status: 'CommunicationRequest.status',
+    StatusReason: 'CommunicationRequest.status-reason',
+    Intent: 'CommunicationRequest.intent',
     Priority: 'CommunicationRequest.priority',
     Category: 'CommunicationRequest.category',
+    DoNotPerform: 'CommunicationRequest.do-not-perform',
+    Medium: 'CommunicationRequest.medium',
     Subject: 'CommunicationRequest.subject',
     About: 'CommunicationRequest.about',
     Encounter: 'CommunicationRequest.encounter',
     Requester: 'CommunicationRequest.requester',
     Recipient: 'CommunicationRequest.recipient',
+    InformationProvider: 'CommunicationRequest.information-provider',
     AuthoredOn: 'CommunicationRequest.authored-on',
     Occurrence: 'CommunicationRequest.occurrence',
     ReasonCode: 'CommunicationRequest.reason-code',
     ReasonReference: 'CommunicationRequest.reason-reference',
     PayloadContent: 'CommunicationRequest.payload-content',
+    PayloadReference: 'CommunicationRequest.payload-reference',
+    PayloadAttachmentContentType: 'CommunicationRequest.payload-attachment-content-type',
+    PayloadAttachmentData: 'CommunicationRequest.payload-attachment-data',
+    PayloadAttachmentTitle: 'CommunicationRequest.payload-attachment-title',
+    Note: 'CommunicationRequest.note',
 });
 export const CommunicationRequestClaimSpecs = Object.freeze([
     { key: CommunicationRequestClaim.Identifier, meaning: 'Business identifier.', example: 'urn:uuid:campaign-1' },
+    { key: CommunicationRequestClaim.BasedOn, meaning: 'Requests fulfilled in whole or in part.', example: 'ServiceRequest/request-1' },
+    { key: CommunicationRequestClaim.Replaces, meaning: 'Earlier requests superseded by this request.', example: 'CommunicationRequest/request-0' },
+    { key: CommunicationRequestClaim.GroupIdentifier, meaning: 'Shared identifier for one request group.', example: 'urn:uuid:request-group-1' },
     { key: CommunicationRequestClaim.Status, meaning: 'Request lifecycle status.', example: 'active' },
+    { key: CommunicationRequestClaim.StatusReason, meaning: 'Coded explanation for the lifecycle status.', example: 'http://terminology.hl7.org/CodeSystem/request-status-reason|paused' },
+    { key: CommunicationRequestClaim.Intent, meaning: 'Published R5 request intent.', example: 'proposal' },
     { key: CommunicationRequestClaim.Priority, meaning: 'Delivery priority.', example: 'routine' },
     { key: CommunicationRequestClaim.Category, meaning: 'Communication category token.', example: 'http://terminology.hl7.org/CodeSystem/communication-category|notification' },
+    { key: CommunicationRequestClaim.DoNotPerform, meaning: 'Whether the requested communication must not occur.', example: 'false' },
+    { key: CommunicationRequestClaim.Medium, meaning: 'Requested communication medium token.', example: 'http://terminology.hl7.org/CodeSystem/v3-ParticipationMode|WRITTEN' },
     { key: CommunicationRequestClaim.Subject, meaning: 'Subject or evaluated Group reference.', example: 'Group/snapshot-1' },
+    { key: CommunicationRequestClaim.About, meaning: 'Resources that the communication request concerns.', example: 'DiagnosticReport/report-1' },
+    { key: CommunicationRequestClaim.Encounter, meaning: 'Encounter context for the request.', example: 'Encounter/emergency-1' },
     { key: CommunicationRequestClaim.Requester, meaning: 'Requesting organization or service.', example: 'Organization/blood-bank-1' },
+    { key: CommunicationRequestClaim.Recipient, meaning: 'Exact intended recipient references.', example: 'Patient/patient-1,RelatedPerson/family-1' },
+    { key: CommunicationRequestClaim.InformationProvider, meaning: 'Actors expected to provide or review message information.', example: 'PractitionerRole/doctor-1' },
     { key: CommunicationRequestClaim.AuthoredOn, meaning: 'Request authoring time.', example: '2026-09-26T11:00:00Z' },
+    { key: CommunicationRequestClaim.Occurrence, meaning: 'Requested delivery time.', example: '2026-09-26T11:30:00Z' },
+    { key: CommunicationRequestClaim.ReasonCode, meaning: 'Coded reasons for the request.', example: 'http://snomed.info/sct|246205007' },
+    { key: CommunicationRequestClaim.ReasonReference, meaning: 'Resource references supporting the request reason.', example: 'Condition/condition-1' },
+    { key: CommunicationRequestClaim.PayloadContent, meaning: 'R4 string payload compatibility value.', example: 'Family update ready for review.' },
+    { key: CommunicationRequestClaim.PayloadReference, meaning: 'Referenced message content.', example: 'DocumentReference/update-1' },
+    { key: CommunicationRequestClaim.PayloadAttachmentContentType, meaning: 'Attachment media type.', example: 'application/pdf' },
+    { key: CommunicationRequestClaim.PayloadAttachmentData, meaning: 'Base64-encoded attachment data.', example: 'JVBERi0xLjQ=' },
+    { key: CommunicationRequestClaim.PayloadAttachmentTitle, meaning: 'Human-readable attachment title.', example: 'Clinical update' },
+    { key: CommunicationRequestClaim.Note, meaning: 'Request note.', example: 'Call before sending.' },
 ]);

package/dist/clinical-artifact-editor.d.ts

@@ -2,6 +2,12 @@ import { type FhirIpsClinicalArtifactSchema, type FhirIpsClinicalArtifactType }
 export type ClinicalArtifactFhirR4Resource = Readonly<Record<string, unknown> & {
     resourceType: FhirIpsClinicalArtifactType;
 }>;
+/**
+ * Converts a native FHIR relative subject reference into the canonical actor
+ * reference accepted by claims-first persistence. Existing governed URNs and
+ * did:web identifiers pass through unchanged.
+ */
+export declare function canonicalClinicalSubjectReference(subjectReference: string): string;
 /** Host-owned subject claims added only at the trusted materialization boundary. */
 export declare function clinicalArtifactSubjectClaims(resourceType: FhirIpsClinicalArtifactType, subjectReference: string): Readonly<Record<string, string>>;
 /**

package/dist/clinical-artifact-editor.js

@@ -7,6 +7,20 @@ import { ImmunizationClaim } from './claims/immunization-claims.js';
 import { MedicationStatementClaim } from './claims/medication-statement-claims.js';
 import { ProcedureClaim } from './claims/procedure-claims.js';
 import { ObservationClaim } from './observation-claims.js';
+/**
+ * Converts a native FHIR relative subject reference into the canonical actor
+ * reference accepted by claims-first persistence. Existing governed URNs and
+ * did:web identifiers pass through unchanged.
+ */
+export function canonicalClinicalSubjectReference(subjectReference) {
+    const normalized = subjectReference.trim();
+    if (/^(?:urn:[^\s]+|did:web:[^\s]+)$/.test(normalized))
+        return normalized;
+    const relativeReference = /^[A-Z][A-Za-z]+\/([^/\s]+)$/.exec(normalized);
+    if (!relativeReference)
+        throw new TypeError('clinical_artifact_subject_reference_invalid');
+    return `urn:uuid:${relativeReference[1]}`;
+}
 /** Host-owned subject claims added only at the trusted materialization boundary. */
 export function clinicalArtifactSubjectClaims(resourceType, subjectReference) {
     const claim = {
@@ -17,7 +31,7 @@ export function clinicalArtifactSubjectClaims(resourceType, subjectReference) {
         [FhirIpsClinicalArtifactTypes.Procedure]: ProcedureClaim.Subject,
         [FhirIpsClinicalArtifactTypes.Observation]: ObservationClaim.Subject,
     }[resourceType];
-    return Object.freeze({ [claim]: subjectReference });
+    return Object.freeze({ [claim]: canonicalClinicalSubjectReference(subjectReference) });
 }
 /**
  * Hydrates one schema-driven editor from a native FHIR R4 resource.

package/dist/converters/convert-communication-request.d.ts

@@ -3,3 +3,7 @@ import type { FhirResource, FlatClaims } from './convert-shared.js';
 export declare function communicationRequestFlatToFhirR4(claims: FlatClaims): FhirResource;
 /** Reads a FHIR R4 CommunicationRequest into canonical flat claims. */
 export declare function communicationRequestFhirR4ToFlat(resource: FhirResource): FlatClaims;
+/** Projects canonical claims to the published FHIR R5 shape. */
+export declare function communicationRequestFlatToFhirR5(claims: FlatClaims): FhirResource;
+/** Reads a published FHIR R5 CommunicationRequest into canonical flat claims. */
+export declare function communicationRequestFhirR5ToFlat(resource: FhirResource): FlatClaims;

package/dist/converters/convert-communication-request.js

@@ -4,37 +4,174 @@ import { codingFromValue, codingListFromCsv, codingListToCsv, codingToValue, ref
 export function communicationRequestFlatToFhirR4(claims) {
     return {
         resourceType: 'CommunicationRequest', identifier: claims[CommunicationRequestClaim.Identifier] ? [{ value: claims[CommunicationRequestClaim.Identifier] }] : undefined,
-        basedOn: referenceCsv(claims[CommunicationRequestClaim.BasedOn]), status: claims[CommunicationRequestClaim.Status], priority: claims[CommunicationRequestClaim.Priority],
+        basedOn: referenceCsv(claims[CommunicationRequestClaim.BasedOn]),
+        replaces: referenceCsv(claims[CommunicationRequestClaim.Replaces]),
+        groupIdentifier: claims[CommunicationRequestClaim.GroupIdentifier] ? { value: claims[CommunicationRequestClaim.GroupIdentifier] } : undefined,
+        status: claims[CommunicationRequestClaim.Status],
+        statusReason: codeableConcept(claims[CommunicationRequestClaim.StatusReason]),
+        priority: claims[CommunicationRequestClaim.Priority],
         category: claims[CommunicationRequestClaim.Category] ? [{ coding: codingFromValue(claims[CommunicationRequestClaim.Category]) }] : undefined,
+        doNotPerform: optionalBoolean(claims[CommunicationRequestClaim.DoNotPerform]),
+        medium: claims[CommunicationRequestClaim.Medium] ? [{ coding: codingFromValue(claims[CommunicationRequestClaim.Medium]) }] : undefined,
         subject: claims[CommunicationRequestClaim.Subject] ? { reference: claims[CommunicationRequestClaim.Subject] } : undefined,
         about: referenceCsv(claims[CommunicationRequestClaim.About]), encounter: claims[CommunicationRequestClaim.Encounter] ? { reference: claims[CommunicationRequestClaim.Encounter] } : undefined,
         requester: claims[CommunicationRequestClaim.Requester] ? { reference: claims[CommunicationRequestClaim.Requester] } : undefined,
+        sender: firstReference(claims[CommunicationRequestClaim.InformationProvider]),
         recipient: referenceCsv(claims[CommunicationRequestClaim.Recipient]), authoredOn: claims[CommunicationRequestClaim.AuthoredOn],
         occurrenceDateTime: claims[CommunicationRequestClaim.Occurrence],
         reasonCode: claims[CommunicationRequestClaim.ReasonCode] ? [{ coding: codingListFromCsv(claims[CommunicationRequestClaim.ReasonCode]) }] : undefined,
         reasonReference: referenceCsv(claims[CommunicationRequestClaim.ReasonReference]),
-        payload: claims[CommunicationRequestClaim.PayloadContent] ? [{ contentString: claims[CommunicationRequestClaim.PayloadContent] }] : undefined,
+        payload: payloadR4(claims),
+        note: annotation(claims[CommunicationRequestClaim.Note]),
     };
 }
 /** Reads a FHIR R4 CommunicationRequest into canonical flat claims. */
 export function communicationRequestFhirR4ToFlat(resource) {
-    return {
+    return compact({
         [CommunicationRequestClaim.Identifier]: resource.identifier?.[0]?.value,
         [CommunicationRequestClaim.BasedOn]: referenceListToCsv(resource.basedOn),
-        [CommunicationRequestClaim.Status]: resource.status, [CommunicationRequestClaim.Priority]: resource.priority,
+        [CommunicationRequestClaim.Replaces]: referenceListToCsv(resource.replaces),
+        [CommunicationRequestClaim.GroupIdentifier]: resource.groupIdentifier?.value,
+        [CommunicationRequestClaim.Status]: resource.status,
+        [CommunicationRequestClaim.StatusReason]: codeableConceptToValue(resource.statusReason),
+        [CommunicationRequestClaim.Priority]: resource.priority,
         [CommunicationRequestClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [CommunicationRequestClaim.DoNotPerform]: typeof resource.doNotPerform === 'boolean' ? String(resource.doNotPerform) : undefined,
+        [CommunicationRequestClaim.Medium]: codingToValue(resource.medium?.[0]?.coding?.[0]),
         [CommunicationRequestClaim.Subject]: referenceToValue(resource.subject),
         [CommunicationRequestClaim.About]: referenceListToCsv(resource.about),
         [CommunicationRequestClaim.Encounter]: referenceToValue(resource.encounter),
         [CommunicationRequestClaim.Requester]: referenceToValue(resource.requester),
+        [CommunicationRequestClaim.InformationProvider]: referenceToValue(resource.sender),
         [CommunicationRequestClaim.Recipient]: referenceListToCsv(resource.recipient),
         [CommunicationRequestClaim.AuthoredOn]: resource.authoredOn, [CommunicationRequestClaim.Occurrence]: resource.occurrenceDateTime,
         [CommunicationRequestClaim.ReasonCode]: codingListToCsv(resource.reasonCode?.flatMap(value => value.coding ?? [])),
         [CommunicationRequestClaim.ReasonReference]: referenceListToCsv(resource.reasonReference),
-        [CommunicationRequestClaim.PayloadContent]: resource.payload?.[0]?.contentString,
+        ...payloadToFlat(resource),
+        [CommunicationRequestClaim.Note]: annotationText(resource.note),
+    });
+}
+/** Projects canonical claims to the published FHIR R5 shape. */
+export function communicationRequestFlatToFhirR5(claims) {
+    return communicationRequestFlatToFhirR5Resource(claims);
+}
+/** Reads a published FHIR R5 CommunicationRequest into canonical flat claims. */
+export function communicationRequestFhirR5ToFlat(resource) {
+    return communicationRequestFhirR5ResourceToFlat(resource);
+}
+function communicationRequestFlatToFhirR5Resource(claims) {
+    const intent = claims[CommunicationRequestClaim.Intent];
+    if (!intent)
+        throw new TypeError('communication_request_intent_required');
+    return {
+        resourceType: 'CommunicationRequest',
+        identifier: claims[CommunicationRequestClaim.Identifier] ? [{ value: claims[CommunicationRequestClaim.Identifier] }] : undefined,
+        basedOn: referenceCsv(claims[CommunicationRequestClaim.BasedOn]),
+        replaces: referenceCsv(claims[CommunicationRequestClaim.Replaces]),
+        groupIdentifier: claims[CommunicationRequestClaim.GroupIdentifier] ? { value: claims[CommunicationRequestClaim.GroupIdentifier] } : undefined,
+        status: claims[CommunicationRequestClaim.Status],
+        statusReason: codeableConcept(claims[CommunicationRequestClaim.StatusReason]),
+        intent,
+        priority: claims[CommunicationRequestClaim.Priority],
+        category: claims[CommunicationRequestClaim.Category] ? [{ coding: codingFromValue(claims[CommunicationRequestClaim.Category]) }] : undefined,
+        doNotPerform: optionalBoolean(claims[CommunicationRequestClaim.DoNotPerform]),
+        medium: claims[CommunicationRequestClaim.Medium] ? [{ coding: codingFromValue(claims[CommunicationRequestClaim.Medium]) }] : undefined,
+        subject: claims[CommunicationRequestClaim.Subject] ? { reference: claims[CommunicationRequestClaim.Subject] } : undefined,
+        about: referenceCsv(claims[CommunicationRequestClaim.About]),
+        encounter: claims[CommunicationRequestClaim.Encounter] ? { reference: claims[CommunicationRequestClaim.Encounter] } : undefined,
+        requester: claims[CommunicationRequestClaim.Requester] ? { reference: claims[CommunicationRequestClaim.Requester] } : undefined,
+        recipient: referenceCsv(claims[CommunicationRequestClaim.Recipient]),
+        informationProvider: referenceCsv(claims[CommunicationRequestClaim.InformationProvider]),
+        authoredOn: claims[CommunicationRequestClaim.AuthoredOn], occurrenceDateTime: claims[CommunicationRequestClaim.Occurrence],
+        reason: reasonsR5(claims), payload: payloadR5(claims), note: annotation(claims[CommunicationRequestClaim.Note]),
     };
 }
+function communicationRequestFhirR5ResourceToFlat(resource) {
+    const reasons = resource.reason;
+    return compact({
+        [CommunicationRequestClaim.Identifier]: resource.identifier?.[0]?.value,
+        [CommunicationRequestClaim.BasedOn]: referenceListToCsv(resource.basedOn),
+        [CommunicationRequestClaim.Replaces]: referenceListToCsv(resource.replaces),
+        [CommunicationRequestClaim.GroupIdentifier]: resource.groupIdentifier?.value,
+        [CommunicationRequestClaim.Status]: resource.status,
+        [CommunicationRequestClaim.StatusReason]: codeableConceptToValue(resource.statusReason),
+        [CommunicationRequestClaim.Intent]: resource.intent,
+        [CommunicationRequestClaim.Priority]: resource.priority,
+        [CommunicationRequestClaim.Category]: codingToValue(resource.category?.[0]?.coding?.[0]),
+        [CommunicationRequestClaim.DoNotPerform]: typeof resource.doNotPerform === 'boolean' ? String(resource.doNotPerform) : undefined,
+        [CommunicationRequestClaim.Medium]: codingToValue(resource.medium?.[0]?.coding?.[0]),
+        [CommunicationRequestClaim.Subject]: referenceToValue(resource.subject),
+        [CommunicationRequestClaim.About]: referenceListToCsv(resource.about),
+        [CommunicationRequestClaim.Encounter]: referenceToValue(resource.encounter),
+        [CommunicationRequestClaim.Requester]: referenceToValue(resource.requester),
+        [CommunicationRequestClaim.Recipient]: referenceListToCsv(resource.recipient),
+        [CommunicationRequestClaim.InformationProvider]: referenceListToCsv(resource.informationProvider),
+        [CommunicationRequestClaim.AuthoredOn]: resource.authoredOn,
+        [CommunicationRequestClaim.Occurrence]: resource.occurrenceDateTime,
+        [CommunicationRequestClaim.ReasonCode]: codingListToCsv(reasons?.flatMap(value => value.concept?.coding ?? [])),
+        [CommunicationRequestClaim.ReasonReference]: reasons?.map(value => value.reference?.reference).filter((value) => Boolean(value)).join(',') || undefined,
+        ...payloadToFlat(resource), [CommunicationRequestClaim.Note]: annotationText(resource.note),
+    });
+}
 function referenceCsv(value) {
     const references = value?.split(',').map(reference => reference.trim()).filter(Boolean) ?? [];
     return references.length ? references.map(reference => ({ reference })) : undefined;
 }
+function firstReference(value) { return referenceCsv(value)?.[0]; }
+function codeableConcept(value) {
+    const coding = codingFromValue(value);
+    return coding ? { coding } : undefined;
+}
+function codeableConceptToValue(value) {
+    return codingToValue(value?.coding?.[0]);
+}
+function optionalBoolean(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== 'true' && value !== 'false')
+        throw new TypeError('communication_request_boolean_invalid');
+    return value === 'true';
+}
+function annotation(value) { return value ? [{ text: value }] : undefined; }
+function annotationText(value) { return value?.[0]?.text; }
+function payloadR4(claims) {
+    if (claims[CommunicationRequestClaim.PayloadReference])
+        return [{ contentReference: { reference: claims[CommunicationRequestClaim.PayloadReference] } }];
+    if (claims[CommunicationRequestClaim.PayloadAttachmentData])
+        return [{ contentAttachment: attachment(claims) }];
+    return claims[CommunicationRequestClaim.PayloadContent] ? [{ contentString: claims[CommunicationRequestClaim.PayloadContent] }] : undefined;
+}
+function payloadR5(claims) {
+    if (claims[CommunicationRequestClaim.PayloadReference])
+        return [{ contentReference: { reference: claims[CommunicationRequestClaim.PayloadReference] } }];
+    if (claims[CommunicationRequestClaim.PayloadAttachmentData])
+        return [{ contentAttachment: attachment(claims) }];
+    if (claims[CommunicationRequestClaim.PayloadContent])
+        throw new TypeError('communication_request_string_payload_not_supported_in_r5');
+    return undefined;
+}
+function attachment(claims) {
+    const contentType = claims[CommunicationRequestClaim.PayloadAttachmentContentType];
+    if (!contentType)
+        throw new TypeError('communication_request_attachment_content_type_required');
+    return { contentType, data: claims[CommunicationRequestClaim.PayloadAttachmentData], title: claims[CommunicationRequestClaim.PayloadAttachmentTitle] };
+}
+function payloadToFlat(resource) {
+    const payload = resource.payload?.[0];
+    return compact({
+        [CommunicationRequestClaim.PayloadContent]: payload?.contentString,
+        [CommunicationRequestClaim.PayloadReference]: payload?.contentReference?.reference,
+        [CommunicationRequestClaim.PayloadAttachmentContentType]: payload?.contentAttachment?.contentType,
+        [CommunicationRequestClaim.PayloadAttachmentData]: payload?.contentAttachment?.data,
+        [CommunicationRequestClaim.PayloadAttachmentTitle]: payload?.contentAttachment?.title,
+    });
+}
+function reasonsR5(claims) {
+    const result = [];
+    for (const coding of codingListFromCsv(claims[CommunicationRequestClaim.ReasonCode]) ?? [])
+        result.push({ concept: { coding: [coding] } });
+    for (const item of referenceCsv(claims[CommunicationRequestClaim.ReasonReference]) ?? [])
+        result.push({ reference: item });
+    return result.length ? result : undefined;
+}
+function compact(value) { return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)); }

package/dist/data/communication-request-form-schema.data.d.ts

@@ -0,0 +1,108 @@
+import type { FlatClaims } from '../converters/convert-shared.js';
+export declare const CommunicationRequestStatuses: readonly ["draft", "active", "on-hold", "revoked", "completed", "entered-in-error", "unknown"];
+export declare const CommunicationRequestIntents: readonly ["proposal", "plan", "directive", "order", "original-order", "reflex-order", "filler-order", "instance-order", "option"];
+export declare const CommunicationRequestPriorities: readonly ["routine", "urgent", "asap", "stat"];
+export type CommunicationRequestFormData = Readonly<{
+    identifier?: string;
+    status: typeof CommunicationRequestStatuses[number];
+    intent: typeof CommunicationRequestIntents[number];
+    priority?: typeof CommunicationRequestPriorities[number];
+    subject: string;
+    encounter?: string;
+    requester: string;
+    recipients: readonly string[];
+    informationProviders?: readonly string[];
+    authoredOn?: string;
+    occurrence?: string;
+    payloadReference?: string;
+    payloadAttachmentContentType?: string;
+    payloadAttachmentData?: string;
+    payloadAttachmentTitle?: string;
+    note?: string;
+}>;
+/** Data-only JSON Schema. Portals own localized labels, widgets and authorization. */
+export declare const FHIR_COMMUNICATION_REQUEST_FORM_SCHEMA: Readonly<{
+    $schema: "https://json-schema.org/draft/2020-12/schema";
+    $id: "https://globaldatacare.com/schemas/fhir/communication-request-form.json";
+    title: "CommunicationRequest";
+    type: "object";
+    additionalProperties: false;
+    required: readonly string[];
+    properties: Readonly<{
+        identifier: Readonly<{
+            type: "string";
+            minLength: 1;
+        }>;
+        status: Readonly<{
+            type: "string";
+            enum: readonly ["draft", "active", "on-hold", "revoked", "completed", "entered-in-error", "unknown"];
+        }>;
+        intent: Readonly<{
+            type: "string";
+            enum: readonly ["proposal", "plan", "directive", "order", "original-order", "reflex-order", "filler-order", "instance-order", "option"];
+        }>;
+        priority: Readonly<{
+            type: "string";
+            enum: readonly ["routine", "urgent", "asap", "stat"];
+        }>;
+        subject: Readonly<{
+            type: "string";
+            pattern: "^[A-Za-z][A-Za-z0-9]+/[A-Za-z0-9.-]{1,64}$";
+        }>;
+        encounter: Readonly<{
+            type: "string";
+            pattern: "^[A-Za-z][A-Za-z0-9]+/[A-Za-z0-9.-]{1,64}$";
+        }>;
+        requester: Readonly<{
+            type: "string";
+            pattern: "^[A-Za-z][A-Za-z0-9]+/[A-Za-z0-9.-]{1,64}$";
+        }>;
+        recipients: Readonly<{
+            type: "array";
+            minItems: 1;
+            uniqueItems: true;
+            items: Readonly<{
+                type: "string";
+                pattern: "^[A-Za-z][A-Za-z0-9]+/[A-Za-z0-9.-]{1,64}$";
+            }>;
+        }>;
+        informationProviders: Readonly<{
+            type: "array";
+            uniqueItems: true;
+            items: Readonly<{
+                type: "string";
+                pattern: "^[A-Za-z][A-Za-z0-9]+/[A-Za-z0-9.-]{1,64}$";
+            }>;
+        }>;
+        authoredOn: Readonly<{
+            type: "string";
+            format: "date-time";
+        }>;
+        occurrence: Readonly<{
+            type: "string";
+            format: "date-time";
+        }>;
+        payloadReference: Readonly<{
+            type: "string";
+            pattern: "^[A-Za-z][A-Za-z0-9]+/[A-Za-z0-9.-]{1,64}$";
+        }>;
+        payloadAttachmentContentType: Readonly<{
+            type: "string";
+            minLength: 1;
+        }>;
+        payloadAttachmentData: Readonly<{
+            type: "string";
+            minLength: 1;
+            contentEncoding: "base64";
+        }>;
+        payloadAttachmentTitle: Readonly<{
+            type: "string";
+            minLength: 1;
+        }>;
+        note: Readonly<{
+            type: "string";
+        }>;
+    }>;
+}>;
+export declare function communicationRequestFormDataToFlatClaims(input: CommunicationRequestFormData): FlatClaims;
+export declare function communicationRequestFlatClaimsToFormData(claims: FlatClaims): CommunicationRequestFormData;

package/dist/data/communication-request-form-schema.data.js

@@ -0,0 +1,91 @@
+// Copyright 2026 Connecting Solution & Applications Ltd under the Apache License, Version 2.0.
+import { CommunicationRequestClaim } from '../claims/communication-request-claims.js';
+export const CommunicationRequestStatuses = Object.freeze([
+    'draft', 'active', 'on-hold', 'revoked', 'completed', 'entered-in-error', 'unknown',
+]);
+export const CommunicationRequestIntents = Object.freeze([
+    'proposal', 'plan', 'directive', 'order', 'original-order', 'reflex-order', 'filler-order', 'instance-order', 'option',
+]);
+export const CommunicationRequestPriorities = Object.freeze(['routine', 'urgent', 'asap', 'stat']);
+/** Data-only JSON Schema. Portals own localized labels, widgets and authorization. */
+export const FHIR_COMMUNICATION_REQUEST_FORM_SCHEMA = Object.freeze({
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://globaldatacare.com/schemas/fhir/communication-request-form.json',
+    title: 'CommunicationRequest',
+    type: 'object',
+    additionalProperties: false,
+    required: Object.freeze(['status', 'intent', 'subject', 'requester', 'recipients']),
+    properties: Object.freeze({
+        identifier: Object.freeze({ type: 'string', minLength: 1 }),
+        status: Object.freeze({ type: 'string', enum: CommunicationRequestStatuses }),
+        intent: Object.freeze({ type: 'string', enum: CommunicationRequestIntents }),
+        priority: Object.freeze({ type: 'string', enum: CommunicationRequestPriorities }),
+        subject: referenceSchema(), encounter: referenceSchema(), requester: referenceSchema(),
+        recipients: Object.freeze({ type: 'array', minItems: 1, uniqueItems: true, items: referenceSchema() }),
+        informationProviders: Object.freeze({ type: 'array', uniqueItems: true, items: referenceSchema() }),
+        authoredOn: dateTimeSchema(), occurrence: dateTimeSchema(), payloadReference: referenceSchema(),
+        payloadAttachmentContentType: Object.freeze({ type: 'string', minLength: 1 }),
+        payloadAttachmentData: Object.freeze({ type: 'string', minLength: 1, contentEncoding: 'base64' }),
+        payloadAttachmentTitle: Object.freeze({ type: 'string', minLength: 1 }),
+        note: Object.freeze({ type: 'string' }),
+    }),
+});
+export function communicationRequestFormDataToFlatClaims(input) {
+    requiredEnum(input.status, CommunicationRequestStatuses, 'communication_request_status_invalid');
+    requiredEnum(input.intent, CommunicationRequestIntents, 'communication_request_intent_invalid');
+    if (input.priority)
+        requiredEnum(input.priority, CommunicationRequestPriorities, 'communication_request_priority_invalid');
+    const recipients = references(input.recipients, 'communication_request_recipient_required');
+    const providers = input.informationProviders?.length
+        ? references(input.informationProviders, 'communication_request_information_provider_invalid') : undefined;
+    if (input.payloadAttachmentData && !input.payloadAttachmentContentType) {
+        throw new TypeError('communication_request_attachment_content_type_required');
+    }
+    return compact({
+        [CommunicationRequestClaim.Identifier]: optional(input.identifier),
+        [CommunicationRequestClaim.Status]: input.status,
+        [CommunicationRequestClaim.Intent]: input.intent,
+        [CommunicationRequestClaim.Priority]: optional(input.priority),
+        [CommunicationRequestClaim.Subject]: reference(input.subject, 'communication_request_subject_invalid'),
+        [CommunicationRequestClaim.Encounter]: input.encounter ? reference(input.encounter, 'communication_request_encounter_invalid') : undefined,
+        [CommunicationRequestClaim.Requester]: reference(input.requester, 'communication_request_requester_invalid'),
+        [CommunicationRequestClaim.Recipient]: recipients.join(','),
+        [CommunicationRequestClaim.InformationProvider]: providers?.join(','),
+        [CommunicationRequestClaim.AuthoredOn]: dateTime(input.authoredOn),
+        [CommunicationRequestClaim.Occurrence]: dateTime(input.occurrence),
+        [CommunicationRequestClaim.PayloadReference]: input.payloadReference ? reference(input.payloadReference, 'communication_request_payload_reference_invalid') : undefined,
+        [CommunicationRequestClaim.PayloadAttachmentContentType]: optional(input.payloadAttachmentContentType),
+        [CommunicationRequestClaim.PayloadAttachmentData]: optional(input.payloadAttachmentData),
+        [CommunicationRequestClaim.PayloadAttachmentTitle]: optional(input.payloadAttachmentTitle),
+        [CommunicationRequestClaim.Note]: optional(input.note),
+    });
+}
+export function communicationRequestFlatClaimsToFormData(claims) {
+    return compact({
+        identifier: claims[CommunicationRequestClaim.Identifier], status: claims[CommunicationRequestClaim.Status],
+        intent: claims[CommunicationRequestClaim.Intent], priority: claims[CommunicationRequestClaim.Priority],
+        subject: claims[CommunicationRequestClaim.Subject], encounter: claims[CommunicationRequestClaim.Encounter],
+        requester: claims[CommunicationRequestClaim.Requester], recipients: split(claims[CommunicationRequestClaim.Recipient]),
+        informationProviders: splitOptional(claims[CommunicationRequestClaim.InformationProvider]),
+        authoredOn: claims[CommunicationRequestClaim.AuthoredOn], occurrence: claims[CommunicationRequestClaim.Occurrence],
+        payloadReference: claims[CommunicationRequestClaim.PayloadReference],
+        payloadAttachmentContentType: claims[CommunicationRequestClaim.PayloadAttachmentContentType],
+        payloadAttachmentData: claims[CommunicationRequestClaim.PayloadAttachmentData],
+        payloadAttachmentTitle: claims[CommunicationRequestClaim.PayloadAttachmentTitle], note: claims[CommunicationRequestClaim.Note],
+    });
+}
+function referenceSchema() { return Object.freeze({ type: 'string', pattern: '^[A-Za-z][A-Za-z0-9]+/[A-Za-z0-9.-]{1,64}$' }); }
+function dateTimeSchema() { return Object.freeze({ type: 'string', format: 'date-time' }); }
+function optional(value) { const text = String(value ?? '').trim(); return text || undefined; }
+function dateTime(value) { const text = optional(value); if (text && Number.isNaN(Date.parse(text)))
+    throw new TypeError('communication_request_datetime_invalid'); return text; }
+function reference(value, error) { const text = optional(value); if (!text || !/^[A-Za-z][A-Za-z0-9]+\/[A-Za-z0-9.-]{1,64}$/u.test(text))
+    throw new TypeError(error); return text; }
+function references(values, error) { if (!Array.isArray(values) || !values.length)
+    throw new TypeError(error); const result = [...new Set(values.map(value => reference(value, error)))]; if (result.length !== values.length)
+    throw new TypeError(error); return result; }
+function split(value) { return Object.freeze(String(value || '').split(',').map(item => item.trim()).filter(Boolean)); }
+function splitOptional(value) { const values = split(value); return values.length ? values : undefined; }
+function requiredEnum(value, allowed, error) { if (!allowed.includes(value))
+    throw new TypeError(error); }
+function compact(value) { return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)); }

package/dist/data/index.d.ts

@@ -5,3 +5,4 @@ export * from './ips-all-sections.data.js';
 export * from './health-credential-qr.data.js';
 export * from './ips-clinical-artifact-schemas.data.js';
 export * from './clinical-document-encounter-journey.data.js';
+export * from './communication-request-form-schema.data.js';

package/dist/data/index.js

@@ -5,3 +5,4 @@ export * from './ips-all-sections.data.js';
 export * from './health-credential-qr.data.js';
 export * from './ips-clinical-artifact-schemas.data.js';
 export * from './clinical-document-encounter-journey.data.js';
+export * from './communication-request-form-schema.data.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fhir-data-utils-ts",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "description": "FHIR-version-neutral flat-claim and SearchParameter data utilities",
   "license": "Apache-2.0",
   "type": "module",