fhir-data-utils-ts 0.2.4 → 0.3.1

package/dist/group-r5.js

@@ -0,0 +1,301 @@
+/**
+ * Browser-safe FHIR R5 Group contract for research-team descriptions.
+ *
+ * Group membership is descriptive. It never grants authorization, permission
+ * or a SMART scope; those decisions remain separate Consent and credential
+ * contracts.
+ *
+ * @see https://hl7.org/fhir/R5/group.html
+ * @see https://hl7.org/fhir/R5/group-search.html
+ */
+export const GroupR5Version = '5.0.0';
+export const GroupR5TypeSystem = 'http://hl7.org/fhir/group-type';
+export const GroupR5TypeCodes = Object.freeze([
+    'person',
+    'animal',
+    'practitioner',
+    'device',
+    'careteam',
+    'healthcareservice',
+    'location',
+    'organization',
+    'relatedperson',
+    'specimen',
+]);
+export const GroupR5MembershipSystem = 'http://hl7.org/fhir/group-membership-basis';
+export const GroupR5MembershipCodes = Object.freeze(['definitional', 'enumerated']);
+export const GroupR5Bindings = Object.freeze({
+    type: Object.freeze({
+        valueSet: 'http://hl7.org/fhir/ValueSet/group-type',
+        strength: 'required',
+    }),
+    membership: Object.freeze({
+        valueSet: 'http://hl7.org/fhir/ValueSet/group-membership-basis',
+        strength: 'required',
+    }),
+});
+const searchParameter = (code, type, expression, components = []) => Object.freeze({
+    code,
+    type,
+    expression,
+    components: Object.freeze([...components]),
+});
+/** Exact resource-specific SearchParameters published by FHIR R5 5.0.0. */
+export const GroupR5SearchParameterCatalog = Object.freeze([
+    searchParameter('characteristic', 'token', 'Group.characteristic.code'),
+    searchParameter('characteristic-reference', 'reference', '(Group.characteristic.value.ofType(Reference))'),
+    searchParameter('characteristic-value', 'composite', 'Group.characteristic', [
+        'http://hl7.org/fhir/SearchParameter/Group-characteristic',
+        'http://hl7.org/fhir/SearchParameter/Group-value',
+    ]),
+    searchParameter('code', 'token', 'Group.code'),
+    searchParameter('exclude', 'token', 'Group.characteristic.exclude'),
+    searchParameter('identifier', 'token', 'Group.identifier'),
+    searchParameter('managing-entity', 'reference', 'Group.managingEntity'),
+    searchParameter('member', 'reference', 'Group.member.entity'),
+    searchParameter('membership', 'token', 'Group.membership'),
+    searchParameter('name', 'string', 'Group.name'),
+    searchParameter('type', 'token', 'Group.type'),
+    searchParameter('value', 'token', '(Group.characteristic.value.ofType(CodeableConcept)) | (Group.characteristic.value.ofType(boolean))'),
+]);
+/** Canonical Group flat-claim names. Never repeat these storage keys as literals. */
+export const GroupClaim = Object.freeze({
+    Characteristic: 'Group.characteristic',
+    CharacteristicReference: 'Group.characteristic-reference',
+    CharacteristicValue: 'Group.characteristic-value',
+    Code: 'Group.code',
+    Exclude: 'Group.exclude',
+    Identifier: 'Group.identifier',
+    ManagingEntity: 'Group.managing-entity',
+    Member: 'Group.member',
+    Membership: 'Group.membership',
+    Name: 'Group.name',
+    Type: 'Group.type',
+    Value: 'Group.value',
+});
+const standardSearchClaims = Object.freeze(Object.values(GroupClaim));
+/** Canonical claims derived only from the official resource-specific catalogue. */
+export const GroupFlatClaimCatalog = Object.freeze({
+    standardSearch: standardSearchClaims,
+    all: standardSearchClaims,
+});
+/**
+ * Normalizes the members used by an enumerated professional research team.
+ * Every entity is a native PractitionerRole reference; a Practitioner or an
+ * employee identifier cannot substitute for the registered role assignment.
+ */
+export function normalizeGroupPractitionerRoleMembers(input) {
+    if (!Array.isArray(input))
+        throw new TypeError('group_members_invalid');
+    return Object.freeze(input.map((value, index) => {
+        if (!isRecord(value) || containsAuthorizationProperty(value)) {
+            throw new TypeError(containsAuthorizationProperty(value) ? 'group_authorization_property_forbidden' : `group_member_${index}_invalid`);
+        }
+        if (!isRecord(value.entity))
+            throw new TypeError(`group_member_${index}_practitioner_role_reference_invalid`);
+        const reference = optionalString(value.entity.reference);
+        const declaredType = optionalString(value.entity.type);
+        if (!reference || !/^PractitionerRole\/[A-Za-z0-9.-]{1,64}$/.test(reference) || (declaredType && declaredType !== 'PractitionerRole')) {
+            throw new TypeError(`group_member_${index}_practitioner_role_reference_invalid`);
+        }
+        const display = optionalString(value.entity.display);
+        const period = value.period === undefined ? undefined : normalizePeriod(value.period, index);
+        if (value.inactive !== undefined && typeof value.inactive !== 'boolean') {
+            throw new TypeError(`group_member_${index}_inactive_invalid`);
+        }
+        return Object.freeze({
+            entity: Object.freeze({
+                reference: reference,
+                type: 'PractitionerRole',
+                ...(display ? { display } : {}),
+            }),
+            ...(period ? { period } : {}),
+            ...(value.inactive !== undefined ? { inactive: value.inactive } : {}),
+        });
+    }));
+}
+/**
+ * Normalizes the Group profile used to describe an explicit professional
+ * ResearchStudy team. This data is descriptive and authorization-shaped
+ * properties are rejected at every depth.
+ */
+export function normalizeGroupR5ResearchTeam(input) {
+    if (!isRecord(input) || input.resourceType !== 'Group')
+        throw new TypeError('group_resource_invalid');
+    if (containsAuthorizationProperty(input))
+        throw new TypeError('group_authorization_property_forbidden');
+    if (input.type !== 'practitioner')
+        throw new TypeError('group_research_team_type_invalid');
+    if (input.membership !== 'enumerated')
+        throw new TypeError('group_research_team_membership_invalid');
+    const member = normalizeGroupPractitionerRoleMembers(input.member);
+    return Object.freeze({ ...input, type: 'practitioner', membership: 'enumerated', member });
+}
+/**
+ * Projects all populated official resource-specific R5 Group SearchParameters
+ * into flat `resource.meta.claims`. A referenced characteristic is indexed by
+ * `characteristic-reference`, not as the token-valued `value` parameter.
+ *
+ * @see https://hl7.org/fhir/R5/group-search.html
+ */
+export function projectGroupR5SearchClaims(input) {
+    if (!isRecord(input) || input.resourceType !== 'Group')
+        throw new TypeError('group_resource_invalid');
+    if (containsAuthorizationProperty(input))
+        throw new TypeError('group_authorization_property_forbidden');
+    if (!GroupR5TypeCodes.includes(input.type))
+        throw new TypeError('group_type_invalid');
+    if (!GroupR5MembershipCodes.includes(input.membership)) {
+        throw new TypeError('group_membership_invalid');
+    }
+    const characteristics = normalizeRecords(input.characteristic, 'group_characteristic_invalid');
+    const characteristicCodes = characteristics.flatMap(item => conceptTokens(item.code));
+    const characteristicValues = characteristics.flatMap(characteristicTokenValues);
+    const claims = {};
+    addClaim(claims, GroupClaim.Characteristic, characteristicCodes);
+    addClaim(claims, GroupClaim.CharacteristicReference, characteristics.flatMap(item => referenceTokens(item.valueReference)));
+    addClaim(claims, GroupClaim.CharacteristicValue, characteristics.flatMap(item => conceptTokens(item.code).flatMap(code => characteristicTokenValues(item).map(value => `${code}$${value}`))));
+    addClaim(claims, GroupClaim.Code, conceptTokens(input.code));
+    addClaim(claims, GroupClaim.Exclude, characteristics.flatMap(item => typeof item.exclude === 'boolean' ? [String(item.exclude)] : []));
+    addClaim(claims, GroupClaim.Identifier, identifierTokens(input.identifier));
+    addClaim(claims, GroupClaim.ManagingEntity, referenceTokens(input.managingEntity));
+    addClaim(claims, GroupClaim.Member, normalizeRecords(input.member, 'group_members_invalid').flatMap(item => referenceTokens(item.entity)));
+    addClaim(claims, GroupClaim.Membership, [input.membership]);
+    addClaim(claims, GroupClaim.Name, strings(input.name));
+    addClaim(claims, GroupClaim.Type, [input.type]);
+    addClaim(claims, GroupClaim.Value, characteristicValues);
+    return Object.freeze(claims);
+}
+/** Projects native-shaped Group input to the claims-only GW persistence shape. */
+export function projectGroupR5FlatClaimsResource(input) {
+    if (!isRecord(input) || input.resourceType !== 'Group')
+        throw new TypeError('group_resource_invalid');
+    const id = fhirId(input.id, 'group_flat_resource_invalid');
+    if (Array.isArray(input.member) && input.member.length > 0)
+        throw new TypeError('group_members_require_separate_resources');
+    return normalizeGroupR5FlatClaimsResource({
+        resourceType: 'Group',
+        id,
+        meta: { claims: projectGroupR5SearchClaims(input) },
+    });
+}
+/** Projects one correlated claims-only GW resource per PractitionerRole member. */
+export function projectGroupPractitionerRoleMemberFlatClaimResources(input) {
+    const id = fhirId(input.groupId, 'group_flat_resource_invalid');
+    const members = normalizeGroupPractitionerRoleMembers(input.members);
+    return Object.freeze(members.map(member => normalizeGroupR5FlatClaimsResource({
+        resourceType: 'Group',
+        id,
+        meta: {
+            claims: projectGroupR5SearchClaims({
+                resourceType: 'Group',
+                id,
+                type: 'practitioner',
+                membership: 'enumerated',
+                member: [member],
+            }),
+        },
+    })));
+}
+/** Validates and freezes a claims-only Group GW resource. */
+export function normalizeGroupR5FlatClaimsResource(input) {
+    if (!isRecord(input)
+        || input.resourceType !== 'Group'
+        || Object.keys(input).some(key => !['resourceType', 'id', 'meta'].includes(key))) {
+        throw new TypeError('group_flat_resource_invalid');
+    }
+    const id = fhirId(input.id, 'group_flat_resource_invalid');
+    if (!isRecord(input.meta) || !isRecord(input.meta.claims))
+        throw new TypeError('group_flat_resource_invalid');
+    const claims = {};
+    for (const [name, rawValues] of Object.entries(input.meta.claims)) {
+        if (!GroupFlatClaimCatalog.all.includes(name)
+            || !Array.isArray(rawValues)
+            || rawValues.length === 0
+            || rawValues.some(value => typeof value !== 'string' || !value.trim())) {
+            throw new TypeError('group_flat_claim_invalid');
+        }
+        claims[name] = Object.freeze(rawValues.map(value => value.trim()));
+    }
+    return Object.freeze({ resourceType: 'Group', id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
+}
+function addClaim(claims, name, values) {
+    const normalized = [...new Set(values.flatMap(value => strings(value)))];
+    if (normalized.length > 0)
+        claims[name] = Object.freeze(normalized);
+}
+function identifierTokens(value) {
+    return normalizeRecords(value, 'group_identifier_invalid').flatMap(identifier => {
+        const system = optionalString(identifier.system);
+        const identifierValue = optionalString(identifier.value);
+        return identifierValue ? [`${system ? `${system}|` : ''}${identifierValue}`] : [];
+    });
+}
+function conceptTokens(value) {
+    if (!isRecord(value))
+        return [];
+    const coding = normalizeRecords(value.coding, 'group_coding_invalid').flatMap(item => {
+        const system = optionalString(item.system);
+        const code = optionalString(item.code);
+        return code ? [`${system ? `${system}|` : ''}${code}`] : [];
+    });
+    return coding.length > 0 ? coding : strings(value.text);
+}
+function characteristicTokenValues(value) {
+    if (typeof value.valueBoolean === 'boolean')
+        return [String(value.valueBoolean)];
+    return conceptTokens(value.valueCodeableConcept);
+}
+function referenceTokens(value) {
+    return isRecord(value) ? strings(value.reference) : [];
+}
+function normalizeRecords(value, error) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || !value.every(isRecord))
+        throw new TypeError(error);
+    return value;
+}
+function normalizePeriod(value, index) {
+    if (!isRecord(value))
+        throw new TypeError(`group_member_${index}_period_invalid`);
+    const start = optionalString(value.start);
+    const end = optionalString(value.end);
+    if (!start && !end)
+        throw new TypeError(`group_member_${index}_period_invalid`);
+    if ((start && !isFhirDateTime(start)) || (end && !isFhirDateTime(end))) {
+        throw new TypeError(`group_member_${index}_period_invalid`);
+    }
+    if (start && end && Date.parse(end) < Date.parse(start))
+        throw new TypeError(`group_member_${index}_period_invalid`);
+    return Object.freeze({ ...(start ? { start } : {}), ...(end ? { end } : {}) });
+}
+function containsAuthorizationProperty(value, seen = new WeakSet()) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (seen.has(value))
+        return false;
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.some(item => containsAuthorizationProperty(item, seen));
+    return Object.entries(value).some(([name, nested]) => ['authorization', 'permission', 'scope'].includes(name) || containsAuthorizationProperty(nested, seen));
+}
+function strings(value) {
+    const normalized = optionalString(value);
+    return normalized ? [normalized] : [];
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function isFhirDateTime(value) {
+    return /^\d{4}(?:-(?:0[1-9]|1[0-2])(?:-(?:0[1-9]|[12]\d|3[01])(?:T.+)?)?)?$/.test(value);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function fhirId(value, error) {
+    const id = optionalString(value);
+    if (!id || !/^[A-Za-z0-9.-]{1,64}$/.test(id))
+        throw new TypeError(error);
+    return id;
+}

package/dist/imaging-types.d.ts

@@ -0,0 +1,30 @@
+/** Type-only DICOMDIR tree contract recovered from the retired UHC package. */
+export interface DicomDirectoryNode {
+    id: string;
+    uid: string;
+    key: string;
+    expanded?: boolean;
+}
+export interface DicomDirectoryPatient extends DicomDirectoryNode {
+    value: string;
+    children?: DicomDirectoryStudy[];
+}
+export interface DicomDirectoryStudy extends DicomDirectoryNode {
+    description: string;
+    numberOfSeries?: number;
+    numberOfInstances?: number;
+    value: string;
+    children?: DicomDirectorySeries[];
+}
+export interface DicomDirectorySeries extends DicomDirectoryNode {
+    description: string;
+    number: number;
+    value: string;
+    children?: DicomDirectoryInstance[];
+}
+export interface DicomDirectoryInstance extends DicomDirectoryNode {
+    number: number;
+    path: string;
+    sopClassUID: string;
+    value: string;
+}

package/dist/imaging-types.js

@@ -0,0 +1 @@
+export {};

package/dist/immunization-flat-claims.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `fhir-data-utils-ts/builders/immunization`. */
+export * from './builders/immunization-graph.js';

package/dist/immunization-flat-claims.js

@@ -0,0 +1,2 @@
+/** @deprecated Import from `fhir-data-utils-ts/builders/immunization`. */
+export * from './builders/immunization-graph.js';

package/dist/immunization-reminder-plan.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `fhir-data-utils-ts/builders/immunization`. */
+export * from './builders/immunization-reminders.js';

package/dist/immunization-reminder-plan.js

@@ -0,0 +1,2 @@
+/** @deprecated Import from `fhir-data-utils-ts/builders/immunization`. */
+export * from './builders/immunization-reminders.js';

package/dist/index.d.ts

@@ -3,3 +3,22 @@ export * from './coding-review-flat-claims.js';
 export * from './search-parameters.js';
 export * from './observation-claims.js';
 export * from './vital-sign-observations.js';
+export * from './claims/index.js';
+export * from './claim-helpers/index.js';
+export * from './converters/index.js';
+export * from './fhir-types.js';
+export * from './fhir-values.js';
+export * from './fhir-search-parameters.js';
+export * from './search-models/index.js';
+export * from './fhir-bundle.js';
+export * from './terminology-models/index.js';
+export * from './constants/index.js';
+export * from './clinical-terminology.js';
+export * from './immunization-flat-claims.js';
+export * from './immunization-reminder-plan.js';
+export * from './builders/index.js';
+export * from './group-r5.js';
+export * from './research-study-r5.js';
+export * from './fhir-tokens.js';
+export * from './related-person.js';
+export * from './imaging-types.js';

package/dist/index.js

@@ -3,3 +3,22 @@ export * from './coding-review-flat-claims.js';
 export * from './search-parameters.js';
 export * from './observation-claims.js';
 export * from './vital-sign-observations.js';
+export * from './claims/index.js';
+export * from './claim-helpers/index.js';
+export * from './converters/index.js';
+export * from './fhir-types.js';
+export * from './fhir-values.js';
+export * from './fhir-search-parameters.js';
+export * from './search-models/index.js';
+export * from './fhir-bundle.js';
+export * from './terminology-models/index.js';
+export * from './constants/index.js';
+export * from './clinical-terminology.js';
+export * from './immunization-flat-claims.js';
+export * from './immunization-reminder-plan.js';
+export * from './builders/index.js';
+export * from './group-r5.js';
+export * from './research-study-r5.js';
+export * from './fhir-tokens.js';
+export * from './related-person.js';
+export * from './imaging-types.js';

package/dist/observation-claims.d.ts

@@ -1,3 +1,4 @@
+import type { ClaimSpec } from './claims/claim-types.js';
 /** Canonical code-system URIs used by neutral Observation contracts. */
 export declare const FhirCodeSystem: Readonly<{
     readonly Loinc: "http://loinc.org";
@@ -121,6 +122,8 @@ export declare const ObservationClaim: Readonly<{
     readonly ValueString: "Observation.value-string";
     readonly Note: "Observation.note";
     readonly EffectiveDateTime: "Observation.effective-datetime";
+    /** @deprecated Read-only camelCase key from historical persisted rows. */
+    readonly EffectiveDateTimeLegacy: "Observation.effectiveDateTime";
     /** Custom provenance flag for an explicitly entered or selected result. */
     readonly UserSelected: "Observation.user-selected";
 }>;
@@ -130,3 +133,170 @@ export type ObservationClaimKey = typeof ObservationClaim[keyof typeof Observati
  * Compatibility input is normalized in memory and never emitted again.
  */
 export declare function decodeObservationClaimList(value: string | undefined): readonly unknown[];
+export type SplitCodingClaims = Readonly<{
+    system?: string;
+    value?: string;
+    text?: string;
+    display?: string;
+}>;
+/**
+ * Builds the legacy compact `system|code` token from split claims.
+ *
+ * Use this only for compatibility/export. Frontend authoring should prefer the
+ * split fields such as `code-value`, `code-text`, and `value-concept-value`.
+ */
+export declare function buildObservationCodingClaim(input: SplitCodingClaims): string | undefined;
+/**
+ * Splits a compact token such as `http://loinc.org|8867-4` into separate
+ * claims that are easier for forms, local storage, and numeric/text filters.
+ */
+export declare function splitObservationCodingClaim(value: unknown): SplitCodingClaims;
+/**
+ * Reduced claim surface that mirrors FHIR `Observation.component`.
+ *
+ * By design this shape does not include `status`, `subject`, or other
+ * top-level Observation context fields from FHIR. When a component needs to be
+ * persisted/indexed locally, the transformer may add only the minimum
+ * operational fields (`identifier`, `subject`) in a separate indexed shape.
+ */
+export interface ClaimsObservationComponent {
+    /** Code system URL. Example: `http://loinc.org`. The SDK can derive the compact token from this and `code-value`. */
+    [ObservationClaim.CodeSystem]?: string;
+    /** Code value. Example: `8480-6`. This is the main code field for UI authoring and search. */
+    [ObservationClaim.CodeValue]?: string;
+    /** Local-language human label used by forms. Example: `Presión arterial sistólica`. */
+    [ObservationClaim.CodeText]?: string;
+    /** Canonical English/international display. Example: `Systolic blood pressure`. */
+    [ObservationClaim.CodeDisplay]?: string;
+    /** Component/observation code as `system|code`. Example: `http://loinc.org|8480-6`. */
+    [ObservationClaim.Code]?: string;
+    /** Value concept system URL. Example: `http://terminology.hl7.org/CodeSystem/data-absent-reason`. */
+    [ObservationClaim.ValueConceptSystem]?: string;
+    /** Value concept code value. Example: `not-performed`. */
+    [ObservationClaim.ValueConceptValue]?: string;
+    /** Local-language label for the value concept. Example: `No realizado`. */
+    [ObservationClaim.ValueConceptText]?: string;
+    /** Canonical English/international display for the value concept. Example: `Not performed`. */
+    [ObservationClaim.ValueConceptDisplay]?: string;
+    /** Value as coded concept token. Example: `http://terminology.hl7.org/CodeSystem/data-absent-reason|not-performed`. */
+    [ObservationClaim.ValueConcept]?: string;
+    /** Value when the observation result itself is one date/dateTime. Example: `2026-06-01T10:00:00Z`. */
+    [ObservationClaim.ValueDate]?: string;
+    /** Free-text value when the result is narrative rather than coded/quantified. Example: `Former smoker`. */
+    [ObservationClaim.ValueString]?: string;
+    /** Optional FHIR Quantity comparator. Allowed values: `<`, `<=`, `>=`, `>`. Example: `>=`. */
+    [ObservationClaim.ValueQuantityComparator]?: string;
+    /** Numeric scalar of the observed value. Example heart rate: `72`. Example temperature: `38.4`. */
+    [ObservationClaim.ValueQuantityNumber]?: string | number;
+    /** Human-readable quantity unit. Example: `/min`, `mmHg`, `Cel`. */
+    [ObservationClaim.ValueQuantityUnit]?: string;
+}
+/**
+ * Reduced component claims after local indexing adds only the minimal locator
+ * information required by vault persistence and parent/child traversal.
+ */
+export interface ClaimsObservationComponentIndexed extends ClaimsObservationComponent {
+    /** Synthetic/local identifier added during indexing of a reduced imported component. Example: `bp-systolic-1`. */
+    [ObservationClaim.Identifier]: string;
+    /** Subject inherited from the parent observation so the reduced row can be indexed and located locally. */
+    [ObservationClaim.Subject]: string;
+    /** Optional compatibility alias of `Observation.subject`. */
+    [ObservationClaim.Patient]?: string;
+}
+/**
+ * Minimal visible Vital Signs Observation claims.
+ *
+ * This is the practical authoring/search surface for local-first individual
+ * apps. A row without `Observation.status` is not considered a visible vital
+ * sign result and should be ignored by normal section list/search operations.
+ */
+export interface ClaimsObservationVitalSigns extends ClaimsObservationComponentIndexed {
+    /** Required for visible/searchable vital signs. If missing, treat the row as internal/supporting only. Example: `final`. */
+    [ObservationClaim.Status]: string;
+    /** Must contain the vital-signs category token for visible Vital Signs rows. */
+    [ObservationClaim.Category]: string;
+    /** Vital Sign LOINC code. Example heart rate: `http://loinc.org|8867-4`. */
+    [ObservationClaim.Code]: string;
+    /** Clinical time of the observation when represented as one scalar date/dateTime. */
+    [ObservationClaim.Date]?: string;
+    /** FHIR-compatible explicit `effectiveDateTime` fallback. Example: `2026-06-01T10:00:00Z`. */
+    [ObservationClaim.EffectiveDateTime]?: string;
+    /** Language of authored text/narrative. Example: `en`, `es`. */
+    [ObservationClaim.Language]?: string;
+    /** Observation method token when relevant. Example: `http://snomed.info/sct|252465000`. */
+    [ObservationClaim.Method]?: string;
+    /** User-authored note. Example: `Measured after resting 5 minutes.` */
+    [ObservationClaim.Note]?: string;
+}
+/**
+ * General Observation claims for persisted/searchable clinical resources.
+ *
+ * This is the widest flat contract currently used by the package. It extends
+ * the Vital Signs-visible shape so consumers can reuse one traversal/query
+ * model while adding broader Observation fields such as encounter, performer,
+ * specimen, focus, and group membership.
+ */
+export interface ClaimsObservationGeneral extends ClaimsObservationVitalSigns {
+    /** Upstream order/request reference list. Example: `ServiceRequest/sr-1`. */
+    [ObservationClaim.BasedOn]?: string;
+    /** Device reference. Example: `Device/dev-1`. */
+    [ObservationClaim.Device]?: string;
+    /** Encounter reference. Example: `Encounter/enc-1`. */
+    [ObservationClaim.Encounter]?: string;
+    /** Focus reference list when the observation is about another target. Example: `Condition/cond-1`. */
+    [ObservationClaim.Focus]?: string;
+    /** Child Observation references for panels/groups. Example: `Observation/hr-1,Observation/temp-1`. */
+    [ObservationClaim.HasMember]?: string;
+    /** Synthetic tags summarizing component presence on a composite observation. Example: `bp-systolic,bp-diastolic`. */
+    [ObservationClaim.ComponentTags]?: string;
+    /** Component code values summarized on the parent observation. Example: `8480-6,8462-4`. */
+    [ObservationClaim.ComponentCodeValues]?: string;
+    /** Human-readable component names summarized on the parent observation. Example: `Systolic blood pressure,Diastolic blood pressure`. */
+    [ObservationClaim.ComponentNames]?: string;
+    /** Performer reference list. Example: `Practitioner/prac-1`. */
+    [ObservationClaim.Performer]?: string;
+    /** Specimen reference. Example: `Specimen/spec-1`. */
+    [ObservationClaim.Specimen]?: string;
+    /** Total assessment score summarized on the parent observation when applicable. Example: `8`. */
+    [ObservationClaim.ScoreTotalNumber]?: string | number;
+    /** Parent blood pressure panel copy of the systolic numeric value. Example: `120`. */
+    [ObservationClaim.BloodPressureSystolicNumber]?: string | number;
+    /** Parent blood pressure panel copy of the diastolic numeric value. Example: `78`. */
+    [ObservationClaim.BloodPressureDiastolicNumber]?: string | number;
+}
+/**
+ * Backwards-compatible alias kept during the current refactor.
+ *
+ * Prefer `ClaimsObservationVitalSigns` in new code when the row is expected to
+ * be one visible/searchable vital-sign Observation.
+ */
+export type ClaimsVitalSign = ClaimsObservationVitalSigns;
+/**
+ * Full persisted claim surface for a general Observation row in local storage.
+ *
+ * This list is intentionally broader than the searchable/indexable subset.
+ * Free-text or UI-only fields may exist here even when they must stay out of
+ * blind-query/search indexes.
+ */
+export declare const ObservationGeneralClaimsList: readonly ["Observation.based-on", "Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code-text", "Observation.code-display", "Observation.code", "Observation.date", "Observation.device", "Observation.encounter", "Observation.effective-datetime", "Observation.focus", "Observation.has-member", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.identifier", "Observation.language", "Observation.method", "Observation.note", "Observation.patient", "Observation.performer", "Observation.specimen", "Observation.status", "Observation.subject", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept-text", "Observation.value-concept-display", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.value-string"];
+/**
+ * Full persisted claim surface for visible/searchable Vital Signs rows.
+ *
+ * This keeps the claims-first authoring fields but still avoids introducing
+ * fields that only belong to broader Observation families.
+ */
+export declare const ObservationVitalSignsClaimsList: readonly ["Observation.category", "Observation.code-system", "Observation.code-value", "Observation.code-text", "Observation.code-display", "Observation.code", "Observation.date", "Observation.effective-datetime", "Observation.has-member", "Observation.component-tags", "Observation.component-code-values", "Observation.component-names", "Observation.identifier", "Observation.language", "Observation.method", "Observation.note", "Observation.patient", "Observation.status", "Observation.subject", "Observation.value-concept-system", "Observation.value-concept-value", "Observation.value-concept-text", "Observation.value-concept-display", "Observation.value-concept", "Observation.value-date", "Observation.value-quantity-comparator", "Observation.value-quantity-number", "Observation.value-quantity-unit", "Observation.score-total-number", "Observation.bp-systolic-number", "Observation.bp-diastolic-number", "Observation.value-string"];
+export declare const ObservationClaimSpecs: ClaimSpec[];
+/**
+ * Returns `true` when the flat claims represent one visible/searchable vital
+ * sign Observation row.
+ *
+ * Current rule:
+ * - must be categorized as `vital-signs`
+ * - must carry `Observation.status`
+ *
+ * Reduced indexed component rows derived from FHIR `component` intentionally do
+ * not carry `Observation.status`, so they are excluded from normal UI list and
+ * search results even though they remain persisted for reconstruction/export.
+ */
+export declare function isDisplayableVitalSignObservationClaims(claims: Record<string, unknown> | undefined): boolean;