gdc-common-utils-ts 2.1.0 → 2.3.0

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

@@ -0,0 +1,96 @@
+import type { BundleEditor } from './bundle-editor-core';
+import { AllowedResourceType, type BuiltBundleEntry, type ResourceTypeEntryEditor } from '../models/bundle-editor-types';
+import type { AllergyIntoleranceEntryEditor } from './allergy-intolerance-entry-editor';
+import type { CarePlanEntryEditor } from './care-plan-entry-editor';
+import type { ClinicalImpressionEntryEditor } from './clinical-impression-entry-editor';
+import type { ConditionEntryEditor } from './condition-entry-editor';
+import type { CoverageEntryEditor } from './coverage-entry-editor';
+import type { DeviceEntryEditor } from './device-entry-editor';
+import type { DeviceUseStatementEntryEditor } from './device-use-statement-entry-editor';
+import type { DiagnosticReportEntryEditor } from './diagnostic-report-entry-editor';
+import type { DocumentReferenceEntryEditor } from './document-reference-entry-editor';
+import type { EncounterEntryEditor } from './encounter-entry-editor';
+import type { EmployeeEntryEditor } from './employee-entry-editor';
+import type { FlagEntryEditor } from './flag-entry-editor';
+import type { ImmunizationEntryEditor } from './immunization-entry-editor';
+import type { MedicationStatementEntryEditor } from './medication-statement-entry-editor';
+import type { ObservationEntryEditor } from './observation-entry-editor';
+import type { ProcedureEntryEditor } from './procedure-entry-editor';
+import type { VitalSignEntryEditor } from './vital-sign-entry-editor';
+import { type EmployeeClaims } from './employee';
+export declare class BundleEntryEditor {
+    protected readonly bundleEditor: BundleEditor;
+    protected readonly entryIndex: number;
+    constructor(bundleEditor: BundleEditor, entryIndex: number);
+    /**
+     * Reopens the current slot as one typed resource editor.
+     *
+     * Use this when the caller already knows the resource type of an existing
+     * entry and wants the typed `get...` / `set...` API back.
+     */
+    asResourceType<T extends AllowedResourceType>(resourceType: T): ResourceTypeEntryEditor<T>;
+    /** Opens the current entry as one employee-specific resource editor. */
+    asEmployee(): EmployeeEntryEditor;
+    /** Opens the current entry as one vital-sign-specific Observation editor. */
+    asVitalSign(): VitalSignEntryEditor;
+    /** Opens the current entry as one general Observation editor. */
+    asObservation(): ObservationEntryEditor;
+    /** Opens the current entry as one AllergyIntolerance editor. */
+    asAllergy(): AllergyIntoleranceEntryEditor;
+    /** Opens the current entry as one Condition editor. */
+    asCondition(): ConditionEntryEditor;
+    /** Opens the current entry as one MedicationStatement editor. */
+    asMedicationStatement(): MedicationStatementEntryEditor;
+    /** Opens the current entry as one DocumentReference editor. */
+    asDocumentReference(): DocumentReferenceEntryEditor;
+    /** Opens the current entry as one CarePlan editor. */
+    asCarePlan(): CarePlanEntryEditor;
+    /** Opens the current entry as one Flag editor. */
+    asFlag(): FlagEntryEditor;
+    /** Opens the current entry as one ClinicalImpression editor. */
+    asClinicalImpression(): ClinicalImpressionEntryEditor;
+    /** Opens the current entry as one Device editor. */
+    asDevice(): DeviceEntryEditor;
+    /** Opens the current entry as one DeviceUseStatement editor. */
+    asDeviceUseStatement(): DeviceUseStatementEntryEditor;
+    /** Opens the current entry as one Encounter editor. */
+    asEncounter(): EncounterEntryEditor;
+    /** Opens the current entry as one Coverage editor. */
+    asCoverage(): CoverageEntryEditor;
+    /** Opens the current entry as one Immunization editor. */
+    asImmunization(): ImmunizationEntryEditor;
+    /** Opens the current entry as one Procedure editor. */
+    asProcedure(): ProcedureEntryEditor;
+    /** Opens the current entry as one DiagnosticReport editor. */
+    asDiagnosticReport(): DiagnosticReportEntryEditor;
+    /** Reads one claim from this entry. */
+    getClaim(key: string): unknown;
+    /** Checks whether this entry contains one claim key. */
+    hasClaim(key: string): boolean;
+    /** Writes one claim on this entry. */
+    setClaim(key: string, value: unknown): this;
+    /** Appends one claim value on this entry. */
+    addClaim(key: string, value: unknown): this;
+    /** Removes one claim from this entry. */
+    removeClaim(key: string): this;
+    /** Writes the staged entry `resource.id`. */
+    setResourceId(resourceId?: string | null): this;
+    /** Reads the staged entry `resource.id` when present. */
+    getResourceId(): string | undefined;
+    /** Writes the staged entry `fullUrl`. */
+    setFullUrl(fullUrl?: string | null): this;
+    /** Reads the staged entry `fullUrl` when present. */
+    getFullUrl(): string | undefined;
+    /** Returns control to the parent bundle editor. */
+    doneEntry(): BundleEditor;
+    /** Returns the mutable staged entry owned by this editor wrapper. */
+    protected getMutableEntry(): BuiltBundleEntry;
+    /** Returns a cloned claims view for safe read-modify-write helper code. */
+    protected getClaims(): EmployeeClaims;
+}
+/**
+ * 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.
+ */

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

