gdc-common-utils-ts 2.0.6 → 2.0.8

package/dist/utils/bundle-editor.js

@@ -1,13 +1,42 @@
 import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
 import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
 import { ObservationCategoryCodes, VitalSignsCodes, VitalSignsUnits } from '../constants/vital-signs.js';
+import { AllergyIntoleranceClaim } from '../models/interoperable-claims/allergy-intolerance-claims.js';
+import { CarePlanClaim } from '../models/interoperable-claims/care-plan-claims.js';
+import { ClinicalImpressionClaim } from '../models/interoperable-claims/clinical-impression-claims.js';
+import { ConditionClaim } from '../models/interoperable-claims/condition-claims.js';
+import { CoverageClaim } from '../models/interoperable-claims/coverage-claims.js';
+import { DeviceClaim } from '../models/interoperable-claims/device-claims.js';
+import { DeviceUseStatementClaim } from '../models/interoperable-claims/device-use-statement-claims.js';
+import { DiagnosticReportClaim } from '../models/interoperable-claims/diagnostic-report-claims.js';
+import { DocumentReferenceClaim } from '../models/interoperable-claims/document-reference-claims.js';
+import { EncounterClaim } from '../models/interoperable-claims/encounter-claims.js';
+import { FlagClaim } from '../models/interoperable-claims/flag-claims.js';
+import { ImmunizationClaim } from '../models/interoperable-claims/immunization-claims.js';
+import { MedicationStatementClaim, MedicationStatementClaimsFhirApiExtended, } from '../models/interoperable-claims/medication-statement-claims.js';
 import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
+import { ProcedureClaim } from '../models/interoperable-claims/procedure-claims.js';
+import { getClaimValues, setClaimValues } from '../claims/claim-list-helpers.js';
 import { buildEmployeeBatchEntry, buildEmployeePurgeBundle, buildEmployeeSearchBundle, EmployeeBatchEntryTypes, EmployeeBundleMethods, EmployeeBundleOperations, EmployeeResourceTypes, } from './employee.js';
 export const BundleEditableResourceTypes = Object.freeze({
     employee: EmployeeResourceTypes.employee,
     consent: ResourceTypesFhirR4.Consent,
     observation: ResourceTypesFhirR4.Observation,
     vitalSign: ResourceTypesFhirR4.Observation,
+    allergyIntolerance: ResourceTypesFhirR4.AllergyIntolerance,
+    condition: ResourceTypesFhirR4.Condition,
+    medicationStatement: ResourceTypesFhirR4.MedicationStatement,
+    documentReference: ResourceTypesFhirR4.DocumentReference,
+    carePlan: ResourceTypesFhirR4.CarePlan,
+    flag: ResourceTypesFhirR4.Flag,
+    clinicalImpression: ResourceTypesFhirR4.ClinicalImpression,
+    device: ResourceTypesFhirR4.Device,
+    deviceUseStatement: ResourceTypesFhirR4.DeviceUseStatement,
+    encounter: ResourceTypesFhirR4.Encounter,
+    coverage: ResourceTypesFhirR4.Coverage,
+    immunization: ResourceTypesFhirR4.Immunization,
+    procedure: ResourceTypesFhirR4.Procedure,
+    diagnosticReport: ResourceTypesFhirR4.DiagnosticReport,
 });
 function cloneEntry(value) {
     return JSON.parse(JSON.stringify(value));
@@ -344,6 +373,118 @@ export class BundleEntryEditor {
         }
         return new ObservationEntryEditor(this.bundleEditor, this.entryIndex);
     }
