gdc-sdk-front-ts 0.6.2 → 0.6.6

package/dist/gdc-sdk-core-ts/src/communication-consent-mutation-contract.js

@@ -0,0 +1,190 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants/fhir-resource-types';
+import { addResources, getResources, removeResources, setResources, } from './communication-bundle-resources.js';
+import { ConsentCommunicationOperationKinds, assertConsentCommunicationOperationInput, } from './consent-communication-operations.js';
+export const CommunicationResourceLifecycleTagSystem = 'org.gdc.resource.lifecycle';
+export const CommunicationResourceLifecycleTagCode = Object.freeze({
+    Enabled: 'enabled',
+    Disabled: 'disabled',
+});
+function toArray(value) {
+    if (!value)
+        return [];
+    return (Array.isArray(value) ? value : [value])
+        .map((item) => String(item || '').trim())
+        .filter(Boolean);
+}
+function toKindArray(value) {
+    if (!value)
+        return [];
+    return (Array.isArray(value) ? value : [value])
+        .map((item) => String(item || '').trim())
+        .filter(Boolean);
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeSectionToken(value) {
+    const token = String(value || '').trim();
+    if (!token)
+        return '';
+    if (token.includes('|')) {
+        const parts = token.split('|');
+        return String(parts[parts.length - 1] || '').trim().toLowerCase();
+    }
+    return token.toLowerCase();
+}
+function getOperationDate(operation) {
+    const date = String(operation.consentDate || operation.periodStart || '').trim();
+    return date || undefined;
+}
+function matchesDate(operation, date) {
+    if (!date?.start && !date?.end)
+        return true;
+    const value = getOperationDate(operation);
+    if (!value)
+        return false;
+    if (date.start && value < date.start)
+        return false;
+    if (date.end && value > date.end)
+        return false;
+    return true;
+}
+function getOperationList(input) {
+    const payload = input.payload;
+    const operations = payload?.operations;
+    if (!Array.isArray(operations))
+        return [];
+    return operations.map((item) => assertConsentCommunicationOperationInput(item));
+}
+function setOperationList(input, operations) {
+    const next = clone(input);
+    const payload = (next.payload && typeof next.payload === 'object' && !Array.isArray(next.payload))
+        ? { ...next.payload }
+        : {};
+    payload.operations = operations;
+    next.payload = payload;
+    return next;
+}
+function matchesOperation(operation, filter) {
+    const operationIds = toArray(filter.operationIds);
+    if (operationIds.length && !operationIds.includes(operation.operationId))
+        return false;
+    const operationKinds = toKindArray(filter.operationKinds);
+    if (operationKinds.length && !operationKinds.includes(operation.operationKind))
+        return false;
+    const targetKinds = toKindArray(filter.targetKinds);
+    if (targetKinds.length && !targetKinds.includes(operation.target.kind))
+        return false;
+    const purposes = toArray(filter.purposes);
+    if (purposes.length && !purposes.includes(operation.purpose))
+        return false;
+    const sections = toArray(filter.sections).map(normalizeSectionToken);
+    if (sections.length) {
+        const operationSections = [
+            ...operation.sections.core,
+            ...(operation.sections.extended || []),
+        ].map(normalizeSectionToken);
+        if (!sections.some((section) => operationSections.includes(section)))
+            return false;
+    }
+    const types = toArray(filter.types);
+    if (types.length && !types.includes(ResourceTypesFhirR4.Consent))
+        return false;
+    return matchesDate(operation, filter.date);
+}
+export function getConsentOperations(input, filter = {}) {
+    return getOperationList(input).filter((operation) => matchesOperation(operation, filter));
+}
+export function addConsentOperations(input, operations) {
+    const current = getOperationList(input);
+    const additions = operations.map(assertConsentCommunicationOperationInput);
+    return setOperationList(input, [...current, ...additions]);
+}
+export function setConsentOperations(input, filter, operations) {
+    const current = getOperationList(input);
+    const keep = current.filter((operation) => !matchesOperation(operation, filter));
+    const replacements = operations.map(assertConsentCommunicationOperationInput);
+    return setOperationList(input, [...keep, ...replacements]);
+}
+function setConsentOperationKindByFilter(input, filter, operationKind) {
+    const current = getOperationList(input);
+    const next = current.map((operation) => {
+        if (!matchesOperation(operation, filter))
+            return operation;
+        return {
+            ...operation,
+            operationKind,
+        };
+    });
+    return setOperationList(input, next);
+}
+export function enableConsentOperations(input, filter) {
+    return setConsentOperationKindByFilter(input, filter, ConsentCommunicationOperationKinds.Enable);
+}
+export function disableConsentOperations(input, filter) {
+    return setConsentOperationKindByFilter(input, filter, ConsentCommunicationOperationKinds.Disable);
+}
+export function removeConsentOperations(input, filter) {
+    const current = getOperationList(input);
+    return setOperationList(input, current.filter((operation) => !matchesOperation(operation, filter)));
+}
+function setResourceLifecycleState(resources, enabled) {
+    return resources.map((resource) => {
+        const next = clone(resource);
+        const meta = (next.meta && typeof next.meta === 'object' && !Array.isArray(next.meta))
+            ? { ...next.meta }
+            : {};
+        const tags = Array.isArray(meta.tag) ? [...meta.tag] : [];
+        const retained = tags.filter((tag) => String(tag.system || '').trim() !== CommunicationResourceLifecycleTagSystem);
+        retained.push({
+            system: CommunicationResourceLifecycleTagSystem,
+            code: enabled
+                ? CommunicationResourceLifecycleTagCode.Enabled
+                : CommunicationResourceLifecycleTagCode.Disabled,
+        });
+        meta.tag = retained;
+        next.meta = meta;
+        return next;
+    });
+}
+export function enableCommunicationResources(communicationOrBundle, filter) {
+    const matched = getResources(communicationOrBundle, filter);
+    const enabled = setResourceLifecycleState(matched, true);
+    return setResources(communicationOrBundle, filter, enabled);
+}
+export function disableCommunicationResources(communicationOrBundle, filter) {
+    const matched = getResources(communicationOrBundle, filter);
+    const disabled = setResourceLifecycleState(matched, false);
+    return setResources(communicationOrBundle, filter, disabled);
+}
+export const ConsentOperationMutationContract = Object.freeze({
+    getConsentOperations,
+    setConsentOperations,
+    addConsentOperations,
+    enableConsentOperations,
+    disableConsentOperations,
+    removeConsentOperations,
+    // Backward-compatible aliases.
+    getX: getConsentOperations,
+    setX: setConsentOperations,
+    addX: addConsentOperations,
+    enableX: enableConsentOperations,
+    disableX: disableConsentOperations,
+    removeX: removeConsentOperations,
+});
+export const CommunicationResourceMutationContract = Object.freeze({
+    getCommunicationResources: getResources,
+    setCommunicationResources: setResources,
+    addCommunicationResources: addResources,
+    enableCommunicationResources,
+    disableCommunicationResources,
+    removeCommunicationResources: removeResources,
+    // Backward-compatible aliases.
+    getX: getResources,
+    setX: setResources,
+    addX: addResources,
+    enableX: enableCommunicationResources,
+    disableX: disableCommunicationResources,
+    removeX: removeResources,
+});

package/dist/gdc-sdk-core-ts/src/communication-document-facade.d.ts

@@ -0,0 +1,55 @@
+import type { FhirResourceLike } from './communication-resource-helpers.js';
+export type ResolvedCommunicationDocument = Readonly<{
+    kind: 'fhir' | 'binary' | 'unknown';
+    contentType?: string;
+    title?: string;
+    base64Data?: string;
+    documentReference?: FhirResourceLike;
+    bundle?: FhirResourceLike;
+    source: 'attachment' | 'documentReference' | 'reference' | 'unknown';
+}>;
+export type FhirDocumentSection = Readonly<{
+    title?: string;
+    code?: string;
+    entries: string[];
+}>;
+export type FhirDocumentFacade = Readonly<{
+    getBundle: () => FhirResourceLike | undefined;
+    getSections: () => FhirDocumentSection[];
+    getResources: (resourceType?: string) => FhirResourceLike[];
+    getByDates: (resourceType: string, start?: string, end?: string) => FhirResourceLike[];
+    getContainingTextOrDisplay: (resourceType: string, searchText: string) => FhirResourceLike[];
+    vitalSigns: Readonly<{
+        getAll: () => FhirResourceLike[];
+        getHeartRate: () => FhirResourceLike[];
+        getBloodPressure: () => FhirResourceLike[];
+        getBodyTemperature: () => FhirResourceLike[];
+    }>;
+}>;
+/**
+ * Resolves the first document reachable from a FHIR `Communication`.
+ *
+ * The returned descriptor hides whether the document was attached directly
+ * or wrapped in a `DocumentReference`.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export declare function getDocumentFromCommunication(communication: FhirResourceLike): ResolvedCommunicationDocument | undefined;
+/**
+ * Creates a read-only document facade over a FHIR `Bundle document`
+ * or over a FHIR `Communication` that contains one.
+ *
+ * @param communicationOrBundle Either a FHIR `Bundle document` or a FHIR `Communication`.
+ */
+export declare function createFhirDocumentFacade(communicationOrBundle: FhirResourceLike): FhirDocumentFacade;
+/**
+ * Creates the high-level communication facade used by SDK consumers.
+ *
+ * Current methods:
+ * - `getDocument(...)`
+ * - `getFhirDocument(...)`
+ */
+export declare function createCommunicationFacade(): Readonly<{
+    getDocument: typeof getDocumentFromCommunication;
+    getFhirDocument: typeof createFhirDocumentFacade;
+}>;

package/dist/gdc-sdk-core-ts/src/communication-document-facade.js

@@ -0,0 +1,194 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants/fhir-resource-types';
+import { createVitalSignsFacade } from './vital-signs.js';
+import { getBundleDocumentEntries, getBundleDocumentResourcesByType, getFirstBundleDocumentFromCommunication, resolveCommunicationPayloads, sortFhirResourcesByDateDescending, } from './communication-resource-helpers.js';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+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 getAttachmentMetadata(payload) {
+    const attachment = isPlainObject(payload.contentAttachment) ? payload.contentAttachment : undefined;
+    if (attachment) {
+        return {
+            contentType: typeof attachment.contentType === 'string' ? attachment.contentType : undefined,
+            title: typeof attachment.title === 'string' ? attachment.title : undefined,
+            data: typeof attachment.data === 'string' ? attachment.data : undefined,
+            source: 'attachment',
+        };
+    }
+    const reference = isPlainObject(payload.contentReference) ? payload.contentReference : undefined;
+    if (reference) {
+        return { source: 'reference' };
+    }
+    return { source: 'unknown' };
+}
+function getTextIndex(resource) {
+    const fragments = [];
+    const walk = (value) => {
+        if (typeof value === 'string' && value.trim()) {
+            fragments.push(value.trim().toLowerCase());
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach(walk);
+            return;
+        }
+        if (isPlainObject(value)) {
+            Object.values(value).forEach(walk);
+        }
+    };
+    walk(resource);
+    return fragments.join(' ');
+}
+/**
+ * Resolves the first document reachable from a FHIR `Communication`.
+ *
+ * The returned descriptor hides whether the document was attached directly
+ * or wrapped in a `DocumentReference`.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export function getDocumentFromCommunication(communication) {
+    const payloads = resolveCommunicationPayloads(communication);
+    const first = payloads[0];
+    if (!first)
+        return undefined;
+    const payloadArray = Array.isArray(communication.payload)
+        ? communication.payload
+        : undefined;
+    const communicationPayload = payloadArray
+        ? payloadArray[first.payloadIndex]
+        : undefined;
+    const payloadMeta = isPlainObject(communicationPayload)
+        ? getAttachmentMetadata(communicationPayload)
+        : { source: 'unknown' };
+    if (first.bundle) {
+        return {
+            kind: 'fhir',
+            contentType: payloadMeta.contentType || 'application/fhir+json',
+            title: payloadMeta.title,
+            base64Data: payloadMeta.data,
+            documentReference: first.documentReference,
+            bundle: first.bundle,
+            source: first.documentReference?.resourceType === ResourceTypesFhirR4.DocumentReference
+                ? 'documentReference'
+                : payloadMeta.source,
+        };
+    }
+    if (payloadMeta.contentType || payloadMeta.data) {
+        return {
+            kind: payloadMeta.contentType?.includes('fhir') ? 'fhir' : 'binary',
+            contentType: payloadMeta.contentType,
+            title: payloadMeta.title,
+            base64Data: payloadMeta.data,
+            documentReference: first.documentReference,
+            bundle: first.resource?.resourceType === ResourceTypesFhirR4.Bundle ? first.resource : undefined,
+            source: first.documentReference?.resourceType === ResourceTypesFhirR4.DocumentReference
+                ? 'documentReference'
+                : payloadMeta.source,
+        };
+    }
+    return {
+        kind: 'unknown',
+        source: payloadMeta.source,
+        documentReference: first.documentReference,
+        bundle: first.bundle,
+    };
+}
+/**
+ * Creates a read-only document facade over a FHIR `Bundle document`
+ * or over a FHIR `Communication` that contains one.
+ *
+ * @param communicationOrBundle Either a FHIR `Bundle document` or a FHIR `Communication`.
+ */
+export function createFhirDocumentFacade(communicationOrBundle) {
+    const bundle = communicationOrBundle.resourceType === ResourceTypesFhirR4.Bundle
+        ? communicationOrBundle
+        : getFirstBundleDocumentFromCommunication(communicationOrBundle);
+    const facade = Object.freeze({
+        getBundle: () => bundle,
+        getSections: () => {
+            const compositions = getBundleDocumentResourcesByType(bundle, ResourceTypesFhirR4.Composition);
+            return compositions.flatMap((composition) => {
+                const sections = Array.isArray(composition.section) ? composition.section : [];
+                return sections
+                    .filter(isPlainObject)
+                    .map((section) => {
+                    const sectionCode = isPlainObject(section.code) ? section.code : undefined;
+                    const codingValue = sectionCode ? sectionCode.coding : undefined;
+                    const codingList = Array.isArray(codingValue) ? codingValue : [];
+                    const firstCoding = codingList.find(isPlainObject);
+                    return {
+                        title: typeof section.title === 'string' ? section.title : undefined,
+                        code: firstCoding
+                            ? [firstCoding.system, firstCoding.code].filter(Boolean).join('|') || undefined
+                            : undefined,
+                        entries: Array.isArray(section.entry)
+                            ? section.entry
+                                .filter(isPlainObject)
+                                .map((entry) => (typeof entry.reference === 'string' ? entry.reference : ''))
+                                .filter(Boolean)
+                            : [],
+                    };
+                });
+            });
+        },
+        getResources: (resourceType) => {
+            if (!resourceType)
+                return getBundleDocumentEntries(bundle);
+            return getBundleDocumentResourcesByType(bundle, resourceType);
+        },
+        getByDates: (resourceType, start, end) => {
+            return sortFhirResourcesByDateDescending(getBundleDocumentResourcesByType(bundle, resourceType))
+                .filter((resource) => {
+                const date = getCanonicalDate(resource);
+                if (!date)
+                    return false;
+                if (start && date < start)
+                    return false;
+                if (end && date > end)
+                    return false;
+                return true;
+            });
+        },
+        getContainingTextOrDisplay: (resourceType, searchText) => {
+            const normalized = searchText.trim().toLowerCase();
+            if (!normalized)
+                return [];
+            return getBundleDocumentResourcesByType(bundle, resourceType)
+                .filter((resource) => getTextIndex(resource).includes(normalized));
+        },
+    });
+    return Object.freeze({
+        ...facade,
+        vitalSigns: createVitalSignsFacade(facade),
+    });
+}
+/**
+ * Creates the high-level communication facade used by SDK consumers.
+ *
+ * Current methods:
+ * - `getDocument(...)`
+ * - `getFhirDocument(...)`
+ */
+export function createCommunicationFacade() {
+    return Object.freeze({
+        getDocument: getDocumentFromCommunication,
+        getFhirDocument: createFhirDocumentFacade,
+    });
+}

package/dist/gdc-sdk-core-ts/src/communication-draft.d.ts

@@ -0,0 +1,104 @@
+import type { CommunicationBatchMessageOptions, CommunicationCreationOptions, CommunicationResourceLike, FhirResourceLike, ResourceAttachmentOptions } from './communication-resource-helpers.js';
+export declare const CommunicationOutboxStatuses: Readonly<{
+    readonly Draft: "draft";
+    readonly Ready: "ready";
+    readonly Submitting: "submitting";
+    readonly Sent: "sent";
+    readonly Completed: "completed";
+    readonly Failed: "failed";
+    readonly ErrorRetryable: "error-retryable";
+}>;
+export type CommunicationOutboxStatus = typeof CommunicationOutboxStatuses[keyof typeof CommunicationOutboxStatuses];
+export type CommunicationDraft = Readonly<{
+    id: string;
+    communication: CommunicationResourceLike;
+    createdAt: string;
+    updatedAt: string;
+    noteText?: string;
+}>;
+export type CommunicationDraftCreationOptions = CommunicationCreationOptions & Readonly<{
+    draftId?: string;
+    createdAt?: string;
+}>;
+export type OutboxJob<TPayload = Record<string, unknown>, TStatus extends string = CommunicationOutboxStatus> = Readonly<{
+    id: string;
+    draftId: string;
+    thid: string;
+    createdAt: string;
+    updatedAt: string;
+    status: TStatus;
+    payload: TPayload;
+    envelope: Record<string, unknown>;
+    response?: Record<string, unknown>;
+    errorMessage?: string;
+}>;
+export type CommunicationOutboxJob = OutboxJob<CommunicationResourceLike, CommunicationOutboxStatus>;
+export type CommunicationOutboxJobOptions = Readonly<{
+    jobId?: string;
+    createdAt?: string;
+    status?: CommunicationOutboxStatus;
+    batchOptions?: CommunicationBatchMessageOptions;
+}>;
+/**
+ * Creates an in-memory `CommunicationDraft` ready to receive resources,
+ * documents, notes, and attachments before submission.
+ *
+ * The draft is purely local. It does not imply persistence, network I/O,
+ * queueing, or polling until converted into an outbox job.
+ *
+ * @param options Draft metadata plus the base `Communication` creation fields.
+ */
+export declare function createCommunicationDraft(options: CommunicationDraftCreationOptions): CommunicationDraft;
+/**
+ * Returns the FHIR `Communication` currently being edited inside the draft.
+ *
+ * @param draft Communication draft to inspect.
+ */
+export declare function getCommunicationFromDraft(draft: CommunicationDraft): CommunicationResourceLike;
+/**
+ * Returns `true` when the draft contains at least one `payload[]` entry and
+ * can therefore be serialized into an outbox job for submission.
+ *
+ * @param draft Communication draft to validate.
+ */
+export declare function isCommunicationDraftReady(draft: CommunicationDraft): boolean;
+/**
+ * Appends a concrete FHIR resource to the draft `Communication.payload[]`.
+ *
+ * @param draft Communication draft being edited.
+ * @param resource FHIR resource to attach.
+ * @param options Attachment/document wrapping options.
+ */
+export declare function addFhirResourceToDraft(draft: CommunicationDraft, resource: FhirResourceLike, options?: ResourceAttachmentOptions): CommunicationDraft;
+/**
+ * Appends a claims-only pseudo-resource to the draft `Communication.payload[]`.
+ *
+ * @param draft Communication draft being edited.
+ * @param resourceType FHIR `resourceType` name to materialize.
+ * @param claims Canonical claims to place under `resource.meta.claims`.
+ * @param options Attachment/document wrapping options.
+ */
+export declare function addClaimsResourceToDraft(draft: CommunicationDraft, resourceType: string, claims: Record<string, unknown>, options?: ResourceAttachmentOptions): CommunicationDraft;
+/**
+ * Freezes the current draft into a transport-oriented outbox job.
+ *
+ * The returned job contains the current `Communication` as `payload`, the prebuilt batch
+ * message, a thread id, and a transport status. Submission and polling are
+ * intentionally left to runtime packages.
+ *
+ * @param draft Draft to freeze.
+ * @param options Optional job id, timestamps, initial status, and batch options.
+ */
+export declare function createOutboxJobFromDraft(draft: CommunicationDraft, options?: CommunicationOutboxJobOptions): CommunicationOutboxJob;
+/**
+ * Returns a copy of the outbox job with a new status and optional transport
+ * result metadata such as gateway responses or error messages.
+ *
+ * @param job Existing outbox job.
+ * @param status Next transport status.
+ * @param patch Optional response/error payload.
+ */
+export declare function updateOutboxJobStatus(job: CommunicationOutboxJob, status: CommunicationOutboxStatus, patch?: Readonly<{
+    response?: Record<string, unknown>;
+    errorMessage?: string;
+}>): CommunicationOutboxJob;

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

@@ -0,0 +1,143 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { addClaimsResourceToCommunication, addFhirResourceToCommunication, buildCommunicationBatchMessage, createCommunicationResource, } from './communication-resource-helpers.js';
+export const CommunicationOutboxStatuses = Object.freeze({
+    Draft: 'draft',
+    Ready: 'ready',
+    Submitting: 'submitting',
+    Sent: 'sent',
+    Completed: 'completed',
+    Failed: 'failed',
+    ErrorRetryable: 'error-retryable',
+});
+function runtimeUuid() {
+    const cryptoLike = globalThis;
+    if (typeof cryptoLike.crypto?.randomUUID === 'function') {
+        return cryptoLike.crypto.randomUUID();
+    }
+    return `draft-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function resolveDraftNoteText(communication) {
+    if (!Array.isArray(communication.note))
+        return undefined;
+    return communication.note
+        .map((item) => (item && typeof item.text === 'string' ? item.text.trim() : ''))
+        .filter(Boolean)
+        .join('\n\n') || undefined;
+}
+/**
+ * Creates an in-memory `CommunicationDraft` ready to receive resources,
+ * documents, notes, and attachments before submission.
+ *
+ * The draft is purely local. It does not imply persistence, network I/O,
+ * queueing, or polling until converted into an outbox job.
+ *
+ * @param options Draft metadata plus the base `Communication` creation fields.
+ */
+export function createCommunicationDraft(options) {
+    const createdAt = options.createdAt || new Date().toISOString();
+    const communication = createCommunicationResource(options);
+    return Object.freeze({
+        id: options.draftId || runtimeUuid(),
+        communication,
+        createdAt,
+        updatedAt: createdAt,
+        noteText: resolveDraftNoteText(communication),
+    });
+}
+/**
+ * Returns the FHIR `Communication` currently being edited inside the draft.
+ *
+ * @param draft Communication draft to inspect.
+ */
+export function getCommunicationFromDraft(draft) {
+    return clone(draft.communication);
+}
+/**
+ * Returns `true` when the draft contains at least one `payload[]` entry and
+ * can therefore be serialized into an outbox job for submission.
+ *
+ * @param draft Communication draft to validate.
+ */
+export function isCommunicationDraftReady(draft) {
+    return Array.isArray(draft.communication.payload) && draft.communication.payload.length > 0;
+}
+/**
+ * Appends a concrete FHIR resource to the draft `Communication.payload[]`.
+ *
+ * @param draft Communication draft being edited.
+ * @param resource FHIR resource to attach.
+ * @param options Attachment/document wrapping options.
+ */
+export function addFhirResourceToDraft(draft, resource, options = {}) {
+    const communication = addFhirResourceToCommunication(draft.communication, resource, options);
+    return Object.freeze({
+        ...draft,
+        communication,
+        updatedAt: new Date().toISOString(),
+        noteText: resolveDraftNoteText(communication),
+    });
+}
+/**
+ * Appends a claims-only pseudo-resource to the draft `Communication.payload[]`.
+ *
+ * @param draft Communication draft being edited.
+ * @param resourceType FHIR `resourceType` name to materialize.
+ * @param claims Canonical claims to place under `resource.meta.claims`.
+ * @param options Attachment/document wrapping options.
+ */
+export function addClaimsResourceToDraft(draft, resourceType, claims, options = {}) {
+    const communication = addClaimsResourceToCommunication(draft.communication, resourceType, claims, options);
+    return Object.freeze({
+        ...draft,
+        communication,
+        updatedAt: new Date().toISOString(),
+        noteText: resolveDraftNoteText(communication),
+    });
+}
+/**
+ * Freezes the current draft into a transport-oriented outbox job.
+ *
+ * The returned job contains the current `Communication` as `payload`, the prebuilt batch
+ * message, a thread id, and a transport status. Submission and polling are
+ * intentionally left to runtime packages.
+ *
+ * @param draft Draft to freeze.
+ * @param options Optional job id, timestamps, initial status, and batch options.
+ */
+export function createOutboxJobFromDraft(draft, options = {}) {
+    const createdAt = options.createdAt || new Date().toISOString();
+    const batchMessage = buildCommunicationBatchMessage(draft.communication, options.batchOptions);
+    const thid = typeof batchMessage.thid === 'string' ? batchMessage.thid : runtimeUuid();
+    return Object.freeze({
+        id: options.jobId || runtimeUuid(),
+        draftId: draft.id,
+        thid,
+        createdAt,
+        updatedAt: createdAt,
+        status: options.status || (isCommunicationDraftReady(draft)
+            ? CommunicationOutboxStatuses.Ready
+            : CommunicationOutboxStatuses.Draft),
+        payload: clone(draft.communication),
+        envelope: batchMessage,
+    });
+}
+/**
+ * Returns a copy of the outbox job with a new status and optional transport
+ * result metadata such as gateway responses or error messages.
+ *
+ * @param job Existing outbox job.
+ * @param status Next transport status.
+ * @param patch Optional response/error payload.
+ */
+export function updateOutboxJobStatus(job, status, patch = {}) {
+    return Object.freeze({
+        ...job,
+        status,
+        updatedAt: new Date().toISOString(),
+        ...(patch.response ? { response: clone(patch.response) } : {}),
+        ...(patch.errorMessage ? { errorMessage: patch.errorMessage } : {}),
+    });
+}