gdc-common-utils-ts 2.1.0 → 2.2.2

package/dist/utils/bundle-reader.js

@@ -1,10 +1,26 @@
 import { getHighestIssueSeverity, isIssueSeverityCode, IssueSeverity, } from '../models/issue.js';
+import { BundleQuery } from './bundle-query.js';
 function cloneEntry(value) {
     return JSON.parse(JSON.stringify(value));
 }
 function asRecord(value) {
     return value && typeof value === 'object' ? value : {};
 }
+function asNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized || undefined;
+}
+function resolveContainedFlagClaimKey(resourceType) {
+    const normalized = asNonEmptyString(resourceType);
+    return normalized ? `${normalized}.is-contained` : undefined;
+}
+function resolveContainedParentReferenceClaimKey(resourceType) {
+    const normalized = asNonEmptyString(resourceType);
+    return normalized ? `${normalized}.contained-parent-reference` : undefined;
+}
 /**
  * Returns the canonical claims view for one bundle entry array index.
  *
@@ -84,6 +100,27 @@ export class BundleReader {
     getEntryClaimsByArrayIndex(index) {
         return getClaimsInBundleEntryAt(this.bundle, index);
     }
+    /** Returns true when the entry was imported from one parent resource `contained[]`. */
+    isContainedResourceEntryByArrayIndex(index) {
+        const claims = this.getEntryClaimsByArrayIndex(index);
+        const entryRecord = asRecord(this.getEntries()[index]);
+        const resourceRecord = asRecord(entryRecord.resource);
+        const resourceType = claims['resourceType'] || resourceRecord.resourceType;
+        const claimKey = resolveContainedFlagClaimKey(resourceType);
+        return claimKey
+            ? (claims[claimKey] === true || claims[claimKey] === 'true')
+            : false;
+    }
+    /** Returns the parent resource reference for one contained resource entry. */
+    getContainedParentReferenceByArrayIndex(index) {
+        const claims = this.getEntryClaimsByArrayIndex(index);
+        const entryRecord = asRecord(this.getEntries()[index]);
+        const resourceRecord = asRecord(entryRecord.resource);
+        const resourceType = claims['resourceType'] || resourceRecord.resourceType;
+        const claimKey = resolveContainedParentReferenceClaimKey(resourceType);
+        const value = claimKey ? claims[claimKey] : undefined;
+        return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+    }
     /** Returns merged claims for the currently opened entry. */
     getActiveEntryClaims() {
         if (this.activeEntryIndex === null) {
@@ -105,6 +142,109 @@ export class BundleReader {
         }
         return undefined;
     }
+    /** Returns stable resource IDs filtered from the current bundle in memory. */
+    getResourceIds(filters = {}) {
+        const query = new BundleQuery(this.bundle);
+        return query.getResourceIds(filters);
+    }
+    /** Returns visible entry indexes after filtering out imported contained children. */
+    getVisibleEntryIndexes(filters = {}) {
+        return [...this.getVisibleResourceNavigation(filters).entryIndexes];
+    }
+    /** Returns stable resource IDs excluding entries marked as imported `contained[]` children. */
+    getVisibleResourceIds(filters = {}) {
+        return [...this.getVisibleResourceNavigation(filters).resourceIds];
+    }
+    /** Returns the number of visible resources the frontend should iterate over. */
+    getVisibleResourceCount(filters = {}) {
+        return this.getVisibleResourceIds(filters).length;
+    }
+    /** Returns one visible entry index by visible-position order. */
+    getVisibleEntryIndexByPosition(position, filters = {}) {
+        if (!Number.isInteger(position) || position < 0) {
+            return undefined;
+        }
+        return this.getVisibleEntryIndexes(filters)[position];
+    }
+    /** Returns the next visible entry index after one raw entry index. */
+    getNextVisibleEntryIndex(currentIndex, filters = {}) {
+        const visibleIndexes = this.getVisibleEntryIndexes(filters);
+        const currentVisiblePosition = visibleIndexes.findIndex((index) => index === currentIndex);
+        if (currentVisiblePosition >= 0) {
+            return visibleIndexes[currentVisiblePosition + 1];
+        }
+        return visibleIndexes.find((index) => index > currentIndex);
+    }
+    /** Returns the previous visible entry index before one raw entry index. */
+    getPreviousVisibleEntryIndex(currentIndex, filters = {}) {
+        const visibleIndexes = this.getVisibleEntryIndexes(filters);
+        const currentVisiblePosition = visibleIndexes.findIndex((index) => index === currentIndex);
+        if (currentVisiblePosition > 0) {
+            return visibleIndexes[currentVisiblePosition - 1];
+        }
+        const lowerVisibleIndexes = visibleIndexes.filter((index) => index < currentIndex);
+        return lowerVisibleIndexes[lowerVisibleIndexes.length - 1];
+    }
+    /** Returns bundle entries matching resource IDs produced by `getResourceIds(...)`. */
+    getEntriesByIds(resourceIds) {
+        const query = new BundleQuery(this.bundle);
+        return query.getResourceEntriesByIds(resourceIds);
+    }
+    /** Resolves the entry URL (`fullUrl`) for a given entry/resource identifier. */
+    getEntryUrl(resourceId) {
+        const query = new BundleQuery(this.bundle);
+        return query.getEntryUrl(resourceId);
+    }
+    /** Returns the Composition-first document sections when this bundle is one document bundle. */
+    getDocumentSections() {
+        const composition = this.getDocumentCompositionResource();
+        if (!composition) {
+            return [];
+        }
+        const sections = Array.isArray(composition.section) ? composition.section : [];
+        return sections.map((section, index) => {
+            const sectionRecord = asRecord(section);
+            const codingList = asRecord(sectionRecord.code).coding;
+            const coding = Array.isArray(codingList)
+                ? asRecord(codingList[0])
+                : {};
+            const system = asNonEmptyString(coding.system);
+            const code = asNonEmptyString(coding.code);
+            const claim = system && code ? `${system}|${code}` : code;
+            const entryReferences = Array.isArray(sectionRecord.entry)
+                ? sectionRecord.entry
+                    .map((entry) => asNonEmptyString(asRecord(entry).reference))
+                    .filter((reference) => Boolean(reference))
+                : [];
+            return {
+                index,
+                code,
+                system,
+                claim,
+                entryReferences,
+            };
+        });
+    }
+    /** Returns the number of Composition sections in one document bundle. */
+    getDocumentSectionCount() {
+        return this.getDocumentSections().length;
+    }
+    /** Returns one document section by canonical claim (`system|code`) or plain code. */
+    getDocumentSectionByCode(sectionCodeOrClaim) {
+        const normalized = normalizeOptionalString(sectionCodeOrClaim);
+        if (!normalized) {
+            return undefined;
+        }
+        return this.getDocumentSections().find((section) => section.claim === normalized || section.code === normalized);
+    }
+    /** Returns the number of resource references inside one document section. */
+    getDocumentSectionResourceCount(sectionCodeOrClaim) {
+        return this.getDocumentSectionByCode(sectionCodeOrClaim)?.entryReferences.length || 0;
+    }
+    /** Returns bundle resource references listed under one document section. */
+    getDocumentSectionResourceReferences(sectionCodeOrClaim) {
+        return [...(this.getDocumentSectionByCode(sectionCodeOrClaim)?.entryReferences || [])];
+    }
     /** Returns the active entry response status when present. */
     getEntryResponseStatus() {
         const entry = this.getRequiredActiveEntry();
@@ -125,9 +265,13 @@ export class BundleReader {
             .filter((diagnostics) => typeof diagnostics === 'string' && diagnostics.trim().length > 0);
     }
     /** Returns the number of bundle entries. */
-    getTotalOperations() {
+    getEntryCount() {
         return this.getEntries().length;
     }
+    /** Returns the number of bundle entries. */
+    getTotalOperations() {
+        return this.getEntryCount();
+    }
     /** Returns the number of entries with one 2xx response status. */
     getTotalSuccessfulOperations() {
         return this.getEntrySummaries().filter((entry) => entry.isSuccessful).length;
@@ -189,6 +333,36 @@ export class BundleReader {
         const entries = this.getEntries();
         return entries[this.activeEntryIndex];
     }
+    getDocumentCompositionResource() {
+        if (this.getBundleType() !== 'document') {
+            return null;
+        }
+        const entries = this.getEntries();
+        const compositionEntry = entries.find((entry) => {
+            const resource = asRecord(asRecord(entry).resource);
+            return asNonEmptyString(resource.resourceType) === 'Composition';
+        });
+        const compositionResource = asRecord(asRecord(compositionEntry).resource);
+        return Object.keys(compositionResource).length ? compositionResource : null;
+    }
+    getVisibleResourceNavigation(filters = {}) {
+        const visiblePairs = this.getResourceIds(filters)
+            .map((resourceId) => {
+            const entryIndex = this.getEntryIndexByIdentifier(resourceId);
+            if (entryIndex === undefined || this.isContainedResourceEntryByArrayIndex(entryIndex)) {
+                return undefined;
+            }
+            return {
+                entryIndex,
+                resourceId,
+            };
+        })
+            .filter((value) => Boolean(value));
+        return {
+            entryIndexes: visiblePairs.map((item) => item.entryIndex),
+            resourceIds: visiblePairs.map((item) => item.resourceId),
+        };
+    }
     getActiveEntryIssues() {
         const entry = this.getRequiredActiveEntry();
         return this.getEntryIssues(entry);

package/dist/utils/care-plan-entry-editor.d.ts

@@ -0,0 +1,43 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged CarePlan resource entry.
+ *
+ * Use this when a caller needs to stage one care-plan row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export declare class CarePlanEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical care-plan identifier. */
+    setIdentifier(identifier?: string | null): this;
+    /** Reads the canonical care-plan identifier. */
+    getIdentifier(): string | undefined;
+    /** Ensures the care-plan entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier(): string;
+    /** Writes the subject/patient reference. */
+    setSubject(subject?: string | null): this;
+    /** Reads the subject/patient reference. */
+    getSubject(): string | undefined;
+    /** Writes the care-plan status. */
+    setStatus(value?: string | null): this;
+    /** Reads the care-plan status. */
+    getStatus(): string | undefined;
+    /** Writes the care-plan intent. */
+    setIntent(value?: string | null): this;
+    /** Reads the care-plan intent. */
+    getIntent(): string | undefined;
+    /** Writes the care-plan category. */
+    setCategory(value?: string | null): this;
+    /** Reads the care-plan category. */
+    getCategory(): string | undefined;
+    /** Writes the linked encounter reference. */
+    setEncounter(value?: string | null): this;
+    /** Reads the linked encounter reference. */
+    getEncounter(): string | undefined;
+    /** Writes the care-plan date. */
+    setDate(value?: string | null): this;
+    /** Reads the care-plan date. */
+    getDate(): string | undefined;
+    /** Writes the note text. */
+    setNote(value?: string | null): this;
+    /** Reads the note text. */
+    getNote(): string | undefined;
+}

package/dist/utils/care-plan-entry-editor.js

@@ -0,0 +1,47 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor.js';
+import { CarePlanClaim } from '../models/interoperable-claims/care-plan-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged CarePlan resource entry.
+ *
+ * Use this when a caller needs to stage one care-plan row with claims-first
+ * accessors in a bundle authoring flow.
+ */
+export class CarePlanEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical care-plan identifier. */
+    setIdentifier(identifier) { return this.setIdentifierValue(CarePlanClaim.Identifier, identifier); }
+    /** Reads the canonical care-plan identifier. */
+    getIdentifier() { return this.getIdentifierValue(CarePlanClaim.Identifier); }
+    /** Ensures the care-plan entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier() { return this.ensureIdentifierValue(CarePlanClaim.Identifier); }
+    /** Writes the subject/patient reference. */
+    setSubject(subject) { return this.setSubjectClaims(CarePlanClaim.Subject, CarePlanClaim.Patient, subject); }
+    /** Reads the subject/patient reference. */
+    getSubject() { return this.getSubjectClaims(CarePlanClaim.Subject, CarePlanClaim.Patient); }
+    /** Writes the care-plan status. */
+    setStatus(value) { return this.setScalarClaim(CarePlanClaim.Status, value); }
+    /** Reads the care-plan status. */
+    getStatus() { return this.getScalarClaim(CarePlanClaim.Status); }
+    /** Writes the care-plan intent. */
+    setIntent(value) { return this.setScalarClaim(CarePlanClaim.Intent, value); }
+    /** Reads the care-plan intent. */
+    getIntent() { return this.getScalarClaim(CarePlanClaim.Intent); }
+    /** Writes the care-plan category. */
+    setCategory(value) { return this.setScalarClaim(CarePlanClaim.Category, value); }
+    /** Reads the care-plan category. */
+    getCategory() { return this.getScalarClaim(CarePlanClaim.Category); }
+    /** Writes the linked encounter reference. */
+    setEncounter(value) { return this.setScalarClaim(CarePlanClaim.Encounter, value); }
+    /** Reads the linked encounter reference. */
+    getEncounter() { return this.getScalarClaim(CarePlanClaim.Encounter); }
+    /** Writes the care-plan date. */
+    setDate(value) { return this.setScalarClaim(CarePlanClaim.Date, value); }
+    /** Reads the care-plan date. */
+    getDate() { return this.getScalarClaim(CarePlanClaim.Date); }
+    /** Writes the note text. */
+    setNote(value) { return this.setScalarClaim(CarePlanClaim.Note, value); }
+    /** Reads the note text. */
+    getNote() { return this.getScalarClaim(CarePlanClaim.Note); }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.carePlan, CarePlanEntryEditor);

package/dist/utils/client-assertion.d.ts

@@ -0,0 +1,38 @@
+import { type JsonWebKey } from 'node:crypto';
+export type ClientAssertionJwtAlgorithm = 'ES256' | 'ES384' | 'ES512' | 'EdDSA';
+export type BuildClientAssertionJwtInput = {
+    clientId: string;
+    audience: string;
+    issuer?: string;
+    subject?: string;
+    algorithm?: ClientAssertionJwtAlgorithm;
+    expiresIn?: string | number;
+    issuedAt?: number | Date;
+    nonce?: string;
+    additionalClaims?: Record<string, unknown>;
+    protectedHeader?: Record<string, unknown>;
+    includePublicJwkInHeader?: boolean;
+};
+/**
+ * Builds one signed client-authentication JWT suitable for SMART/OpenID token
+ * requests that use `client_assertion`.
+ *
+ * Defaults:
+ * - algorithm: `ES384`
+ * - expiration: `5m`
+ * - protected header embeds the generated public JWK
+ *
+ * The helper is intentionally Node-oriented because it relies on
+ * `generateKeyPairSync(...)`. Frontends or wallets that already manage their
+ * own keys should build the same JWT shape with their own signer and can still
+ * reuse the returned contract fields from this JSDoc.
+ */
+export declare function buildClientAssertionJwt(input: BuildClientAssertionJwtInput): Promise<string>;
+/**
+ * Builds one signed client-authentication JWT and exposes the generated public
+ * JWK for callers that also need to register or persist the verification key.
+ */
+export declare function buildClientAssertionFixture(input: BuildClientAssertionJwtInput): Promise<{
+    jwt: string;
+    publicJwk: JsonWebKey;
+}>;

package/dist/utils/client-assertion.js

@@ -0,0 +1,113 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { generateKeyPairSync } from 'node:crypto';
+import { exportJWK, SignJWT } from 'jose';
+function resolveAlgorithmDefaults(algorithm) {
+    switch (algorithm) {
+        case 'ES256':
+            return generateKeyPairSync('ec', { namedCurve: 'P-256' });
+        case 'ES384':
+            return generateKeyPairSync('ec', { namedCurve: 'P-384' });
+        case 'ES512':
+            return generateKeyPairSync('ec', { namedCurve: 'P-521' });
+        case 'EdDSA':
+            return generateKeyPairSync('ed25519');
+        default:
+            throw new Error(`Unsupported client assertion algorithm '${algorithm}'.`);
+    }
+}
+function resolveIssuedAt(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return Math.trunc(value);
+    if (value instanceof Date)
+        return Math.trunc(value.getTime() / 1000);
+    return undefined;
+}
+/**
+ * Builds one signed client-authentication JWT suitable for SMART/OpenID token
+ * requests that use `client_assertion`.
+ *
+ * Defaults:
+ * - algorithm: `ES384`
+ * - expiration: `5m`
+ * - protected header embeds the generated public JWK
+ *
+ * The helper is intentionally Node-oriented because it relies on
+ * `generateKeyPairSync(...)`. Frontends or wallets that already manage their
+ * own keys should build the same JWT shape with their own signer and can still
+ * reuse the returned contract fields from this JSDoc.
+ */
+export async function buildClientAssertionJwt(input) {
+    const clientId = String(input.clientId || '').trim();
+    const audience = String(input.audience || '').trim();
+    if (!clientId)
+        throw new Error('buildClientAssertionJwt requires clientId.');
+    if (!audience)
+        throw new Error('buildClientAssertionJwt requires audience.');
+    const algorithm = input.algorithm || 'ES384';
+    const { privateKey, publicKey } = resolveAlgorithmDefaults(algorithm);
+    const publicJwk = await exportJWK(publicKey);
+    const protectedHeader = {
+        alg: algorithm,
+        typ: 'JWT',
+        ...(input.includePublicJwkInHeader === false ? {} : { jwk: publicJwk }),
+        ...(input.protectedHeader || {}),
+    };
+    const jwt = new SignJWT({
+        ...(input.nonce ? { nonce: input.nonce } : {}),
+        ...(input.additionalClaims || {}),
+    })
+        .setProtectedHeader(protectedHeader)
+        .setIssuer(String(input.issuer || clientId).trim())
+        .setSubject(String(input.subject || clientId).trim())
+        .setAudience(audience);
+    const issuedAt = resolveIssuedAt(input.issuedAt);
+    if (typeof issuedAt === 'number') {
+        jwt.setIssuedAt(issuedAt);
+    }
+    else {
+        jwt.setIssuedAt();
+    }
+    return jwt
+        .setExpirationTime(input.expiresIn ?? '5m')
+        .sign(privateKey);
+}
+/**
+ * Builds one signed client-authentication JWT and exposes the generated public
+ * JWK for callers that also need to register or persist the verification key.
+ */
+export async function buildClientAssertionFixture(input) {
+    const algorithm = input.algorithm || 'ES384';
+    const { privateKey, publicKey } = resolveAlgorithmDefaults(algorithm);
+    const publicJwk = await exportJWK(publicKey);
+    const protectedHeader = {
+        alg: algorithm,
+        typ: 'JWT',
+        ...(input.includePublicJwkInHeader === false ? {} : { jwk: publicJwk }),
+        ...(input.protectedHeader || {}),
+    };
+    const clientId = String(input.clientId || '').trim();
+    const audience = String(input.audience || '').trim();
+    if (!clientId)
+        throw new Error('buildClientAssertionFixture requires clientId.');
+    if (!audience)
+        throw new Error('buildClientAssertionFixture requires audience.');
+    const jwt = new SignJWT({
+        ...(input.nonce ? { nonce: input.nonce } : {}),
+        ...(input.additionalClaims || {}),
+    })
+        .setProtectedHeader(protectedHeader)
+        .setIssuer(String(input.issuer || clientId).trim())
+        .setSubject(String(input.subject || clientId).trim())
+        .setAudience(audience);
+    const issuedAt = resolveIssuedAt(input.issuedAt);
+    if (typeof issuedAt === 'number') {
+        jwt.setIssuedAt(issuedAt);
+    }
+    else {
+        jwt.setIssuedAt();
+    }
+    return {
+        jwt: await jwt.setExpirationTime(input.expiresIn ?? '5m').sign(privateKey),
+        publicJwk,
+    };
+}

package/dist/utils/clinical-impression-entry-editor.d.ts

@@ -0,0 +1,43 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor';
+/**
+ * Typed editor for one staged ClinicalImpression resource entry.
+ *
+ * Use this when a caller needs to stage one clinical-impression row with
+ * claims-first accessors in a bundle authoring flow.
+ */
+export declare class ClinicalImpressionEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical clinical-impression identifier. */
+    setIdentifier(identifier?: string | null): this;
+    /** Reads the canonical clinical-impression identifier. */
+    getIdentifier(): string | undefined;
+    /** Ensures the entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier(): string;
+    /** Writes the subject/patient reference. */
+    setSubject(subject?: string | null): this;
+    /** Reads the subject/patient reference. */
+    getSubject(): string | undefined;
+    /** Writes the status. */
+    setStatus(value?: string | null): this;
+    /** Reads the status. */
+    getStatus(): string | undefined;
+    /** Writes the description. */
+    setDescription(value?: string | null): this;
+    /** Reads the description. */
+    getDescription(): string | undefined;
+    /** Writes the linked encounter reference. */
+    setEncounter(value?: string | null): this;
+    /** Reads the linked encounter reference. */
+    getEncounter(): string | undefined;
+    /** Writes the effective date/time. */
+    setEffectiveDateTime(value?: string | null): this;
+    /** Reads the effective date/time. */
+    getEffectiveDateTime(): string | undefined;
+    /** Writes the assessor reference. */
+    setAssessor(value?: string | null): this;
+    /** Reads the assessor reference. */
+    getAssessor(): string | undefined;
+    /** Writes the summary text. */
+    setSummary(value?: string | null): this;
+    /** Reads the summary text. */
+    getSummary(): string | undefined;
+}

package/dist/utils/clinical-impression-entry-editor.js

@@ -0,0 +1,47 @@
+import { ClinicalResourceEntryEditor } from './clinical-resource-entry-editor.js';
+import { ClinicalImpressionClaim } from '../models/interoperable-claims/clinical-impression-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged ClinicalImpression resource entry.
+ *
+ * Use this when a caller needs to stage one clinical-impression row with
+ * claims-first accessors in a bundle authoring flow.
+ */
+export class ClinicalImpressionEntryEditor extends ClinicalResourceEntryEditor {
+    /** Writes the canonical clinical-impression identifier. */
+    setIdentifier(identifier) { return this.setIdentifierValue(ClinicalImpressionClaim.Identifier, identifier); }
+    /** Reads the canonical clinical-impression identifier. */
+    getIdentifier() { return this.getIdentifierValue(ClinicalImpressionClaim.Identifier); }
+    /** Ensures the entry has one canonical `urn:uuid:*` identifier. */
+    ensureIdentifier() { return this.ensureIdentifierValue(ClinicalImpressionClaim.Identifier); }
+    /** Writes the subject/patient reference. */
+    setSubject(subject) { return this.setSubjectClaims(ClinicalImpressionClaim.Subject, ClinicalImpressionClaim.Subject, subject); }
+    /** Reads the subject/patient reference. */
+    getSubject() { return this.getSubjectClaims(ClinicalImpressionClaim.Subject, ClinicalImpressionClaim.Subject); }
+    /** Writes the status. */
+    setStatus(value) { return this.setScalarClaim(ClinicalImpressionClaim.Status, value); }
+    /** Reads the status. */
+    getStatus() { return this.getScalarClaim(ClinicalImpressionClaim.Status); }
+    /** Writes the description. */
+    setDescription(value) { return this.setScalarClaim(ClinicalImpressionClaim.Description, value); }
+    /** Reads the description. */
+    getDescription() { return this.getScalarClaim(ClinicalImpressionClaim.Description); }
+    /** Writes the linked encounter reference. */
+    setEncounter(value) { return this.setScalarClaim(ClinicalImpressionClaim.Encounter, value); }
+    /** Reads the linked encounter reference. */
+    getEncounter() { return this.getScalarClaim(ClinicalImpressionClaim.Encounter); }
+    /** Writes the effective date/time. */
+    setEffectiveDateTime(value) { return this.setScalarClaim(ClinicalImpressionClaim.EffectiveDateTime, value); }
+    /** Reads the effective date/time. */
+    getEffectiveDateTime() { return this.getScalarClaim(ClinicalImpressionClaim.EffectiveDateTime); }
+    /** Writes the assessor reference. */
+    setAssessor(value) { return this.setScalarClaim(ClinicalImpressionClaim.Assessor, value); }
+    /** Reads the assessor reference. */
+    getAssessor() { return this.getScalarClaim(ClinicalImpressionClaim.Assessor); }
+    /** Writes the summary text. */
+    setSummary(value) { return this.setScalarClaim(ClinicalImpressionClaim.Summary, value); }
+    /** Reads the summary text. */
+    getSummary() { return this.getScalarClaim(ClinicalImpressionClaim.Summary); }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.clinicalImpression, ClinicalImpressionEntryEditor);