gdc-common-utils-ts 2.1.0 → 2.2.2

package/dist/utils/bundle-editor.js

@@ -1,1601 +1,21 @@
-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));
-}
-function cloneClaimValue(value) {
-    if (Array.isArray(value)) {
-        return [...value];
-    }
-    return value;
-}
-function normalizeOptionalIdentifier(value) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    const normalized = String(value).trim();
-    return normalized ? normalized : undefined;
-}
-function createCanonicalIdentifierUrn() {
-    const cryptoLike = globalThis;
-    const uuid = typeof cryptoLike.crypto?.randomUUID === 'function'
-        ? cryptoLike.crypto.randomUUID()
-        : `resource-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    return `urn:uuid:${uuid}`;
-}
-function resolveRequestMethodForOperation(operation) {
-    switch (operation) {
-        case EmployeeBundleOperations.disable:
-            return EmployeeBundleMethods.disable;
-        case EmployeeBundleOperations.search:
-        case EmployeeBundleOperations.create:
-        case EmployeeBundleOperations.purge:
-        default:
-            return EmployeeBundleMethods.create;
-    }
-}
-function resolveEntryTypeForOperation(operation) {
-    switch (operation) {
-        case EmployeeBundleOperations.disable:
-            return EmployeeBatchEntryTypes.disable;
-        case EmployeeBundleOperations.purge:
-            return EmployeeBatchEntryTypes.purge;
-        case EmployeeBundleOperations.search:
-            return EmployeeBatchEntryTypes.search;
-        case EmployeeBundleOperations.create:
-        default:
-            return EmployeeBatchEntryTypes.create;
-    }
-}
-function inferGenericEntryType(resourceType, operation) {
-    const normalizedResourceType = String(resourceType || '').trim();
-    if (normalizedResourceType === EmployeeResourceTypes.employee) {
-        return resolveEntryTypeForOperation(operation);
-    }
-    return `${normalizedResourceType}-${operation}-request-v1.0`;
-}
-/**
- * Generic bundle editor for FHIR-like bundle payloads assembled in memory.
- *
- * This class owns bundle-level concerns:
- * - which business operation the bundle represents
- * - which resource type the bundle allows
- * - which entries belong to the bundle
- * - when the final bundle is materialized through `build()`
- *
- * Resource-specific semantics belong to resource entry editors such as
- * `EmployeeEntryEditor`.
- */
-export class BundleEditor {
-    bundleOperation = null;
-    allowedResourceType = null;
-    entries = [];
-    /**
-     * Declares which business action this in-memory bundle is staging.
-     *
-     * Important distinction:
-     * - this is **not** the same concept as FHIR `Bundle.entry.request.method`
-     * - this is the higher-level action the editor is helping to assemble, for
-     *   example `create`, `search`, `disable`, or `purge`
-     * - the lower-level transport/request method may later be derived from that
-     *   action, and may differ by backend contract
-     *
-     * Example:
-     * - bundle operation `disable`
-     * - current employee GW contract -> inner `entry.request.method = DELETE`
-     * - current individual organization GW contract -> explicit `/_disable`
-     *   route with inner `entry.request.method = POST`
-     */
-    setBundleOperation(operation) {
-        this.bundleOperation = operation;
-        return this;
-    }
-    /**
-     * Returns the current high-level business action assigned to the bundle.
-     *
-     * Read this as:
-     * - "what am I trying to do?"
-     *
-     * not as:
-     * - "which HTTP/FHIR request method will the final entry use?"
-     */
-    getBundleOperation() {
-        return this.bundleOperation;
-    }
-    /**
-     * Restricts the bundle to one resource type.
-     *
-     * For employee batch bundles this should be fixed to
-     * `EmployeeResourceTypes.employee` so the editor cannot mix unrelated
-     * resource kinds.
-     */
-    setAllowedResourceType(resourceType) {
-        this.allowedResourceType = resourceType;
-        return this;
-    }
-    /** Returns the bundle resource type restriction when already declared. */
-    getAllowedResourceType() {
-        return this.allowedResourceType;
-    }
-    /**
-     * Opens one new entry and returns a generic entry editor for that slot.
-     *
-     * The entry editor can later expose resource-specific semantics through
-     * methods such as `asEmployee()`.
-     */
-    newEntry(resourceId) {
-        const operation = this.requireBundleOperation();
-        const resourceType = this.requireAllowedResourceType();
-        const entry = this.createEntryDraft(operation, resourceType, resourceId);
-        this.entries.push(entry);
-        return new BundleEntryEditor(this, this.entries.length - 1);
-    }
-    /** Reopens one existing entry by `resource.id` or `fullUrl`. */
-    openEntry(resourceIdOrFullUrl) {
-        const normalizedIdentifier = normalizeOptionalIdentifier(resourceIdOrFullUrl);
-        if (!normalizedIdentifier) {
-            throw new Error('openEntry requires a non-empty resource identifier or fullUrl.');
-        }
-        const entryIndex = this.entries.findIndex((entry) => {
-            return normalizeOptionalIdentifier(entry.resource?.id) === normalizedIdentifier
-                || normalizeOptionalIdentifier(entry.fullUrl) === normalizedIdentifier;
-        });
-        if (entryIndex < 0) {
-            throw new Error(`openEntry could not find resource identifier or fullUrl: ${normalizedIdentifier}`);
-        }
-        return new BundleEntryEditor(this, entryIndex);
-    }
-    /** Returns cloned staged entries for inspection or debugging. */
-    getEntries() {
-        return this.entries.map((entry) => cloneEntry(entry));
-    }
-    /**
-     * Materializes the final bundle payload from the editor state.
-     *
-     * `build()` does not send, sign, or wrap the payload. It only returns the
-     * final bundle object for the declared operation and staged entries.
-     */
-    build() {
-        const operation = this.requireBundleOperation();
-        const resourceType = this.requireAllowedResourceType();
-        if (operation === EmployeeBundleOperations.search) {
-            if (resourceType !== EmployeeResourceTypes.employee) {
-                throw new Error(`BundleEditor search currently supports only resource type: ${EmployeeResourceTypes.employee}`);
-            }
-            return buildEmployeeSearchBundle({
-                claims: this.getSingleSearchClaims(),
-                resourceType,
-            });
-        }
-        if (operation === EmployeeBundleOperations.purge) {
-            if (resourceType !== EmployeeResourceTypes.employee) {
-                throw new Error(`BundleEditor purge currently supports only resource type: ${EmployeeResourceTypes.employee}`);
-            }
-            return {
-                resourceType: EmployeeResourceTypes.bundle,
-                type: EmployeeResourceTypes.batch,
-                entry: this.entries.map((entry) => {
-                    const identifier = normalizeOptionalIdentifier(entry.resource?.meta?.claims?.[ClaimsPersonSchemaorg.identifier]
-                        || entry.resource?.id
-                        || entry.fullUrl);
-                    if (!identifier) {
-                        throw new Error('Every purge entry requires one canonical employee identifier.');
-                    }
-                    return buildEmployeePurgeBundle({
-                        identifier,
-                        resourceType,
-                    }).entry[0];
-                }),
-            };
-        }
-        return {
-            resourceType: ResourceTypesFhirR4.Bundle,
-            type: EmployeeResourceTypes.batch,
-            entry: this.entries.map((entry) => cloneEntry(entry)),
-        };
-    }
-    /**
-     * Materializes the staged entries as the `BundleJsonApi` shape used by
-     * `CommunicationAttachedBundleSession` and `ConsentAccessEditor`.
-     *
-     * Use this when the next layer edits bundle entries in-memory before another
-     * runtime wraps or sends the bundle.
-     */
-    buildJsonApi() {
-        return {
-            resourceType: ResourceTypesFhirR4.Bundle,
-            type: EmployeeResourceTypes.batch,
-            data: this.entries.map((entry) => {
-                const clonedEntry = cloneEntry(entry);
-                const { request: _requestIgnored, ...clonedEntryWithoutRequest } = clonedEntry;
-                const normalizedRequest = clonedEntry.request
-                    ? {
-                        method: clonedEntry.request.method,
-                        url: clonedEntry.request.url || '',
-                    }
-                    : undefined;
-                return normalizedRequest
-                    ? {
-                        ...clonedEntryWithoutRequest,
-                        request: normalizedRequest,
-                    }
-                    : clonedEntryWithoutRequest;
-            }),
-        };
-    }
-    /** @internal */
-    getMutableEntry(entryIndex) {
-        if (!Number.isInteger(entryIndex) || entryIndex < 0 || entryIndex >= this.entries.length) {
-            throw new Error(`BundleEditor could not open entry index: ${entryIndex}`);
-        }
-        return this.entries[entryIndex];
-    }
-    createEntryDraft(operation, resourceType, resourceId) {
-        const normalizedIdentifier = operation === EmployeeBundleOperations.search
-            ? normalizeOptionalIdentifier(resourceId)
-            : (normalizeOptionalIdentifier(resourceId) || createCanonicalIdentifierUrn());
-        const claims = {
-            '@context': 'org.schema',
-            ...(normalizedIdentifier ? { [ClaimsPersonSchemaorg.identifier]: normalizedIdentifier } : {}),
-        };
-        if (resourceType !== EmployeeResourceTypes.employee) {
-            return {
-                type: inferGenericEntryType(resourceType, operation),
-                request: { method: resolveRequestMethodForOperation(operation) },
-                fullUrl: normalizedIdentifier,
-                resource: {
-                    resourceType,
-                    ...(normalizedIdentifier ? { id: normalizedIdentifier } : {}),
-                    meta: { claims: {} },
-                },
-            };
-        }
-        const entry = buildEmployeeBatchEntry({
-            type: resolveEntryTypeForOperation(operation),
-            method: resolveRequestMethodForOperation(operation),
-            resourceId: normalizedIdentifier,
-            resourceType,
-            claims,
-        });
-        if (normalizedIdentifier) {
-            entry.fullUrl = normalizedIdentifier;
-        }
-        return entry;
-    }
-    getSingleSearchClaims() {
-        if (this.entries.length === 0) {
-            return {};
-        }
-        if (this.entries.length > 1) {
-            throw new Error('Search bundles currently support one entry per bundle.');
-        }
-        const claims = this.entries[0].resource?.meta?.claims || {};
-        const searchClaims = {};
-        for (const [key, value] of Object.entries(claims)) {
-            if (value === undefined
-                || value === null
-                || typeof value === 'string'
-                || typeof value === 'number'
-                || typeof value === 'boolean') {
-                searchClaims[key] = value;
-            }
-        }
-        return searchClaims;
-    }
-    requireBundleOperation() {
-        if (!this.bundleOperation) {
-            throw new Error('BundleEditor requires setBundleOperation(...) before newEntry() or build().');
-        }
-        return this.bundleOperation;
-    }
-    requireAllowedResourceType() {
-        if (!this.allowedResourceType) {
-            throw new Error('BundleEditor requires setAllowedResourceType(...) before newEntry() or build().');
-        }
-        return this.allowedResourceType;
-    }
-}
-/**
- * Generic editor for one staged bundle entry.
- *
- * This class only knows generic entry concerns such as:
- * - resource id
- * - fullUrl
- * - meta claims
- * - conversion to one resource-specific entry editor
- */
-export class BundleEntryEditor {
-    bundleEditor;
-    entryIndex;
-    constructor(bundleEditor, entryIndex) {
-        this.bundleEditor = bundleEditor;
-        this.entryIndex = entryIndex;
-    }
-    /** Opens the current entry as one employee-specific resource editor. */
-    asEmployee() {
-        const entry = this.getMutableEntry();
-        if (entry.resource?.resourceType !== EmployeeResourceTypes.employee) {
-            throw new Error(`BundleEntryEditor cannot open this entry as Employee: ${String(entry.resource?.resourceType || '')}`);
-        }
-        return new EmployeeEntryEditor(this.bundleEditor, this.entryIndex);
-    }
-    /** Opens the current entry as one vital-sign-specific Observation editor. */
-    asVitalSign() {
-        const entry = this.getMutableEntry();
-        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Observation) {
-            throw new Error(`BundleEntryEditor cannot open this entry as VitalSign: ${String(entry.resource?.resourceType || '')}`);
-        }
-        return new VitalSignEntryEditor(this.bundleEditor, this.entryIndex);
-    }
-    /** Opens the current entry as one general Observation editor. */
-    asObservation() {
-        const entry = this.getMutableEntry();
-        if (entry.resource?.resourceType !== ResourceTypesFhirR4.Observation) {
-            throw new Error(`BundleEntryEditor cannot open this entry as Observation: ${String(entry.resource?.resourceType || '')}`);
-        }
-        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()]);
-    }
-    /** Checks whether this entry contains one claim key. */
-    hasClaim(key) {
-        return Object.prototype.hasOwnProperty.call(this.getClaims(), String(key).trim());
-    }
-    /** Writes one claim on this entry. */
-    setClaim(key, value) {
-        const entry = this.getMutableEntry();
-        entry.resource = entry.resource || {
-            resourceType: this.bundleEditor.getAllowedResourceType() || EmployeeResourceTypes.employee,
-            meta: { claims: {} },
-        };
-        entry.resource.meta = entry.resource.meta || {};
-        entry.resource.meta.claims = {
-            ...(entry.resource.meta.claims || {}),
-            [String(key).trim()]: cloneClaimValue(value),
-        };
-        return this;
-    }
-    /** Appends one claim value on this entry. */
-    addClaim(key, value) {
-        const normalizedKey = String(key).trim();
-        const current = this.getClaim(normalizedKey);
-        if (current === undefined) {
-            return this.setClaim(normalizedKey, value);
-        }
-        if (Array.isArray(current)) {
-            return this.setClaim(normalizedKey, [...current, cloneClaimValue(value)]);
-        }
-        return this.setClaim(normalizedKey, [current, cloneClaimValue(value)]);
-    }
-    /** Removes one claim from this entry. */
-    removeClaim(key) {
-        const entry = this.getMutableEntry();
-        const claims = {
-            ...(entry.resource?.meta?.claims || {}),
-        };
-        delete claims[String(key).trim()];
-        entry.resource = entry.resource || {
-            resourceType: this.bundleEditor.getAllowedResourceType() || EmployeeResourceTypes.employee,
-            meta: { claims: {} },
-        };
-        entry.resource.meta = entry.resource.meta || {};
-        entry.resource.meta.claims = claims;
-        return this;
-    }
-    /** Writes the staged entry `resource.id`. */
-    setResourceId(resourceId) {
-        const entry = this.getMutableEntry();
-        const normalized = normalizeOptionalIdentifier(resourceId);
-        if (!normalized) {
-            delete entry.resource?.id;
-            return this;
-        }
-        entry.resource = entry.resource || {
-            resourceType: this.bundleEditor.getAllowedResourceType() || EmployeeResourceTypes.employee,
-            meta: { claims: {} },
-        };
-        entry.resource.id = normalized;
-        return this;
-    }
-    /** Reads the staged entry `resource.id` when present. */
-    getResourceId() {
-        return normalizeOptionalIdentifier(this.getMutableEntry().resource?.id);
-    }
-    /** Writes the staged entry `fullUrl`. */
-    setFullUrl(fullUrl) {
-        const entry = this.getMutableEntry();
-        const normalized = normalizeOptionalIdentifier(fullUrl);
-        if (!normalized) {
-            delete entry.fullUrl;
-            return this;
-        }
-        entry.fullUrl = normalized;
-        return this;
-    }
-    /** Reads the staged entry `fullUrl` when present. */
-    getFullUrl() {
-        return normalizeOptionalIdentifier(this.getMutableEntry().fullUrl);
-    }
-    /** Returns control to the parent bundle editor. */
-    doneEntry() {
-        return this.bundleEditor;
-    }
-    getMutableEntry() {
-        return this.bundleEditor.getMutableEntry(this.entryIndex);
-    }
-    getClaims() {
-        return {
-            ...(this.getMutableEntry().resource?.meta?.claims || {}),
-        };
-    }
-}
-/**
- * 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.
- *
- * This base layer owns the reusable code/value authoring helpers shared by
- * Vital Signs and broader Observation entry editors.
- */
-export class ObservationComponentEntryEditor extends BundleEntryEditor {
-    setCode(code) {
-        const token = typeof code === 'string' ? code.trim() : code.claim;
-        this.setClaim(ObservationClaim.Code, token);
-        if (typeof code !== 'string') {
-            this.setClaim(ObservationClaim.CodeSystem, code.system);
-            this.setClaim(ObservationClaim.CodeValue, code.code);
-            if (code.display) {
-                this.setClaim(ObservationClaim.CodeDisplay, code.display);
-            }
-        }
-        return this;
-    }
-    getCode() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Code));
-    }
-    setCodeSystem(system) {
-        return this.setClaim(ObservationClaim.CodeSystem, String(system).trim());
-    }
-    getCodeSystem() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeSystem));
-    }
-    setCodeValue(value) {
-        return this.setClaim(ObservationClaim.CodeValue, String(value).trim());
-    }
-    getCodeValue() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeValue));
-    }
-    setCodeDisplay(display) {
-        return this.setClaim(ObservationClaim.CodeDisplay, String(display).trim());
-    }
-    getCodeDisplay() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeDisplay));
-    }
-    /**
-     * Stores the local-language label used by forms and local UI copy.
-     *
-     * Keep this distinct from `setCodeDisplay(...)`, which is the canonical
-     * English/international display carried by the coded concept.
-     */
-    setCodeTextLocal(text) {
-        return this.setClaim(ObservationClaim.CodeText, String(text).trim());
-    }
-    /**
-     * Returns the local-language label used by forms and local UI copy.
-     *
-     * Keep this distinct from `getCodeDisplay()`, which returns the canonical
-     * English/international display when present.
-     */
-    getCodeTextLocal() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.CodeText));
-    }
-    /** Compatibility alias for older examples/tests. Prefer `setCodeTextLocal(...)`. */
-    setLocalText(text) {
-        return this.setCodeTextLocal(text);
-    }
-    /** Compatibility alias for older examples/tests. Prefer `getCodeTextLocal()`. */
-    getLocalText() {
-        return this.getCodeTextLocal();
-    }
-    setValueQuantityNumber(value) {
-        return this.setClaim(ObservationClaim.ValueQuantityNumber, String(value));
-    }
-    getValueQuantityNumber() {
-        const raw = this.getClaim(ObservationClaim.ValueQuantityNumber);
-        if (raw === undefined || raw === null || raw === '')
-            return undefined;
-        const numeric = Number(raw);
-        return Number.isFinite(numeric) ? numeric : undefined;
-    }
-    setValueQuantityUnit(unit) {
-        const normalized = typeof unit === 'string' ? unit.trim() : unit.claim;
-        return this.setClaim(ObservationClaim.ValueQuantityUnit, normalized);
-    }
-    getValueQuantityUnit() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.ValueQuantityUnit));
-    }
-    setValueString(value) {
-        return this.setClaim(ObservationClaim.ValueString, String(value).trim());
-    }
-    getValueString() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.ValueString));
-    }
-    setValueDate(value) {
-        return this.setClaim(ObservationClaim.ValueDate, String(value).trim());
-    }
-    getValueDate() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.ValueDate));
-    }
-}
-/**
- * Vital-sign-specific editor surface for one staged Observation entry.
- *
- * This layer applies the visible/searchable Vital Signs claim contract on top
- * of the reduced Observation component helpers.
- */
-export class VitalSignEntryEditor extends ObservationComponentEntryEditor {
-    setIdentifier(identifier) {
-        const normalized = normalizeOptionalIdentifier(identifier);
-        if (!normalized) {
-            this.removeClaim(ObservationClaim.Identifier);
-            this.setResourceId(undefined);
-            this.setFullUrl(undefined);
-            return this;
-        }
-        this.setClaim(ObservationClaim.Identifier, normalized);
-        this.setResourceId(normalized);
-        this.setFullUrl(normalized);
-        return this;
-    }
-    getIdentifier() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Identifier)
-            || this.getResourceId()
-            || this.getFullUrl());
-    }
-    ensureIdentifier() {
-        const existing = this.getIdentifier();
-        if (existing)
-            return existing;
-        const generated = createCanonicalIdentifierUrn();
-        this.setIdentifier(generated);
-        return generated;
-    }
-    setSubject(subject) {
-        const normalized = String(subject).trim();
-        this.setClaim(ObservationClaim.Subject, normalized);
-        this.setClaim(ObservationClaim.Patient, normalized);
-        return this;
-    }
-    getSubject() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Subject)
-            || this.getClaim(ObservationClaim.Patient));
-    }
-    setStatus(status) {
-        return this.setClaim(ObservationClaim.Status, String(status).trim());
-    }
-    getStatus() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Status));
-    }
-    setCategory(category) {
-        const normalized = typeof category === 'string' ? category.trim() : category.claim;
-        return this.setClaim(ObservationClaim.Category, normalized);
-    }
-    getCategory() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Category));
-    }
-    setDate(date) {
-        const normalized = String(date).trim();
-        this.setClaim(ObservationClaim.Date, normalized);
-        this.setClaim(ObservationClaim.EffectiveDateTime, normalized);
-        return this;
-    }
-    getDate() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Date)
-            || this.getClaim(ObservationClaim.EffectiveDateTime));
-    }
-    setNote(note) {
-        return this.setClaim(ObservationClaim.Note, String(note).trim());
-    }
-    getNote() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Note));
-    }
-    setVitalSignType(code, unit) {
-        this.setCategory(ObservationCategoryCodes.VitalSigns);
-        this.setStatus(this.getStatus() || 'final');
-        this.setCode(code);
-        this.setCodeSystem(code.system);
-        this.setCodeValue(code.code);
-        if (code.display) {
-            this.setCodeDisplay(code.display);
-            this.setCodeTextLocal(code.display);
-        }
-        if (unit) {
-            this.setValueQuantityUnit(unit);
-        }
-        return this;
-    }
-    setHeartRate(value) {
-        return this
-            .setVitalSignType(VitalSignsCodes.HeartRate, VitalSignsUnits.BeatsPerMinute)
-            .setValueQuantityNumber(value);
-    }
-    getHeartRate() {
-        return this.getCodeValue() === VitalSignsCodes.HeartRate.code
-            ? this.getValueQuantityNumber()
-            : undefined;
-    }
-    setBodyTemperature(value) {
-        return this
-            .setVitalSignType(VitalSignsCodes.BodyTemperature, VitalSignsUnits.Celsius)
-            .setValueQuantityNumber(value);
-    }
-    getBodyTemperature() {
-        return this.getCodeValue() === VitalSignsCodes.BodyTemperature.code
-            ? this.getValueQuantityNumber()
-            : undefined;
-    }
-    setSystolicBloodPressure(value) {
-        return this
-            .setVitalSignType(VitalSignsCodes.SystolicBloodPressure, VitalSignsUnits.MillimeterOfMercury)
-            .setValueQuantityNumber(value);
-    }
-    getSystolicBloodPressure() {
-        return this.getCodeValue() === VitalSignsCodes.SystolicBloodPressure.code
-            ? this.getValueQuantityNumber()
-            : undefined;
-    }
-    setDiastolicBloodPressure(value) {
-        return this
-            .setVitalSignType(VitalSignsCodes.DiastolicBloodPressure, VitalSignsUnits.MillimeterOfMercury)
-            .setValueQuantityNumber(value);
-    }
-    getDiastolicBloodPressure() {
-        return this.getCodeValue() === VitalSignsCodes.DiastolicBloodPressure.code
-            ? this.getValueQuantityNumber()
-            : undefined;
-    }
-}
-/**
- * General Observation editor surface.
- *
- * This extends the Vital Sign editor so generic Observation rows can reuse the
- * same code/date/value helpers while adding broader Observation references.
- */
-export class ObservationEntryEditor extends VitalSignEntryEditor {
-    setBasedOn(reference) {
-        return this.setClaim(ObservationClaim.BasedOn, String(reference).trim());
-    }
-    getBasedOn() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.BasedOn));
-    }
-    setEncounter(reference) {
-        return this.setClaim(ObservationClaim.Encounter, String(reference).trim());
-    }
-    getEncounter() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Encounter));
-    }
-    setPerformer(reference) {
-        return this.setClaim(ObservationClaim.Performer, String(reference).trim());
-    }
-    getPerformer() {
-        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Performer));
-    }
-    setHasMember(reference) {
-        return this.setClaim(ObservationClaim.HasMember, String(reference).trim());
-    }
-    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.
- *
- * Use this class after `bundle.newEntry().asEmployee()` or
- * `bundle.openEntry(...).asEmployee()`.
- */
-export class EmployeeEntryEditor extends BundleEntryEditor {
-    /**
-     * Writes the canonical employee identifier.
-     *
-     * The identifier is synchronized across:
-     * - `entry.fullUrl`
-     * - `resource.id`
-     * - `org.schema.Person.identifier`
-     */
-    setIdentifier(identifier) {
-        const normalized = normalizeOptionalIdentifier(identifier);
-        if (!normalized) {
-            this.removeClaim(ClaimsPersonSchemaorg.identifier);
-            this.setResourceId(undefined);
-            this.setFullUrl(undefined);
-            return this;
-        }
-        this.setClaim(ClaimsPersonSchemaorg.identifier, normalized);
-        this.setResourceId(normalized);
-        this.setFullUrl(normalized);
-        return this;
-    }
-    /** Reads the canonical employee identifier from claims, resource id, or fullUrl. */
-    getIdentifier() {
-        return normalizeOptionalIdentifier(this.getClaim(ClaimsPersonSchemaorg.identifier)
-            || this.getResourceId()
-            || this.getFullUrl());
-    }
-    /** Ensures the employee entry carries one canonical `urn:uuid:*` identifier. */
-    ensureIdentifier() {
-        const existing = this.getIdentifier();
-        if (existing) {
-            return existing;
-        }
-        const generated = createCanonicalIdentifierUrn();
-        this.setIdentifier(generated);
-        return generated;
-    }
-    /** Writes the canonical employee email claim on this entry. */
-    setEmail(email) {
-        return this.setClaim(ClaimsPersonSchemaorg.email, String(email).trim());
-    }
-    /** Reads the canonical employee email claim from this entry. */
-    getEmail() {
-        const email = this.getClaim(ClaimsPersonSchemaorg.email);
-        return typeof email === 'string' && email.trim() ? email.trim() : undefined;
-    }
-    /** Writes the canonical employee occupational role claim on this entry. */
-    setRole(role) {
-        return this.setClaim(ClaimsPersonSchemaorg.hasOccupationalRoleValue, String(role).trim());
-    }
-    /** Reads the canonical employee occupational role claim from this entry. */
-    getRole() {
-        const role = this.getClaim(ClaimsPersonSchemaorg.hasOccupationalRoleValue);
-        return typeof role === 'string' && role.trim() ? role.trim() : undefined;
-    }
-    /** Writes the canonical employee `worksFor` claim on this entry. */
-    setWorksFor(worksFor) {
-        return this.setClaim(ClaimsPersonSchemaorg.worksFor, String(worksFor).trim());
-    }
-    /** Writes the canonical employee `memberOf` claim on this entry. */
-    setMemberOf(memberOf) {
-        return this.setClaim(ClaimsPersonSchemaorg.memberOf, String(memberOf).trim());
-    }
-    /** Writes the canonical employee organization tax id claim on this entry. */
-    setMemberOfOrgTaxId(taxId) {
-        return this.setClaim(ClaimsPersonSchemaorg.memberOfOrgTaxId, String(taxId).trim());
-    }
-}
+export * from '../models/bundle-editor-types.js';
+export * from './bundle-editor-core.js';
+export * from './bundle-entry-editor.js';
+export * from './observation-component-entry-editor.js';
+export * from './vital-sign-entry-editor.js';
+export * from './observation-entry-editor.js';
+export * from './allergy-intolerance-entry-editor.js';
+export * from './condition-entry-editor.js';
+export * from './medication-statement-entry-editor.js';
+export * from './document-reference-entry-editor.js';
+export * from './care-plan-entry-editor.js';
+export * from './flag-entry-editor.js';
+export * from './clinical-impression-entry-editor.js';
+export * from './device-entry-editor.js';
+export * from './device-use-statement-entry-editor.js';
+export * from './encounter-entry-editor.js';
+export * from './coverage-entry-editor.js';
+export * from './immunization-entry-editor.js';
+export * from './procedure-entry-editor.js';
+export * from './diagnostic-report-entry-editor.js';
+export * from './employee-entry-editor.js';