@@ -0,0 +1,305 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - This file owns only the generic entry-level editor surface.
+ * - Resource-specific semantics must live in the dedicated typed entry editors.
+ */
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { BundleEditableResourceTypes, } from '../models/bundle-editor-types.js';
+import { EmployeeResourceTypes, } from './employee.js';
+import { cloneClaimValue, normalizeOptionalIdentifier } from './bundle-editor-helpers.js';
+import { createRegisteredBundleEntryEditor } from './bundle-editor-registry.js';
+export class BundleEntryEditor {
+    bundleEditor;
+    entryIndex;
+    constructor(bundleEditor, entryIndex) {
+        this.bundleEditor = bundleEditor;
+        this.entryIndex = entryIndex;
+    }
+    /**
+     * Reopens the current slot as one typed resource editor.
+     *
+     * Use this when the caller already knows the resource type of an existing
+     * entry and wants the typed `get...` / `set...` API back.
+     */
+    asResourceType(resourceType) {
+        const normalized = String(resourceType || '').trim();
+        switch (normalized) {
+            case BundleEditableResourceTypes.employee:
+                return this.asEmployee();
+            case BundleEditableResourceTypes.vitalSign:
+                return this.asVitalSign();
+            case BundleEditableResourceTypes.observation:
+                return this.asObservation();
+            case BundleEditableResourceTypes.allergyIntolerance:
+                return this.asAllergy();
+            case BundleEditableResourceTypes.condition:
+                return this.asCondition();
+            case BundleEditableResourceTypes.medicationStatement:
+                return this.asMedicationStatement();
+            case BundleEditableResourceTypes.documentReference:
+                return this.asDocumentReference();
+            case BundleEditableResourceTypes.carePlan:
+                return this.asCarePlan();
+            case BundleEditableResourceTypes.flag:
+                return this.asFlag();
+            case BundleEditableResourceTypes.clinicalImpression:
+                return this.asClinicalImpression();
+            case BundleEditableResourceTypes.device:
+                return this.asDevice();
+            case BundleEditableResourceTypes.deviceUseStatement:
+                return this.asDeviceUseStatement();
+            case BundleEditableResourceTypes.encounter:
+                return this.asEncounter();
+            case BundleEditableResourceTypes.coverage:
+                return this.asCoverage();
+            case BundleEditableResourceTypes.immunization:
+                return this.asImmunization();
+            case BundleEditableResourceTypes.procedure:
+                return this.asProcedure();
+            case BundleEditableResourceTypes.diagnosticReport:
+                return this.asDiagnosticReport();
+            default:
+                return this;
+        }
+    }
+    /** 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.employee, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.vitalSign, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.observation, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.allergyIntolerance, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.condition, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.medicationStatement, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.documentReference, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.carePlan, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.flag, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.clinicalImpression, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.device, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.deviceUseStatement, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.encounter, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.coverage, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.immunization, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.procedure, 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 createRegisteredBundleEntryEditor(BundleEditableResourceTypes.diagnosticReport, 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;
+    }
+    /** Returns the mutable staged entry owned by this editor wrapper. */
+    getMutableEntry() {
+        return this.bundleEditor.getMutableEntry(this.entryIndex);
+    }
+    /** Returns a cloned claims view for safe read-modify-write helper code. */
+    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.
+ */

package/dist/utils/bundle-query.d.ts

@@ -26,6 +26,7 @@ export declare class BundleQuery {
      * Resolves the entry URL (`fullUrl`) for a given entry/resource identifier.
      */
     getEntryUrl(entryId: string): string | undefined;
+    private getEntries;
     private resolveBundleEntryId;
     private resolveIdentifierFromClaims;
     private matchesResourceFilters;

package/dist/utils/bundle-query.js

@@ -14,7 +14,7 @@ export class BundleQuery {
      * Returns stable resource IDs from bundle entries with optional filters.
      */
     getResourceIds(filters = {}) {
-        return this.bundle.data
+        return this.getEntries()
             .filter((entry) => this.matchesResourceFilters(entry, filters))
             .map((entry, index) => this.resolveBundleEntryId(entry, index));
     }
@@ -26,7 +26,7 @@ export class BundleQuery {
         if (wanted.size === 0) {
             return [];
         }
-        return this.bundle.data
+        return this.getEntries()
             .map((entry, index) => ({
             entry,
             id: this.resolveBundleEntryId(entry, index),
@@ -42,10 +42,19 @@ export class BundleQuery {
         if (!wanted) {
             return undefined;
         }
-        const match = this.bundle.data.find((entry, index) => this.resolveBundleEntryId(entry, index) === wanted);
+        const match = this.getEntries().find((entry, index) => this.resolveBundleEntryId(entry, index) === wanted);
         const fullUrl = asTrimmedString(match?.fullUrl);
         return fullUrl || undefined;
     }
+    getEntries() {
+        if (Array.isArray(this.bundle.data)) {
+            return this.bundle.data;
+        }
+        if (Array.isArray(this.bundle.entry)) {
+            return this.bundle.entry;
+        }
+        return [];
+    }
     resolveBundleEntryId(entry, index) {
         const explicitId = asTrimmedString(entry.id);
         if (explicitId) {

package/dist/utils/bundle-reader.d.ts

@@ -1,4 +1,5 @@
 import { type IssueSeverityCode } from '../models/issue';
+import { type BundleResourceIdFilters } from './bundle-query';
 export type BundleReaderEntry = Record<string, unknown>;
 export type BundleReaderEntrySummary = Readonly<{
     index: number;
@@ -29,6 +30,17 @@ export type BundleReaderResponseAnalysis = Readonly<{
         success: BundleReaderSeverityBucket;
     }>;
 }>;
+export type BundleDocumentSectionSummary = Readonly<{
+    index: number;
+    code?: string;
+    system?: string;
+    claim?: string;
+    entryReferences: readonly string[];
+}>;
+export type BundleVisibleResourceNavigation = Readonly<{
+    entryIndexes: readonly number[];
+    resourceIds: readonly string[];
+}>;
 /**
  * Returns the canonical claims view for one bundle entry array index.
  *
@@ -66,10 +78,42 @@ export declare class BundleReader {
     getEntryIdentifierByArrayIndex(index: number): string | undefined;
     /** Returns merged claims for one entry array index. */
     getEntryClaimsByArrayIndex(index: number): Record<string, unknown>;
+    /** Returns true when the entry was imported from one parent resource `contained[]`. */
+    isContainedResourceEntryByArrayIndex(index: number): boolean;
+    /** Returns the parent resource reference for one contained resource entry. */
+    getContainedParentReferenceByArrayIndex(index: number): string | undefined;
     /** Returns merged claims for the currently opened entry. */
     getActiveEntryClaims(): Record<string, unknown>;
     /** Returns the first entry array index whose resolved identifier matches the requested value. */
     getEntryIndexByIdentifier(identifier: string): number | undefined;
+    /** Returns stable resource IDs filtered from the current bundle in memory. */
+    getResourceIds(filters?: BundleResourceIdFilters): string[];
+    /** Returns visible entry indexes after filtering out imported contained children. */
+    getVisibleEntryIndexes(filters?: BundleResourceIdFilters): number[];
+    /** Returns stable resource IDs excluding entries marked as imported `contained[]` children. */
+    getVisibleResourceIds(filters?: BundleResourceIdFilters): string[];
+    /** Returns the number of visible resources the frontend should iterate over. */
+    getVisibleResourceCount(filters?: BundleResourceIdFilters): number;
+    /** Returns one visible entry index by visible-position order. */
+    getVisibleEntryIndexByPosition(position: number, filters?: BundleResourceIdFilters): number | undefined;
+    /** Returns the next visible entry index after one raw entry index. */
+    getNextVisibleEntryIndex(currentIndex: number, filters?: BundleResourceIdFilters): number | undefined;
+    /** Returns the previous visible entry index before one raw entry index. */
+    getPreviousVisibleEntryIndex(currentIndex: number, filters?: BundleResourceIdFilters): number | undefined;
+    /** Returns bundle entries matching resource IDs produced by `getResourceIds(...)`. */
+    getEntriesByIds(resourceIds: readonly string[]): BundleReaderEntry[];
+    /** Resolves the entry URL (`fullUrl`) for a given entry/resource identifier. */
+    getEntryUrl(resourceId: string): string | undefined;
+    /** Returns the Composition-first document sections when this bundle is one document bundle. */
+    getDocumentSections(): BundleDocumentSectionSummary[];
+    /** Returns the number of Composition sections in one document bundle. */
+    getDocumentSectionCount(): number;
+    /** Returns one document section by canonical claim (`system|code`) or plain code. */
+    getDocumentSectionByCode(sectionCodeOrClaim: string): BundleDocumentSectionSummary | undefined;
+    /** Returns the number of resource references inside one document section. */
+    getDocumentSectionResourceCount(sectionCodeOrClaim: string): number;
+    /** Returns bundle resource references listed under one document section. */
+    getDocumentSectionResourceReferences(sectionCodeOrClaim: string): string[];
     /** Returns the active entry response status when present. */
     getEntryResponseStatus(): string | undefined;
     /** Returns all active entry issue severities. */
@@ -77,6 +121,8 @@ export declare class BundleReader {
     /** Returns all active entry issue diagnostics strings. */
     getIssueDiagnostics(): string[];
     /** Returns the number of bundle entries. */
+    getEntryCount(): number;
+    /** Returns the number of bundle entries. */
     getTotalOperations(): number;
     /** Returns the number of entries with one 2xx response status. */
     getTotalSuccessfulOperations(): number;
@@ -97,6 +143,8 @@ export declare class BundleReader {
     /** Returns one frontend-oriented response analysis for global bundle outcome rendering. */
     getResponseAnalysis(): BundleReaderResponseAnalysis;
     private getRequiredActiveEntry;
+    private getDocumentCompositionResource;
+    private getVisibleResourceNavigation;
     private getActiveEntryIssues;
     private getEntryIssues;
     private buildEntrySummary;