+    /** Opens the current entry as one AllergyIntolerance editor. */
+    asAllergy() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.AllergyIntolerance) {
+            throw new Error(`BundleEntryEditor cannot open this entry as AllergyIntolerance: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new AllergyIntoleranceEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one Condition editor. */
+    asCondition() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Condition) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Condition: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new ConditionEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one MedicationStatement editor. */
+    asMedicationStatement() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.MedicationStatement) {
+            throw new Error(`BundleEntryEditor cannot open this entry as MedicationStatement: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new MedicationStatementEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one DocumentReference editor. */
+    asDocumentReference() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.DocumentReference) {
+            throw new Error(`BundleEntryEditor cannot open this entry as DocumentReference: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new DocumentReferenceEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one CarePlan editor. */
+    asCarePlan() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.CarePlan) {
+            throw new Error(`BundleEntryEditor cannot open this entry as CarePlan: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new CarePlanEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one Flag editor. */
+    asFlag() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Flag) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Flag: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new FlagEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one ClinicalImpression editor. */
+    asClinicalImpression() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.ClinicalImpression) {
+            throw new Error(`BundleEntryEditor cannot open this entry as ClinicalImpression: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new ClinicalImpressionEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one Device editor. */
+    asDevice() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Device) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Device: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new DeviceEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one DeviceUseStatement editor. */
+    asDeviceUseStatement() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.DeviceUseStatement) {
+            throw new Error(`BundleEntryEditor cannot open this entry as DeviceUseStatement: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new DeviceUseStatementEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one Encounter editor. */
+    asEncounter() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Encounter) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Encounter: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new EncounterEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one Coverage editor. */
+    asCoverage() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Coverage) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Coverage: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new CoverageEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one Immunization editor. */
+    asImmunization() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Immunization) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Immunization: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new ImmunizationEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one Procedure editor. */
+    asProcedure() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Procedure) {
+            throw new Error(`BundleEntryEditor cannot open this entry as Procedure: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new ProcedureEntryEditor(this.bundleEditor, this.entryIndex);
+    }
+    /** Opens the current entry as one DiagnosticReport editor. */
+    asDiagnosticReport() {
+        const entry = this.getMutableEntry();
+        if (entry.resource?.resourceType !== ResourceTypesFhirR4.DiagnosticReport) {
+            throw new Error(`BundleEntryEditor cannot open this entry as DiagnosticReport: ${String(entry.resource?.resourceType || '')}`);
+        }
+        return new DiagnosticReportEntryEditor(this.bundleEditor, this.entryIndex);
+    }
     /** Reads one claim from this entry. */
     getClaim(key) {
         return cloneClaimValue(this.getClaims()[String(key).trim()]);
@@ -440,6 +581,109 @@ export class BundleEntryEditor {
         };
     }
 }
+/**
+ * Shared claims-first editor utilities for IPS clinical resource families.
+ *
+ * The concrete resource type changes, but the editing contract stays aligned:
+ * identifier + subject + status + date + optional CSV-backed reference lists.
+ */
+class ClinicalResourceEntryEditor extends BundleEntryEditor {
+    getIdentifierValue(claimKey) {
+        return normalizeOptionalIdentifier(this.getClaim(claimKey)
+            || this.getResourceId()
+            || this.getFullUrl());
+    }
+    setIdentifierValue(claimKey, identifier) {
+        const normalized = normalizeOptionalIdentifier(identifier);
+        if (!normalized) {
+            this.removeClaim(claimKey);
+            this.setResourceId(undefined);
+            this.setFullUrl(undefined);
+            return this;
+        }
+        this.setClaim(claimKey, normalized);
+        this.setResourceId(normalized);
+        this.setFullUrl(normalized);
+        return this;
+    }
+    setSubjectClaims(subjectClaimKey, patientClaimKey, subject) {
+        const normalized = normalizeOptionalIdentifier(subject);
+        if (!normalized) {
+            this.removeClaim(subjectClaimKey);
+            this.removeClaim(patientClaimKey);
+            return this;
+        }
+        this.setClaim(subjectClaimKey, normalized);
+        this.setClaim(patientClaimKey, normalized);
+        return this;
+    }
+    getSubjectClaims(subjectClaimKey, patientClaimKey) {
+        return normalizeOptionalIdentifier(this.getClaim(subjectClaimKey)
+            || this.getClaim(patientClaimKey));
+    }
+    setScalarClaim(claimKey, value) {
+        const normalized = normalizeOptionalIdentifier(value);
+        if (!normalized) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, normalized);
+    }
+    getScalarClaim(claimKey) {
+        return normalizeOptionalIdentifier(this.getClaim(claimKey));
+    }
+    setNumberClaim(claimKey, value) {
+        if (value === undefined || value === null || Number.isNaN(value)) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, String(value));
+    }
+    getNumberClaim(claimKey) {
+        const raw = this.getClaim(claimKey);
+        if (raw === undefined || raw === null || raw === '')
+            return undefined;
+        const numeric = Number(raw);
+        return Number.isFinite(numeric) ? numeric : undefined;
+    }
+    setBooleanClaim(claimKey, value) {
+        if (value === undefined || value === null) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, value);
+    }
+    getBooleanClaim(claimKey) {
+        const raw = this.getClaim(claimKey);
+        if (typeof raw === 'boolean')
+            return raw;
+        if (raw === 'true')
+            return true;
+        if (raw === 'false')
+            return false;
+        return undefined;
+    }
+    setCsvClaimList(claimKey, values) {
+        const next = setClaimValues({}, claimKey, values);
+        const normalized = normalizeOptionalIdentifier(next[claimKey]);
+        if (!normalized) {
+            this.removeClaim(claimKey);
+            return this;
+        }
+        return this.setClaim(claimKey, normalized);
+    }
+    getCsvClaimList(claimKey) {
+        return getClaimValues(this.getClaims(), claimKey);
+    }
+    ensureIdentifierValue(claimKey) {
+        const existing = this.getIdentifierValue(claimKey);
+        if (existing)
+            return existing;
+        const generated = createCanonicalIdentifierUrn();
+        this.setIdentifierValue(claimKey, generated);
+        return generated;
+    }
+}
 /**
  * Reduced Observation component-style editor surface.
  *
@@ -676,6 +920,590 @@ export class ObservationEntryEditor extends VitalSignEntryEditor {
     getHasMember() {
         return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.HasMember));
     }
+    setHasMemberList(references) {
+        const next = setClaimValues({}, ObservationClaim.HasMember, references);
+        const normalized = normalizeOptionalIdentifier(next[ObservationClaim.HasMember]);
+        if (!normalized) {
+            this.removeClaim(ObservationClaim.HasMember);
+            return this;
+        }
+        return this.setClaim(ObservationClaim.HasMember, normalized);
+    }
+    getHasMemberList() {
+        return getClaimValues(this.getClaims(), ObservationClaim.HasMember);
+    }
+}
+/** Claims-first editor for one staged AllergyIntolerance entry. */
+export class AllergyIntoleranceEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(AllergyIntoleranceClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(AllergyIntoleranceClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(AllergyIntoleranceClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(AllergyIntoleranceClaim.Subject, AllergyIntoleranceClaim.Patient, subject); }
+    getSubject() { return this.getSubjectClaims(AllergyIntoleranceClaim.Subject, AllergyIntoleranceClaim.Patient); }
+    setCode(code) { return this.setScalarClaim(AllergyIntoleranceClaim.Code, code); }
+    getCode() { return this.getScalarClaim(AllergyIntoleranceClaim.Code); }
+    setClinicalStatus(status) { return this.setScalarClaim(AllergyIntoleranceClaim.ClinicalStatus, status); }
+    getClinicalStatus() { return this.getScalarClaim(AllergyIntoleranceClaim.ClinicalStatus); }
+    setVerificationStatus(status) { return this.setScalarClaim(AllergyIntoleranceClaim.VerificationStatus, status); }
+    getVerificationStatus() { return this.getScalarClaim(AllergyIntoleranceClaim.VerificationStatus); }
+    setCategory(category) { return this.setScalarClaim(AllergyIntoleranceClaim.Category, category); }
+    getCategory() { return this.getScalarClaim(AllergyIntoleranceClaim.Category); }
+    setCriticality(criticality) { return this.setScalarClaim(AllergyIntoleranceClaim.Criticality, criticality); }
+    getCriticality() { return this.getScalarClaim(AllergyIntoleranceClaim.Criticality); }
+    setOnsetDateTime(value) { return this.setScalarClaim(AllergyIntoleranceClaim.OnsetDateTime, value); }
+    getOnsetDateTime() { return this.getScalarClaim(AllergyIntoleranceClaim.OnsetDateTime); }
+    setRecorder(reference) { return this.setScalarClaim(AllergyIntoleranceClaim.Recorder, reference); }
+    getRecorder() { return this.getScalarClaim(AllergyIntoleranceClaim.Recorder); }
+    setContainedDocumentIdentifierList(identifiers) { return this.setCsvClaimList(AllergyIntoleranceClaim.ContainedDocuments, identifiers); }
+    getContainedDocumentIdentifierList() { return this.getCsvClaimList(AllergyIntoleranceClaim.ContainedDocuments); }
+}
+/** Claims-first editor for one staged Condition entry. */
+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); }
+}
+/** Claims-first editor for one staged MedicationStatement entry. */
+export class MedicationStatementEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(MedicationStatementClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(MedicationStatementClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(MedicationStatementClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(MedicationStatementClaim.Subject, MedicationStatementClaim.Patient, subject); }
+    getSubject() { return this.getSubjectClaims(MedicationStatementClaim.Subject, MedicationStatementClaim.Patient); }
+    setStatus(status) { return this.setScalarClaim(MedicationStatementClaim.Status, status); }
+    getStatus() { return this.getScalarClaim(MedicationStatementClaim.Status); }
+    setEffective(value) { return this.setScalarClaim(MedicationStatementClaim.Effective, value); }
+    getEffective() { return this.getScalarClaim(MedicationStatementClaim.Effective); }
+    setCode(code) { return this.setScalarClaim(MedicationStatementClaim.Code, code); }
+    getCode() { return this.getScalarClaim(MedicationStatementClaim.Code); }
+    setMedicationText(text) { return this.setScalarClaim(MedicationStatementClaim.MedicationText, text); }
+    getMedicationText() { return this.getScalarClaim(MedicationStatementClaim.MedicationText); }
+    setNote(note) { return this.setScalarClaim(MedicationStatementClaim.Note, note); }
+    getNote() { return this.getScalarClaim(MedicationStatementClaim.Note); }
+    setDosageInstruction(value) { return this.setScalarClaim(MedicationStatementClaim.DosageInstruction, value); }
+    getDosageInstruction() { return this.getScalarClaim(MedicationStatementClaim.DosageInstruction); }
+    setCategoryList(values) { return this.setCsvClaimList(MedicationStatementClaim.Category, values); }
+    getCategoryList() { return this.getCsvClaimList(MedicationStatementClaim.Category); }
+    setDoseQuantityValue(value) { return this.setNumberClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityValue, value); }
+    getDoseQuantityValue() { return this.getNumberClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityValue); }
+    setDoseQuantityUnit(value) { return this.setScalarClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityUnit, value); }
+    getDoseQuantityUnit() { return this.getScalarClaim(MedicationStatementClaimsFhirApiExtended.DoseQuantityUnit); }
+    setTimingFrequency(value) { return this.setNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingFrequency, value); }
+    getTimingFrequency() { return this.getNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingFrequency); }
+    setTimingPeriod(value) { return this.setNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriod, value); }
+    getTimingPeriod() { return this.getNumberClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriod); }
+    setTimingPeriodUnit(value) { return this.setScalarClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriodUnit, value); }
+    getTimingPeriodUnit() { return this.getScalarClaim(MedicationStatementClaimsFhirApiExtended.TimingPeriodUnit); }
+    setDosageAsNeeded(value) { return this.setBooleanClaim(MedicationStatementClaimsFhirApiExtended.DosageAsNeeded, value); }
+    getDosageAsNeeded() { return this.getBooleanClaim(MedicationStatementClaimsFhirApiExtended.DosageAsNeeded); }
+}
+/** Claims-first editor for one staged DocumentReference entry. */
+export class DocumentReferenceEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(DocumentReferenceClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(DocumentReferenceClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(DocumentReferenceClaim.Identifier); }
+    setSubject(subject) { return this.setScalarClaim(DocumentReferenceClaim.Subject, subject); }
+    getSubject() { return this.getScalarClaim(DocumentReferenceClaim.Subject); }
+    setType(value) { return this.setScalarClaim(DocumentReferenceClaim.Type, value); }
+    getType() { return this.getScalarClaim(DocumentReferenceClaim.Type); }
+    setCategory(value) { return this.setScalarClaim(DocumentReferenceClaim.Category, value); }
+    getCategory() { return this.getScalarClaim(DocumentReferenceClaim.Category); }
+    setContentType(value) { return this.setScalarClaim(DocumentReferenceClaim.ContentType, value); }
+    getContentType() { return this.getScalarClaim(DocumentReferenceClaim.ContentType); }
+    setContentData(value) { return this.setScalarClaim(DocumentReferenceClaim.ContentData, value); }
+    getContentData() { return this.getScalarClaim(DocumentReferenceClaim.ContentData); }
+    setContentHash(value) { return this.setScalarClaim(DocumentReferenceClaim.ContentHash, value); }
+    getContentHash() { return this.getScalarClaim(DocumentReferenceClaim.ContentHash); }
+    setLocation(value) { return this.setScalarClaim(DocumentReferenceClaim.Location, value); }
+    getLocation() { return this.getScalarClaim(DocumentReferenceClaim.Location); }
+    setDescription(value) { return this.setScalarClaim(DocumentReferenceClaim.Description, value); }
+    getDescription() { return this.getScalarClaim(DocumentReferenceClaim.Description); }
+    setDate(value) { return this.setScalarClaim(DocumentReferenceClaim.Date, value); }
+    getDate() { return this.getScalarClaim(DocumentReferenceClaim.Date); }
+    setAuthor(value) { return this.setScalarClaim(DocumentReferenceClaim.Author, value); }
+    getAuthor() { return this.getScalarClaim(DocumentReferenceClaim.Author); }
+}
+/** Claims-first editor for one staged CarePlan entry. */
+export class CarePlanEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(CarePlanClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(CarePlanClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(CarePlanClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(CarePlanClaim.Subject, CarePlanClaim.Patient, subject); }
+    getSubject() { return this.getSubjectClaims(CarePlanClaim.Subject, CarePlanClaim.Patient); }
+    setStatus(value) { return this.setScalarClaim(CarePlanClaim.Status, value); }
+    getStatus() { return this.getScalarClaim(CarePlanClaim.Status); }
+    setIntent(value) { return this.setScalarClaim(CarePlanClaim.Intent, value); }
+    getIntent() { return this.getScalarClaim(CarePlanClaim.Intent); }
+    setCategory(value) { return this.setScalarClaim(CarePlanClaim.Category, value); }
+    getCategory() { return this.getScalarClaim(CarePlanClaim.Category); }
+    setEncounter(value) { return this.setScalarClaim(CarePlanClaim.Encounter, value); }
+    getEncounter() { return this.getScalarClaim(CarePlanClaim.Encounter); }
+    setDate(value) { return this.setScalarClaim(CarePlanClaim.Date, value); }
+    getDate() { return this.getScalarClaim(CarePlanClaim.Date); }
+    setNote(value) { return this.setScalarClaim(CarePlanClaim.Note, value); }
+    getNote() { return this.getScalarClaim(CarePlanClaim.Note); }
+}
+/** Claims-first editor for one staged Flag entry. */
+export class FlagEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(FlagClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(FlagClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(FlagClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(FlagClaim.Subject, FlagClaim.Patient, subject); }
+    getSubject() { return this.getSubjectClaims(FlagClaim.Subject, FlagClaim.Patient); }
+    setStatus(value) { return this.setScalarClaim(FlagClaim.Status, value); }
+    getStatus() { return this.getScalarClaim(FlagClaim.Status); }
+    setCategory(value) { return this.setScalarClaim(FlagClaim.Category, value); }
+    getCategory() { return this.getScalarClaim(FlagClaim.Category); }
+    setCode(value) { return this.setScalarClaim(FlagClaim.Code, value); }
+    getCode() { return this.getScalarClaim(FlagClaim.Code); }
+    setDate(value) { return this.setScalarClaim(FlagClaim.Date, value); }
+    getDate() { return this.getScalarClaim(FlagClaim.Date); }
+    setEncounter(value) { return this.setScalarClaim(FlagClaim.Encounter, value); }
+    getEncounter() { return this.getScalarClaim(FlagClaim.Encounter); }
+    setPeriodStart(value) { return this.setScalarClaim(FlagClaim.PeriodStart, value); }
+    getPeriodStart() { return this.getScalarClaim(FlagClaim.PeriodStart); }
+    setPeriodEnd(value) { return this.setScalarClaim(FlagClaim.PeriodEnd, value); }
+    getPeriodEnd() { return this.getScalarClaim(FlagClaim.PeriodEnd); }
+}
+/** Claims-first editor for one staged ClinicalImpression entry. */
+export class ClinicalImpressionEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(ClinicalImpressionClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(ClinicalImpressionClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(ClinicalImpressionClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(ClinicalImpressionClaim.Subject, ClinicalImpressionClaim.Subject, subject); }
+    getSubject() { return this.getSubjectClaims(ClinicalImpressionClaim.Subject, ClinicalImpressionClaim.Subject); }
+    setStatus(value) { return this.setScalarClaim(ClinicalImpressionClaim.Status, value); }
+    getStatus() { return this.getScalarClaim(ClinicalImpressionClaim.Status); }
+    setDescription(value) { return this.setScalarClaim(ClinicalImpressionClaim.Description, value); }
+    getDescription() { return this.getScalarClaim(ClinicalImpressionClaim.Description); }
+    setEncounter(value) { return this.setScalarClaim(ClinicalImpressionClaim.Encounter, value); }
+    getEncounter() { return this.getScalarClaim(ClinicalImpressionClaim.Encounter); }
+    setEffectiveDateTime(value) { return this.setScalarClaim(ClinicalImpressionClaim.EffectiveDateTime, value); }
+    getEffectiveDateTime() { return this.getScalarClaim(ClinicalImpressionClaim.EffectiveDateTime); }
+    setAssessor(value) { return this.setScalarClaim(ClinicalImpressionClaim.Assessor, value); }
+    getAssessor() { return this.getScalarClaim(ClinicalImpressionClaim.Assessor); }
+    setSummary(value) { return this.setScalarClaim(ClinicalImpressionClaim.Summary, value); }
+    getSummary() { return this.getScalarClaim(ClinicalImpressionClaim.Summary); }
+}
+/** Claims-first editor for one staged Device entry. */
+export class DeviceEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(DeviceClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(DeviceClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(DeviceClaim.Identifier); }
+    setPatient(value) { return this.setScalarClaim(DeviceClaim.Patient, value); }
+    getPatient() { return this.getScalarClaim(DeviceClaim.Patient); }
+    setStatus(value) { return this.setScalarClaim(DeviceClaim.Status, value); }
+    getStatus() { return this.getScalarClaim(DeviceClaim.Status); }
+    setType(value) { return this.setScalarClaim(DeviceClaim.Type, value); }
+    getType() { return this.getScalarClaim(DeviceClaim.Type); }
+    setManufacturer(value) { return this.setScalarClaim(DeviceClaim.Manufacturer, value); }
+    getManufacturer() { return this.getScalarClaim(DeviceClaim.Manufacturer); }
+    setModel(value) { return this.setScalarClaim(DeviceClaim.Model, value); }
+    getModel() { return this.getScalarClaim(DeviceClaim.Model); }
+    setDeviceName(value) { return this.setScalarClaim(DeviceClaim.DeviceName, value); }
+    getDeviceName() { return this.getScalarClaim(DeviceClaim.DeviceName); }
+    setSerialNumber(value) { return this.setScalarClaim(DeviceClaim.SerialNumber, value); }
+    getSerialNumber() { return this.getScalarClaim(DeviceClaim.SerialNumber); }
+    setOrganization(value) { return this.setScalarClaim(DeviceClaim.Organization, value); }
+    getOrganization() { return this.getScalarClaim(DeviceClaim.Organization); }
+    setLocation(value) { return this.setScalarClaim(DeviceClaim.Location, value); }
+    getLocation() { return this.getScalarClaim(DeviceClaim.Location); }
+    setUrl(value) { return this.setScalarClaim(DeviceClaim.Url, value); }
+    getUrl() { return this.getScalarClaim(DeviceClaim.Url); }
+    setNote(value) { return this.setScalarClaim(DeviceClaim.Note, value); }
+    getNote() { return this.getScalarClaim(DeviceClaim.Note); }
+}
+/** Claims-first editor for one staged DeviceUseStatement entry. */
+export class DeviceUseStatementEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(DeviceUseStatementClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(DeviceUseStatementClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(DeviceUseStatementClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(DeviceUseStatementClaim.Subject, DeviceUseStatementClaim.Subject, subject); }
+    getSubject() { return this.getSubjectClaims(DeviceUseStatementClaim.Subject, DeviceUseStatementClaim.Subject); }
+    setStatus(value) { return this.setScalarClaim(DeviceUseStatementClaim.Status, value); }
+    getStatus() { return this.getScalarClaim(DeviceUseStatementClaim.Status); }
+    setDevice(value) { return this.setScalarClaim(DeviceUseStatementClaim.Device, value); }
+    getDevice() { return this.getScalarClaim(DeviceUseStatementClaim.Device); }
+    setRecordedOn(value) { return this.setScalarClaim(DeviceUseStatementClaim.RecordedOn, value); }
+    getRecordedOn() { return this.getScalarClaim(DeviceUseStatementClaim.RecordedOn); }
+    setTimingDateTime(value) { return this.setScalarClaim(DeviceUseStatementClaim.TimingDateTime, value); }
+    getTimingDateTime() { return this.getScalarClaim(DeviceUseStatementClaim.TimingDateTime); }
+    setReasonCode(value) { return this.setScalarClaim(DeviceUseStatementClaim.ReasonCode, value); }
+    getReasonCode() { return this.getScalarClaim(DeviceUseStatementClaim.ReasonCode); }
+    setSource(value) { return this.setScalarClaim(DeviceUseStatementClaim.Source, value); }
+    getSource() { return this.getScalarClaim(DeviceUseStatementClaim.Source); }
+}
+/** Claims-first editor for one staged Encounter entry. */
+export class EncounterEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(EncounterClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(EncounterClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(EncounterClaim.Identifier); }
+    setSubject(subject) { return this.setSubjectClaims(EncounterClaim.Subject, EncounterClaim.Patient, subject); }
+    getSubject() { return this.getSubjectClaims(EncounterClaim.Subject, EncounterClaim.Patient); }
+    setStatus(value) { return this.setScalarClaim(EncounterClaim.Status, value); }
+    getStatus() { return this.getScalarClaim(EncounterClaim.Status); }
+    setClass(value) { return this.setScalarClaim(EncounterClaim.Class, value); }
+    getClass() { return this.getScalarClaim(EncounterClaim.Class); }
+    setType(value) { return this.setScalarClaim(EncounterClaim.Type, value); }
+    getType() { return this.getScalarClaim(EncounterClaim.Type); }
+    setParticipantList(values) { return this.setCsvClaimList(EncounterClaim.Participant, values); }
+    getParticipantList() { return this.getCsvClaimList(EncounterClaim.Participant); }
+    setServiceProvider(value) { return this.setScalarClaim(EncounterClaim.ServiceProvider, value); }
+    getServiceProvider() { return this.getScalarClaim(EncounterClaim.ServiceProvider); }
+    setPeriodStart(value) { return this.setScalarClaim(EncounterClaim.PeriodStart, value); }
+    getPeriodStart() { return this.getScalarClaim(EncounterClaim.PeriodStart); }
+    setPeriodEnd(value) { return this.setScalarClaim(EncounterClaim.PeriodEnd, value); }
+    getPeriodEnd() { return this.getScalarClaim(EncounterClaim.PeriodEnd); }
+    setReasonCode(value) { return this.setScalarClaim(EncounterClaim.ReasonCode, value); }
+    getReasonCode() { return this.getScalarClaim(EncounterClaim.ReasonCode); }
+}
+/** Claims-first editor for one staged Coverage entry. */
+export class CoverageEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) { return this.setIdentifierValue(CoverageClaim.Identifier, identifier); }
+    getIdentifier() { return this.getIdentifierValue(CoverageClaim.Identifier); }
+    ensureIdentifier() { return this.ensureIdentifierValue(CoverageClaim.Identifier); }
+    setStatus(value) { return this.setScalarClaim(CoverageClaim.Status, value); }
+    getStatus() { return this.getScalarClaim(CoverageClaim.Status); }
+    setType(value) { return this.setScalarClaim(CoverageClaim.Type, value); }
+    getType() { return this.getScalarClaim(CoverageClaim.Type); }
+    setPolicyHolder(value) { return this.setScalarClaim(CoverageClaim.PolicyHolder, value); }
+    getPolicyHolder() { return this.getScalarClaim(CoverageClaim.PolicyHolder); }
+    setSubscriber(value) { return this.setScalarClaim(CoverageClaim.Subscriber, value); }
+    getSubscriber() { return this.getScalarClaim(CoverageClaim.Subscriber); }
+    setBeneficiary(value) { return this.setScalarClaim(CoverageClaim.Beneficiary, value); }
+    getBeneficiary() { return this.getScalarClaim(CoverageClaim.Beneficiary); }
+    setRelationship(value) { return this.setScalarClaim(CoverageClaim.Relationship, value); }
+    getRelationship() { return this.getScalarClaim(CoverageClaim.Relationship); }
+    setPeriodStart(value) { return this.setScalarClaim(CoverageClaim.PeriodStart, value); }
+    getPeriodStart() { return this.getScalarClaim(CoverageClaim.PeriodStart); }
+    setPeriodEnd(value) { return this.setScalarClaim(CoverageClaim.PeriodEnd, value); }
+    getPeriodEnd() { return this.getScalarClaim(CoverageClaim.PeriodEnd); }
+    setPayorList(values) { return this.setCsvClaimList(CoverageClaim.Payor, values); }
+    getPayorList() { return this.getCsvClaimList(CoverageClaim.Payor); }
+}
+/** Claims-first editor for one staged Immunization entry. */
+export class ImmunizationEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) {
+        return this.setIdentifierValue(ImmunizationClaim.Identifier, identifier);
+    }
+    getIdentifier() {
+        return this.getIdentifierValue(ImmunizationClaim.Identifier);
+    }
+    ensureIdentifier() {
+        return this.ensureIdentifierValue(ImmunizationClaim.Identifier);
+    }
+    setSubject(subject) {
+        return this.setSubjectClaims(ImmunizationClaim.Subject, ImmunizationClaim.Patient, subject);
+    }
+    getSubject() {
+        return this.getSubjectClaims(ImmunizationClaim.Subject, ImmunizationClaim.Patient);
+    }
+    setStatus(status) {
+        return this.setScalarClaim(ImmunizationClaim.Status, status);
+    }
+    getStatus() {
+        return this.getScalarClaim(ImmunizationClaim.Status);
+    }
+    setDate(date) {
+        return this.setScalarClaim(ImmunizationClaim.Date, date);
+    }
+    getDate() {
+        return this.getScalarClaim(ImmunizationClaim.Date);
+    }
+    setVaccineCode(code) {
+        return this.setScalarClaim(ImmunizationClaim.VaccineCode, code);
+    }
+    getVaccineCode() {
+        return this.getScalarClaim(ImmunizationClaim.VaccineCode);
+    }
+    setVaccineCodeTextLocal(text) {
+        return this.setScalarClaim(ImmunizationClaim.VaccineCodeText, text);
+    }
+    getVaccineCodeTextLocal() {
+        return this.getScalarClaim(ImmunizationClaim.VaccineCodeText);
+    }
+    setVaccineCodeDisplay(display) {
+        return this.setScalarClaim(ImmunizationClaim.VaccineCodeDisplay, display);
+    }
+    getVaccineCodeDisplay() {
+        return this.getScalarClaim(ImmunizationClaim.VaccineCodeDisplay);
+    }
+    setLocation(reference) {
+        return this.setScalarClaim(ImmunizationClaim.Location, reference);
+    }
+    getLocation() {
+        return this.getScalarClaim(ImmunizationClaim.Location);
+    }
+    setManufacturer(reference) {
+        return this.setScalarClaim(ImmunizationClaim.Manufacturer, reference);
+    }
+    getManufacturer() {
+        return this.getScalarClaim(ImmunizationClaim.Manufacturer);
+    }
+    setLotNumber(lotNumber) {
+        return this.setScalarClaim(ImmunizationClaim.LotNumber, lotNumber);
+    }
+    getLotNumber() {
+        return this.getScalarClaim(ImmunizationClaim.LotNumber);
+    }
+    setPerformerList(references) {
+        return this.setCsvClaimList(ImmunizationClaim.Performer, references);
+    }
+    getPerformerList() {
+        return this.getCsvClaimList(ImmunizationClaim.Performer);
+    }
+    setReasonCode(code) {
+        return this.setScalarClaim(ImmunizationClaim.ReasonCode, code);
+    }
+    getReasonCode() {
+        return this.getScalarClaim(ImmunizationClaim.ReasonCode);
+    }
+    setStatusReason(reason) {
+        return this.setScalarClaim(ImmunizationClaim.StatusReason, reason);
+    }
+    getStatusReason() {
+        return this.getScalarClaim(ImmunizationClaim.StatusReason);
+    }
+    setTargetDisease(code) {
+        return this.setScalarClaim(ImmunizationClaim.TargetDisease, code);
+    }
+    getTargetDisease() {
+        return this.getScalarClaim(ImmunizationClaim.TargetDisease);
+    }
+    setDoseSequence(sequence) {
+        return this.setScalarClaim(ImmunizationClaim.DoseSequence, sequence);
+    }
+    getDoseSequence() {
+        return this.getScalarClaim(ImmunizationClaim.DoseSequence);
+    }
+    setSeries(series) {
+        return this.setScalarClaim(ImmunizationClaim.Series, series);
+    }
+    getSeries() {
+        return this.getScalarClaim(ImmunizationClaim.Series);
+    }
+    setReactionDate(date) {
+        return this.setScalarClaim(ImmunizationClaim.ReactionDate, date);
+    }
+    getReactionDate() {
+        return this.getScalarClaim(ImmunizationClaim.ReactionDate);
+    }
+    setNote(note) {
+        return this.setScalarClaim(ImmunizationClaim.Note, note);
+    }
+    getNote() {
+        return this.getScalarClaim(ImmunizationClaim.Note);
+    }
+    setClinicalNote(note) {
+        return this.setNote(note);
+    }
+    getClinicalNote() {
+        return this.getNote();
+    }
+}
+/** Claims-first editor for one staged Procedure entry. */
+export class ProcedureEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) {
+        return this.setIdentifierValue(ProcedureClaim.Identifier, identifier);
+    }
+    getIdentifier() {
+        return this.getIdentifierValue(ProcedureClaim.Identifier);
+    }
+    ensureIdentifier() {
+        return this.ensureIdentifierValue(ProcedureClaim.Identifier);
+    }
+    setSubject(subject) {
+        return this.setSubjectClaims(ProcedureClaim.Subject, ProcedureClaim.Patient, subject);
+    }
+    getSubject() {
+        return this.getSubjectClaims(ProcedureClaim.Subject, ProcedureClaim.Patient);
+    }
+    setStatus(status) {
+        return this.setScalarClaim(ProcedureClaim.Status, status);
+    }
+    getStatus() {
+        return this.getScalarClaim(ProcedureClaim.Status);
+    }
+    setDate(date) {
+        return this.setScalarClaim(ProcedureClaim.Date, date);
+    }
+    getDate() {
+        return this.getScalarClaim(ProcedureClaim.Date);
+    }
+    setCode(code) {
+        return this.setScalarClaim(ProcedureClaim.Code, code);
+    }
+    getCode() {
+        return this.getScalarClaim(ProcedureClaim.Code);
+    }
+    setCodeTextLocal(text) {
+        return this.setScalarClaim(ProcedureClaim.CodeText, text);
+    }
+    getCodeTextLocal() {
+        return this.getScalarClaim(ProcedureClaim.CodeText);
+    }
+    setCodeDisplay(display) {
+        return this.setScalarClaim(ProcedureClaim.CodeDisplay, display);
+    }
+    getCodeDisplay() {
+        return this.getScalarClaim(ProcedureClaim.CodeDisplay);
+    }
+    setEncounter(reference) {
+        return this.setScalarClaim(ProcedureClaim.Encounter, reference);
+    }
+    getEncounter() {
+        return this.getScalarClaim(ProcedureClaim.Encounter);
+    }
+    setLocation(reference) {
+        return this.setScalarClaim(ProcedureClaim.Location, reference);
+    }
+    getLocation() {
+        return this.getScalarClaim(ProcedureClaim.Location);
+    }
+    setReasonCode(code) {
+        return this.setScalarClaim(ProcedureClaim.ReasonCode, code);
+    }
+    getReasonCode() {
+        return this.getScalarClaim(ProcedureClaim.ReasonCode);
+    }
+    setNote(note) {
+        return this.setScalarClaim(ProcedureClaim.Note, note);
+    }
+    getNote() {
+        return this.getScalarClaim(ProcedureClaim.Note);
+    }
+    setClinicalNote(note) {
+        return this.setNote(note);
+    }
+    getClinicalNote() {
+        return this.getNote();
+    }
+    setPerformerList(references) {
+        return this.setCsvClaimList(ProcedureClaim.Performer, references);
+    }
+    getPerformerList() {
+        return this.getCsvClaimList(ProcedureClaim.Performer);
+    }
+    setBasedOnList(references) {
+        return this.setCsvClaimList(ProcedureClaim.BasedOn, references);
+    }
+    getBasedOnList() {
+        return this.getCsvClaimList(ProcedureClaim.BasedOn);
+    }
+    setReasonReferenceList(references) {
+        return this.setCsvClaimList(ProcedureClaim.ReasonReference, references);
+    }
+    getReasonReferenceList() {
+        return this.getCsvClaimList(ProcedureClaim.ReasonReference);
+    }
+}
+/** Claims-first editor for one staged DiagnosticReport entry. */
+export class DiagnosticReportEntryEditor extends ClinicalResourceEntryEditor {
+    setIdentifier(identifier) {
+        return this.setIdentifierValue(DiagnosticReportClaim.Identifier, identifier);
+    }
+    getIdentifier() {
+        return this.getIdentifierValue(DiagnosticReportClaim.Identifier);
+    }
+    ensureIdentifier() {
+        return this.ensureIdentifierValue(DiagnosticReportClaim.Identifier);
+    }
+    setSubject(subject) {
+        return this.setSubjectClaims(DiagnosticReportClaim.Subject, DiagnosticReportClaim.Patient, subject);
+    }
+    getSubject() {
+        return this.getSubjectClaims(DiagnosticReportClaim.Subject, DiagnosticReportClaim.Patient);
+    }
+    setStatus(status) {
+        return this.setScalarClaim(DiagnosticReportClaim.Status, status);
+    }
+    getStatus() {
+        return this.getScalarClaim(DiagnosticReportClaim.Status);
+    }
+    setDate(date) {
+        return this.setScalarClaim(DiagnosticReportClaim.Date, date);
+    }
+    getDate() {
+        return this.getScalarClaim(DiagnosticReportClaim.Date);
+    }
+    setCategory(category) {
+        return this.setScalarClaim(DiagnosticReportClaim.Category, category);
+    }
+    getCategory() {
+        return this.getScalarClaim(DiagnosticReportClaim.Category);
+    }
+    setCode(code) {
+        return this.setScalarClaim(DiagnosticReportClaim.Code, code);
+    }
+    getCode() {
+        return this.getScalarClaim(DiagnosticReportClaim.Code);
+    }
+    setEncounter(reference) {
+        return this.setScalarClaim(DiagnosticReportClaim.Encounter, reference);
+    }
+    getEncounter() {
+        return this.getScalarClaim(DiagnosticReportClaim.Encounter);
+    }
+    setPerformerList(references) {
+        return this.setCsvClaimList(DiagnosticReportClaim.Performer, references);
+    }
+    getPerformerList() {
+        return this.getCsvClaimList(DiagnosticReportClaim.Performer);
+    }
+    setResultList(references) {
+        return this.setCsvClaimList(DiagnosticReportClaim.Result, references);
+    }
+    getResultList() {
+        return this.getCsvClaimList(DiagnosticReportClaim.Result);
+    }
+    setSpecimenList(references) {
+        return this.setCsvClaimList(DiagnosticReportClaim.Specimen, references);
+    }
+    getSpecimenList() {
+        return this.getCsvClaimList(DiagnosticReportClaim.Specimen);
+    }
+    setContainedDocumentIdentifierList(identifiers) {
+        return this.setCsvClaimList(DiagnosticReportClaim.ContainedDocuments, identifiers);
+    }
+    getContainedDocumentIdentifierList() {
+        return this.getCsvClaimList(DiagnosticReportClaim.ContainedDocuments);
+    }
+    setPresentedFormContentType(contentType) {
+        return this.setScalarClaim(DiagnosticReportClaim.PresentedFormContentType, contentType);
+    }
+    getPresentedFormContentType() {
+        return this.getScalarClaim(DiagnosticReportClaim.PresentedFormContentType);
+    }
+    setPresentedFormData(data) {
+        return this.setScalarClaim(DiagnosticReportClaim.PresentedFormData, data);
+    }
+    getPresentedFormData() {
+        return this.getScalarClaim(DiagnosticReportClaim.PresentedFormData);
+    }
+    setPresentedFormUrl(url) {
+        return this.setScalarClaim(DiagnosticReportClaim.PresentedFormUrl, url);
+    }
+    getPresentedFormUrl() {
+        return this.getScalarClaim(DiagnosticReportClaim.PresentedFormUrl);
+    }
 }
 /**
  * Employee-specific editor for one staged bundle entry.