gdc-common-utils-ts 2.1.0 → 2.2.2

package/dist/utils/communication-didcomm-payload.js

@@ -1,8 +1,9 @@
 // Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { DidcommMessageTypes } from '../constants/didcomm.js';
 import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
 import { transformCommunicationClaimsToResourceFhirR4 } from './communication-fhir-r4.js';
 export const CommunicationDidcommEntryTypes = Object.freeze({
-    AttachedBundle: 'Communication-attached-bundle-v1.0',
+    AttachedBundle: DidcommMessageTypes.CommunicationAttachedBundle,
 });
 function clone(value) {
     return JSON.parse(JSON.stringify(value));
@@ -45,23 +46,32 @@ export function buildDidcommPayloadFromCommunicationClaims(input) {
  * one DIDComm-style payload.
  */
 export function getFirstCommunicationClaimsFromDidcommPayload(payload) {
-    const first = Array.isArray(payload?.body?.data) ? payload.body.data[0] : undefined;
-    const metaClaims = first?.meta && typeof first.meta === 'object'
-        ? first.meta['claims']
-        : undefined;
-    if (metaClaims && typeof metaClaims === 'object') {
-        return clone(metaClaims);
-    }
-    const resource = first?.resource && typeof first.resource === 'object'
-        ? first.resource
-        : {};
-    const meta = resource.meta && typeof resource.meta === 'object'
-        ? resource.meta
-        : {};
-    const claims = meta.claims && typeof meta.claims === 'object'
-        ? meta.claims
-        : {};
-    return clone(claims);
+    return getCommunicationClaimsListFromDidcommPayload(payload)[0] || {};
+}
+/**
+ * Reads canonical communication claims from every `body.data[]` entry of one
+ * DIDComm-style payload.
+ */
+export function getCommunicationClaimsListFromDidcommPayload(payload) {
+    const entries = Array.isArray(payload?.body?.data) ? payload.body.data : [];
+    return entries.map((first) => {
+        const metaClaims = first?.meta && typeof first.meta === 'object'
+            ? first.meta['claims']
+            : undefined;
+        if (metaClaims && typeof metaClaims === 'object') {
+            return clone(metaClaims);
+        }
+        const resource = first?.resource && typeof first.resource === 'object'
+            ? first.resource
+            : {};
+        const meta = resource.meta && typeof resource.meta === 'object'
+            ? resource.meta
+            : {};
+        const claims = meta.claims && typeof meta.claims === 'object'
+            ? meta.claims
+            : {};
+        return clone(claims);
+    });
 }
 /**
  * Decodes the attached bundle carried in `Communication.content-attachment-data`.

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

@@ -25,6 +25,18 @@ export type BuildDocumentReferenceResult = {
     evidence: EvidenceObjectDLT[];
     warnings: string[];
 };
+export type BlockchainArtifactDocumentReferenceInput = Readonly<{
+    subject: string;
+    resource?: Record<string, unknown>;
+    contentDataBase64?: string;
+    contentType?: string;
+    identifier?: string;
+    title?: string;
+    description?: string;
+    date?: string;
+    location?: string;
+    language?: string;
+}>;
 /**
  * Detects the logical attachment kind from a MIME type.
  *
@@ -39,3 +51,14 @@ export declare function detectAttachmentKind(contentType?: string): AttachmentKi
  * @param options.mode `strict` throws on invalid input, `normalize` applies best-effort defaults.
  */
 export declare function buildDocumentReferenceFromCommunicationPayload(communication: Record<string, any>, options?: BuildDocumentReferenceOptions): BuildDocumentReferenceResult;
+/**
+ * Builds a blockchain-ready `DocumentReference` projection from either a FHIR
+ * resource or already-encoded attachment bytes.
+ *
+ * The resulting projection keeps two identifiers distinct:
+ * - `contentCid`: canonical content address used for blockchain registration
+ * - `documentReference.identifier`: optional business identifier supplied by the caller
+ *
+ * @param input Source artifact data to wrap.
+ */
+export declare function buildBlockchainArtifactDocumentReference(input: BlockchainArtifactDocumentReferenceInput): BuildDocumentReferenceResult;

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

@@ -38,6 +38,9 @@ function cidFromBytes(bytes) {
 function decodeBase64(data) {
     return Uint8Array.from(Buffer.from(data, 'base64'));
 }
+function encodeBase64Utf8(data) {
+    return Buffer.from(data, 'utf8').toString('base64');
+}
 function toStringOrUndefined(value) {
     if (value === undefined || value === null)
         return undefined;
@@ -168,3 +171,89 @@ export function buildDocumentReferenceFromCommunicationPayload(communication, op
         warnings,
     };
 }
+/**
+ * Builds a blockchain-ready `DocumentReference` projection from either a FHIR
+ * resource or already-encoded attachment bytes.
+ *
+ * The resulting projection keeps two identifiers distinct:
+ * - `contentCid`: canonical content address used for blockchain registration
+ * - `documentReference.identifier`: optional business identifier supplied by the caller
+ *
+ * @param input Source artifact data to wrap.
+ */
+export function buildBlockchainArtifactDocumentReference(input) {
+    const subject = toStringOrUndefined(input.subject);
+    if (!subject) {
+        throw new Error('buildBlockchainArtifactDocumentReference requires subject.');
+    }
+    const resource = input.resource;
+    const hasResource = !!resource && typeof resource === 'object' && !Array.isArray(resource);
+    const contentType = toStringOrUndefined(input.contentType) || (hasResource ? 'application/fhir+json' : 'application/octet-stream');
+    const title = toStringOrUndefined(input.title) || (hasResource
+        ? `${String(resource.resourceType || 'resource').toLowerCase()}.json`
+        : 'artifact.bin');
+    let contentDataBase64 = toStringOrUndefined(input.contentDataBase64);
+    let contentCid;
+    let communicationLike;
+    if (hasResource) {
+        const serialized = JSON.stringify(resource);
+        contentDataBase64 = encodeBase64Utf8(serialized);
+        contentCid = fhirResourceToCid(resource).cid;
+        communicationLike = {
+            resourceType: 'Communication',
+            meta: { claims: { [CommunicationClaim.Subject]: subject } },
+            payload: [{ contentAttachment: { contentType, data: contentDataBase64, title } }],
+        };
+    }
+    else {
+        if (!contentDataBase64) {
+            throw new Error('buildBlockchainArtifactDocumentReference requires contentDataBase64 when resource is absent.');
+        }
+        contentCid = cidFromBytes(decodeBase64(contentDataBase64));
+        communicationLike = {
+            resourceType: 'Communication',
+            meta: { claims: { [CommunicationClaim.Subject]: subject } },
+            payload: [{ contentAttachment: { contentType, data: contentDataBase64, title, url: input.location } }],
+        };
+    }
+    const result = buildDocumentReferenceFromCommunicationPayload(communicationLike, { mode: 'strict' });
+    const logicalIdentifier = toStringOrUndefined(input.identifier) || contentCid;
+    const documentReference = {
+        ...result.documentReference,
+        identifier: logicalIdentifier ? [{ value: logicalIdentifier }] : undefined,
+        description: toStringOrUndefined(input.description) || result.documentReference.description,
+        date: toStringOrUndefined(input.date) || result.documentReference.date,
+        content: [{
+                attachment: {
+                    ...(result.documentReference.content?.[0]?.attachment || {}),
+                    contentType,
+                    data: contentDataBase64,
+                    url: toStringOrUndefined(input.location) || result.documentReference.content?.[0]?.attachment?.url,
+                    title,
+                    language: toStringOrUndefined(input.language) || result.documentReference.content?.[0]?.attachment?.language,
+                    hash: contentCid,
+                },
+            }],
+        meta: {
+            ...(result.documentReference.meta || {}),
+            versionId: contentCid,
+            claims: {
+                ...((result.documentReference.meta || {}).claims || {}),
+                [DocumentReferenceClaim.Identifier]: logicalIdentifier,
+                [DocumentReferenceClaim.ContentHash]: contentCid,
+                [DocumentReferenceClaim.ContentData]: contentDataBase64,
+                [DocumentReferenceClaim.ContentType]: contentType,
+                [DocumentReferenceClaim.Subject]: subject,
+                ...(toStringOrUndefined(input.description) ? { [DocumentReferenceClaim.Description]: input.description } : {}),
+                ...(toStringOrUndefined(input.date) ? { [DocumentReferenceClaim.Date]: input.date } : {}),
+                ...(toStringOrUndefined(input.location) ? { [DocumentReferenceClaim.Location]: input.location } : {}),
+                ...(toStringOrUndefined(input.language) ? { [DocumentReferenceClaim.Language]: input.language } : {}),
+            },
+        },
+    };
+    return {
+        ...result,
+        contentCid,
+        documentReference,
+    };
+}

package/dist/utils/communication-editor.d.ts

@@ -0,0 +1,53 @@
+import type { BundleEntry, BundleJsonApi } from '../models/bundle';
+import type { BundleResourceIdFilters } from './bundle-query';
+import { type CommunicationAttachedBundleSessionMode } from '../models/communication-attached-bundle-session';
+import { BundleReader } from './bundle-reader';
+import { CommunicationAttachedBundleSession } from './communication-attached-bundle-session';
+import type { IDecodedDidcommPayload } from '../models/confidential-message';
+export type CommunicationEditorOptions = Readonly<{
+    initialBundle?: BundleJsonApi<BundleEntry>;
+    mode?: CommunicationAttachedBundleSessionMode;
+    communicationClaims?: Record<string, unknown>;
+}>;
+/**
+ * Public high-level editor for one delivery `Communication`.
+ *
+ * Teaching contract:
+ * - use this name in tutorials when the caller is authoring one outer
+ *   `Communication`
+ * - keep `CommunicationAttachedBundleSession` as the lower-level compatibility
+ *   implementation detail underneath
+ */
+export declare class CommunicationEditor extends CommunicationAttachedBundleSession {
+    constructor(options?: CommunicationEditorOptions);
+    /** Materializes one immutable snapshot of the current Communication claims. */
+    done(): Record<string, unknown>;
+    /** Returns one reader over the current Communication snapshot. */
+    toReader(): CommunicationReader;
+}
+/**
+ * Public high-level reader for one delivery `Communication`.
+ */
+export declare class CommunicationReader {
+    private readonly session;
+    constructor(communicationClaims: Record<string, unknown>);
+    /** Reads the first delivery `Communication` carried in one DIDComm/plain payload. */
+    static fromDidcommPayload(payload: IDecodedDidcommPayload): CommunicationReader;
+    /** Reads every delivery `Communication` carried in one DIDComm/plain payload. */
+    static listFromDidcommPayload(payload: IDecodedDidcommPayload): CommunicationReader[];
+    getCommunicationClaims(): Record<string, unknown>;
+    getCommunicationIdentifier(): string;
+    getCommunicationSubject(): string;
+    getCommunicationCategoryList(): string[];
+    getCommunicationTopic(): string;
+    getCommunicationText(): string;
+    getAttachmentContentType(): string;
+    getAttachmentTitle(): string;
+    getAttachmentUrl(): string;
+    getAttachmentDataBase64(): string;
+    getAttachedBundle(): BundleJsonApi<BundleEntry>;
+    getAttachedBundleReader(): BundleReader;
+    getAttachedBundleResourceIds(filters?: BundleResourceIdFilters): string[];
+    getAttachedBundleEntriesByIds(resourceIds: readonly string[]): BundleEntry[];
+    getAttachedBundleEntryUrl(resourceId: string): string | undefined;
+}

package/dist/utils/communication-editor.js

@@ -0,0 +1,97 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { CommunicationClaimsContext, } from '../models/communication-attached-bundle-session.js';
+import { BundleReader } from './bundle-reader.js';
+import { CommunicationAttachedBundleSession } from './communication-attached-bundle-session.js';
+import { getCommunicationClaimsListFromDidcommPayload, getFirstCommunicationClaimsFromDidcommPayload, } from './communication-didcomm-payload.js';
+import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
+/**
+ * Public high-level editor for one delivery `Communication`.
+ *
+ * Teaching contract:
+ * - use this name in tutorials when the caller is authoring one outer
+ *   `Communication`
+ * - keep `CommunicationAttachedBundleSession` as the lower-level compatibility
+ *   implementation detail underneath
+ */
+export class CommunicationEditor extends CommunicationAttachedBundleSession {
+    constructor(options = {}) {
+        super({
+            ...options,
+            communicationClaims: {
+                '@context': CommunicationClaimsContext,
+                ...(options.communicationClaims || {}),
+            },
+        });
+    }
+    /** Materializes one immutable snapshot of the current Communication claims. */
+    done() {
+        return this.getCommunicationClaims();
+    }
+    /** Returns one reader over the current Communication snapshot. */
+    toReader() {
+        return new CommunicationReader(this.getCommunicationClaims());
+    }
+}
+/**
+ * Public high-level reader for one delivery `Communication`.
+ */
+export class CommunicationReader {
+    session;
+    constructor(communicationClaims) {
+        this.session = new CommunicationAttachedBundleSession({ communicationClaims });
+    }
+    /** Reads the first delivery `Communication` carried in one DIDComm/plain payload. */
+    static fromDidcommPayload(payload) {
+        return new CommunicationReader(getFirstCommunicationClaimsFromDidcommPayload(payload));
+    }
+    /** Reads every delivery `Communication` carried in one DIDComm/plain payload. */
+    static listFromDidcommPayload(payload) {
+        return getCommunicationClaimsListFromDidcommPayload(payload)
+            .map((communicationClaims) => new CommunicationReader(communicationClaims));
+    }
+    getCommunicationClaims() {
+        return this.session.getCommunicationClaims();
+    }
+    getCommunicationIdentifier() {
+        return this.session.getCommunicationIdentifier();
+    }
+    getCommunicationSubject() {
+        return this.session.getCommunicationSubject();
+    }
+    getCommunicationCategoryList() {
+        return this.session.getCommunicationCategoryList();
+    }
+    getCommunicationTopic() {
+        return this.session.getCommunicationTopic();
+    }
+    getCommunicationText() {
+        return this.session.getCommunicationText();
+    }
+    getAttachmentContentType() {
+        return String(this.getCommunicationClaims()[CommunicationClaim.ContentAttachmentType] || '').trim();
+    }
+    getAttachmentTitle() {
+        return String(this.getCommunicationClaims()[CommunicationClaim.ContentAttachmentTitle] || '').trim();
+    }
+    getAttachmentUrl() {
+        return String(this.getCommunicationClaims()[CommunicationClaim.ContentAttachmentUrl] || '').trim();
+    }
+    getAttachmentDataBase64() {
+        return String(this.getCommunicationClaims()[CommunicationClaim.ContentAttachmentData] || '').trim();
+    }
+    getAttachedBundle() {
+        return this.session.getAttachedBundle();
+    }
+    getAttachedBundleReader() {
+        return new BundleReader(this.getAttachedBundle());
+    }
+    getAttachedBundleResourceIds(filters = {}) {
+        return this.getAttachedBundleReader().getResourceIds(filters);
+    }
+    getAttachedBundleEntriesByIds(resourceIds) {
+        return this.getAttachedBundleReader().getEntriesByIds(resourceIds);
+    }
+    getAttachedBundleEntryUrl(resourceId) {
+        return this.getAttachedBundleReader().getEntryUrl(resourceId);
+    }
+}

package/dist/utils/condition-entry-editor.d.ts

@@ -0,0 +1,30 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged Condition resource entry.
+ *
+ * Use this when a caller needs to stage one condition row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export declare class ConditionEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier?: string | null): this;
+    getIdentifier(): string | undefined;
+    ensureIdentifier(): string;
+    setSubject(subject?: string | null): this;
+    getSubject(): string | undefined;
+    setCode(code?: string | null): this;
+    getCode(): string | undefined;
+    setClinicalStatus(status?: string | null): this;
+    getClinicalStatus(): string | undefined;
+    setVerificationStatus(status?: string | null): this;
+    getVerificationStatus(): string | undefined;
+    setCategory(category?: string | null): this;
+    getCategory(): string | undefined;
+    setSeverity(severity?: string | null): this;
+    getSeverity(): string | undefined;
+    setOnsetDateTime(value?: string | null): this;
+    getOnsetDateTime(): string | undefined;
+    setRecorder(reference?: string | null): this;
+    getRecorder(): string | undefined;
+    setContainedDocumentIdentifierList(identifiers: readonly string[]): this;
+    getContainedDocumentIdentifierList(): string[];
+}

package/dist/utils/condition-entry-editor.js

@@ -0,0 +1,34 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor.js';
+import { ConditionClaim } from '../models/interoperable-claims/condition-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged Condition resource entry.
+ *
+ * Use this when a caller needs to stage one condition row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export class ConditionEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(ConditionClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(ConditionClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(ConditionClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(ConditionClaim.Subject, ConditionClaim.Subject, subject); }
+    getSubject() { return this.getSubjectClaims(ConditionClaim.Subject, ConditionClaim.Subject); }
+    setCode(code) { return this.setScalarClaim(ConditionClaim.Code, code); }
+    getCode() { return this.getScalarClaim(ConditionClaim.Code); }
+    setClinicalStatus(status) { return this.setScalarClaim(ConditionClaim.ClinicalStatus, status); }
+    getClinicalStatus() { return this.getScalarClaim(ConditionClaim.ClinicalStatus); }
+    setVerificationStatus(status) { return this.setScalarClaim(ConditionClaim.VerificationStatus, status); }
+    getVerificationStatus() { return this.getScalarClaim(ConditionClaim.VerificationStatus); }
+    setCategory(category) { return this.setScalarClaim(ConditionClaim.Category, category); }
+    getCategory() { return this.getScalarClaim(ConditionClaim.Category); }
+    setSeverity(severity) { return this.setScalarClaim(ConditionClaim.Severity, severity); }
+    getSeverity() { return this.getScalarClaim(ConditionClaim.Severity); }
+    setOnsetDateTime(value) { return this.setScalarClaim(ConditionClaim.OnsetDateTime, value); }
+    getOnsetDateTime() { return this.getScalarClaim(ConditionClaim.OnsetDateTime); }
+    setRecorder(reference) { return this.setScalarClaim(ConditionClaim.Recorder, reference); }
+    getRecorder() { return this.getScalarClaim(ConditionClaim.Recorder); }
+    setContainedDocumentIdentifierList(identifiers) { return this.setCsvClaimList(ConditionClaim.ContainedDocuments, identifiers); }
+    getContainedDocumentIdentifierList() { return this.getCsvClaimList(ConditionClaim.ContainedDocuments); }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.condition, ConditionEntryEditor);

package/dist/utils/consent-claim-helpers.d.ts

@@ -77,9 +77,13 @@ export declare function removeSectors(claims: InteroperableClaims, values: strin
  * Returns linked DocumentReference identifiers carried by the consent.
  */
 export declare function getContainedDocumentIdentifierList(claims: InteroperableClaims): string[];
+export declare function getContainedResourceReferenceList(claims: InteroperableClaims): string[];
 export declare function setContainedDocumentIdentifierList(claims: InteroperableClaims, values: string | readonly string[]): InteroperableClaims;
+export declare function setContainedResourceReferenceList(claims: InteroperableClaims, values: string | readonly string[]): InteroperableClaims;
 export declare function addContainedDocumentIdentifierList(claims: InteroperableClaims, values: string | readonly string[]): InteroperableClaims;
 export declare function removeContainedDocumentIdentifierList(claims: InteroperableClaims, values: string | readonly string[]): InteroperableClaims;
+export declare function addContainedResourceReferenceList(claims: InteroperableClaims, values: string | readonly string[]): InteroperableClaims;
+export declare function removeContainedResourceReferenceList(claims: InteroperableClaims, values: string | readonly string[]): InteroperableClaims;
 /**
  * Reads the canonical consent date claim.
  */

package/dist/utils/consent-claim-helpers.js

@@ -167,13 +167,20 @@ export function removeSectors(claims, values) {
  */
 export function getContainedDocumentIdentifierList(claims) {
     return uniqueCsvLists([
+        getClaimValues(claims, ClaimConsent.containedReferenceList),
         getClaimValues(claims, ClaimConsent.containedDocuments),
         getClaimValues(claims, ClaimConsent.attachmentContentIds),
     ]);
 }
+export function getContainedResourceReferenceList(claims) {
+    return getContainedDocumentIdentifierList(claims);
+}
 export function setContainedDocumentIdentifierList(claims, values) {
     return setContainedDocuments(claims, values);
 }
+export function setContainedResourceReferenceList(claims, values) {
+    return setContainedDocuments(claims, values);
+}
 export function addContainedDocumentIdentifierList(claims, values) {
     return setContainedDocuments(claims, uniqueCsvLists([
         getContainedDocumentIdentifierList(claims),
@@ -186,11 +193,18 @@ export function removeContainedDocumentIdentifierList(claims, values) {
         .filter(Boolean));
     return setContainedDocuments(claims, getContainedDocumentIdentifierList(claims).filter((item) => !toRemove.has(item)));
 }
+export function addContainedResourceReferenceList(claims, values) {
+    return addContainedDocumentIdentifierList(claims, values);
+}
+export function removeContainedResourceReferenceList(claims, values) {
+    return removeContainedDocumentIdentifierList(claims, values);
+}
 function setContainedDocuments(claims, values) {
-    const next = setClaimValues(claims, ClaimConsent.containedDocuments, values);
+    const next = setClaimValues(claims, ClaimConsent.containedReferenceList, values);
     const cleaned = {
         ...next,
     };
+    delete cleaned[ClaimConsent.containedDocuments];
     delete cleaned[ClaimConsent.attachmentContentIds];
     return cleaned;
 }

package/dist/utils/coverage-entry-editor.d.ts

@@ -0,0 +1,51 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged Coverage resource entry.
+ *
+ * Use this when a caller needs to stage one coverage row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export declare class CoverageEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical coverage identifier. */
+    setIdentifier(identifier?: string | null): this;
+    /** Reads the canonical coverage identifier. */
+    getIdentifier(): string | undefined;
+    /** Ensures the coverage entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier(): string;
+    /** Writes the coverage status. */
+    setStatus(value?: string | null): this;
+    /** Reads the coverage status. */
+    getStatus(): string | undefined;
+    /** Writes the coverage type. */
+    setType(value?: string | null): this;
+    /** Reads the coverage type. */
+    getType(): string | undefined;
+    /** Writes the policy-holder reference. */
+    setPolicyHolder(value?: string | null): this;
+    /** Reads the policy-holder reference. */
+    getPolicyHolder(): string | undefined;
+    /** Writes the subscriber reference. */
+    setSubscriber(value?: string | null): this;
+    /** Reads the subscriber reference. */
+    getSubscriber(): string | undefined;
+    /** Writes the beneficiary reference. */
+    setBeneficiary(value?: string | null): this;
+    /** Reads the beneficiary reference. */
+    getBeneficiary(): string | undefined;
+    /** Writes the subscriber relationship. */
+    setRelationship(value?: string | null): this;
+    /** Reads the subscriber relationship. */
+    getRelationship(): string | undefined;
+    /** Writes the coverage period start. */
+    setPeriodStart(value?: string | null): this;
+    /** Reads the coverage period start. */
+    getPeriodStart(): string | undefined;
+    /** Writes the coverage period end. */
+    setPeriodEnd(value?: string | null): this;
+    /** Reads the coverage period end. */
+    getPeriodEnd(): string | undefined;
+    /** Writes the payor list. */
+    setPayorList(values: readonly string[]): this;
+    /** Reads the payor list. */
+    getPayorList(): string[];
+}

package/dist/utils/coverage-entry-editor.js

@@ -0,0 +1,55 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor.js';
+import { CoverageClaim } from '../models/interoperable-claims/coverage-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged Coverage resource entry.
+ *
+ * Use this when a caller needs to stage one coverage row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export class CoverageEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical coverage identifier. */
+    setIdentifier(identifier) { return this.setIdentifierValue(CoverageClaim.Identifier, identifier); }
+    /** Reads the canonical coverage identifier. */
+    getIdentifier() { return this.getIdentifierValue(CoverageClaim.Identifier); }
+    /** Ensures the coverage entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier() { return this.ensureIdentifierValue(CoverageClaim.Identifier); }
+    /** Writes the coverage status. */
+    setStatus(value) { return this.setScalarClaim(CoverageClaim.Status, value); }
+    /** Reads the coverage status. */
+    getStatus() { return this.getScalarClaim(CoverageClaim.Status); }
+    /** Writes the coverage type. */
+    setType(value) { return this.setScalarClaim(CoverageClaim.Type, value); }
+    /** Reads the coverage type. */
+    getType() { return this.getScalarClaim(CoverageClaim.Type); }
+    /** Writes the policy-holder reference. */
+    setPolicyHolder(value) { return this.setScalarClaim(CoverageClaim.PolicyHolder, value); }
+    /** Reads the policy-holder reference. */
+    getPolicyHolder() { return this.getScalarClaim(CoverageClaim.PolicyHolder); }
+    /** Writes the subscriber reference. */
+    setSubscriber(value) { return this.setScalarClaim(CoverageClaim.Subscriber, value); }
+    /** Reads the subscriber reference. */
+    getSubscriber() { return this.getScalarClaim(CoverageClaim.Subscriber); }
+    /** Writes the beneficiary reference. */
+    setBeneficiary(value) { return this.setScalarClaim(CoverageClaim.Beneficiary, value); }
+    /** Reads the beneficiary reference. */
+    getBeneficiary() { return this.getScalarClaim(CoverageClaim.Beneficiary); }
+    /** Writes the subscriber relationship. */
+    setRelationship(value) { return this.setScalarClaim(CoverageClaim.Relationship, value); }
+    /** Reads the subscriber relationship. */
+    getRelationship() { return this.getScalarClaim(CoverageClaim.Relationship); }
+    /** Writes the coverage period start. */
+    setPeriodStart(value) { return this.setScalarClaim(CoverageClaim.PeriodStart, value); }
+    /** Reads the coverage period start. */
+    getPeriodStart() { return this.getScalarClaim(CoverageClaim.PeriodStart); }
+    /** Writes the coverage period end. */
+    setPeriodEnd(value) { return this.setScalarClaim(CoverageClaim.PeriodEnd, value); }
+    /** Reads the coverage period end. */
+    getPeriodEnd() { return this.getScalarClaim(CoverageClaim.PeriodEnd); }
+    /** Writes the payor list. */
+    setPayorList(values) { return this.setCsvClaimList(CoverageClaim.Payor, values); }
+    /** Reads the payor list. */
+    getPayorList() { return this.getCsvClaimList(CoverageClaim.Payor); }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.coverage, CoverageEntryEditor);

package/dist/utils/device-entry-editor.d.ts

@@ -0,0 +1,59 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged Device resource entry.
+ *
+ * Use this when a caller needs to stage one device row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export declare class DeviceEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical device identifier. */
+    setIdentifier(identifier?: string | null): this;
+    /** Reads the canonical device identifier. */
+    getIdentifier(): string | undefined;
+    /** Ensures the device entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier(): string;
+    /** Writes the patient reference for the device. */
+    setPatient(value?: string | null): this;
+    /** Reads the patient reference for the device. */
+    getPatient(): string | undefined;
+    /** Writes the device status. */
+    setStatus(value?: string | null): this;
+    /** Reads the device status. */
+    getStatus(): string | undefined;
+    /** Writes the device type. */
+    setType(value?: string | null): this;
+    /** Reads the device type. */
+    getType(): string | undefined;
+    /** Writes the manufacturer reference. */
+    setManufacturer(value?: string | null): this;
+    /** Reads the manufacturer reference. */
+    getManufacturer(): string | undefined;
+    /** Writes the model. */
+    setModel(value?: string | null): this;
+    /** Reads the model. */
+    getModel(): string | undefined;
+    /** Writes the human-readable device name. */
+    setDeviceName(value?: string | null): this;
+    /** Reads the human-readable device name. */
+    getDeviceName(): string | undefined;
+    /** Writes the serial number. */
+    setSerialNumber(value?: string | null): this;
+    /** Reads the serial number. */
+    getSerialNumber(): string | undefined;
+    /** Writes the owning organization. */
+    setOrganization(value?: string | null): this;
+    /** Reads the owning organization. */
+    getOrganization(): string | undefined;
+    /** Writes the location reference. */
+    setLocation(value?: string | null): this;
+    /** Reads the location reference. */
+    getLocation(): string | undefined;
+    /** Writes the URL reference. */
+    setUrl(value?: string | null): this;
+    /** Reads the URL reference. */
+    getUrl(): string | undefined;
+    /** Writes the note text. */
+    setNote(value?: string | null): this;
+    /** Reads the note text. */
+    getNote(): string | undefined;
+}