@cosyte/terminology 0.0.12 → 0.1.0

package/dist/index.d.cts

@@ -111,9 +111,12 @@ declare function codeableConcept(init: CodeableConcept): CodeableConcept;
  *
  * Read that as the rule, and note what it does **not** say. It does not say no factory takes a
  * `string` parameter. Several do: `malformed(path, fault)` in `conceptmap/load.ts` and
- * `valueset/load.ts`, and `cannotExpand(detail, path)`, `truncated(detail, path)` and
- * `underPath(d, prefix)` in `valueset/`, where `expand.ts` and `validate.ts` each carry their own
- * copy. It says every **argument** reaching them is engine-owned: each `fault` and `detail` is a
+ * `valueset/load.ts`, and `cannotExpand(detail, path)`, `truncated(detail, path)`,
+ * `enumeratedUndefined(detail, path)` and `underPath(d, prefix)` in `valueset/`, where `expand.ts`
+ * and `validate.ts` each carry their own copy of the ones both operations raise
+ * (`enumeratedUndefined` is `expand.ts`'s alone: membership decides that case rather than reporting
+ * it, and a decided outcome carries no diagnostic). It says every **argument** reaching them is
+ * engine-owned: each `fault` and `detail` is a
  * literal at the call site, each `path` and `prefix` is built from indices by the loader that
  * raises it. That distinction is the thing to preserve: an absolute "no factory takes a value
  * parameter" reads as a stronger guarantee than the one the code makes, and those factories are the
@@ -227,19 +230,43 @@ declare const DIAGNOSTIC_CODES: {
     readonly TERM_CONCEPT_HEADER_NOT_BILLABLE: "TERM_CONCEPT_HEADER_NOT_BILLABLE";
     /**
      * A ValueSet `compose` part could **not be expanded**: an intensional `include`/`exclude` whose
-     * code system was not supplied, an unresolvable referenced value set, or a `filter` operator the
-     * engine does not implement. Surfaced as a typed outcome that marks the expansion **incomplete**;
+     * code system was not supplied, an unresolvable referenced value set, a `filter` operator the
+     * engine does not implement, or a component whose declared code system version disagrees with the
+     * supplied release (or names a pin that release carries no version to confirm). Surfaced as a
+     * typed outcome that marks the expansion **incomplete**;
      * the engine **never** fabricates a member and **never** returns a silently-empty "no members"
      * answer for a part it could not compute (a false "not a member" is a clinical error).
      */
     readonly TERM_VALUESET_CANNOT_EXPAND: "TERM_VALUESET_CANNOT_EXPAND";
     /**
      * A **pre-computed** `ValueSet.expansion` is **incomplete**: its `total` exceeds the number of
-     * `contains` entries, or it is flagged too-costly (the VSAC `$expand` >1200-code truncation
-     * hazard). The engine **never treats a truncated expansion as complete membership**: a code
-     * absent from a truncated expansion is `undetermined`, never a confident "not a member".
+     * `contains` entries, it is flagged too-costly (the VSAC `$expand` >1200-code truncation
+     * hazard), or it is marked `unclosed` (the value set is unbounded because it includes
+     * post-coordinated content, so no expansion can enumerate it). The engine **never treats an
+     * incomplete expansion as complete membership**: a code absent from one is `undetermined`, never
+     * a confident "not a member". The diagnostic's `detail` says which of those it was.
      */
     readonly TERM_VALUESET_EXPANSION_TRUNCATED: "TERM_VALUESET_EXPANSION_TRUNCATED";
+    /**
+     * A `ValueSet.compose` component **enumerated** a code the release supplied for its `system` does
+     * not define, so the code was **not admitted** as a member. The never-fabricate invariant applied
+     * to an extensional selection: enumerating a code is the value set's claim that it exists, and
+     * asserting membership for it while holding the very release that shows it does not is the engine
+     * deciding against its own evidence.
+     *
+     * Raised **only** where the evidence is in hand: a release keyed by the component's `system` that
+     * the component's declared `version` (if any) agrees with. No release for that system, a declared
+     * version the supplied release does not agree with, or a component naming no `system` at all
+     * leaves the engine with no contrary evidence, so every enumerated code is carried and **no
+     * diagnostic is raised**: absence of evidence is not evidence the code is undefined.
+     *
+     * The answer stays **decided**, unlike {@link TERM_VALUESET_CANNOT_EXPAND}: the engine computed
+     * membership on the evidence it was given, so `expand` reports `complete: true` and
+     * `validateCodeInValueSet` reports a decided non-member for the dropped code, rather than a lower
+     * bound or a refusal. One diagnostic is raised per affected component, located by that
+     * component's own index path, however many of its codes were dropped.
+     */
+    readonly TERM_VALUESET_ENUMERATED_CODE_UNDEFINED: "TERM_VALUESET_ENUMERATED_CODE_UNDEFINED";
     /**
      * A UCUM unit expression is **not valid**: it does not parse against the UCUM grammar, or it
      * names an atom absent from the vendored UCUM table. A **first-class typed outcome, never an
@@ -652,6 +679,29 @@ interface TranslateMatch {
     /** Author's free-text comment on this mapping, when present (carried verbatim, e.g. map advice). */
     readonly comment?: string;
 }
+/**
+ * One target the map explicitly asserted is **not related** to the source: an R4 `disjoint` row,
+ * carried verbatim on a {@link TranslateUnmapped} result so the assertion the map author made is
+ * not lost when the source reports as not translated.
+ *
+ * This is the opposite of a {@link TranslateMatch}: a `disjoint` row is a declared non-mapping, so
+ * it never counts toward the translated verdict. It is surfaced because dropping it would discard
+ * what the steward said. A pure `unmatched` assertion carries no target code and is not surfaced
+ * here.
+ */
+interface TranslateNotRelated {
+    /** The target {@link Coding} exactly as declared in the map (frozen). */
+    readonly target: Coding;
+    /**
+     * The normalized, version-neutral relationship (R5 vocabulary), folded from the token below by
+     * the same table every match uses: always `not-related-to` for a `disjoint` row.
+     */
+    readonly relationship: Relationship;
+    /** Always `disjoint`: the verbatim FHIR R4 `equivalence` token this assertion was declared with. */
+    readonly equivalence: "disjoint";
+    /** Author's free-text comment on this assertion, when present (carried verbatim). */
+    readonly comment?: string;
+}
 /**
  * The FHIR R4 `group.unmapped.mode` an unmapped source fell through to: the map author's declared
  * fallback behavior. Surfaced (never silently acted on): the caller decides whether to trust a
@@ -660,7 +710,8 @@ interface TranslateMatch {
  * - `provided`: echo the source code as the target (the map declares no real mapping).
  * - `fixed`: a single fixed fallback code the map declares for *all* unmapped sources.
  * - `other-map`: consult the referenced ConceptMap (which this engine does not auto-follow).
- * - `none`: no `group.unmapped` directive applied (plain no-match, or an explicit `unmatched`).
+ * - `none`: no `group.unmapped` directive applied (plain no-match, or an authored non-mapping: an
+ *   explicit `unmatched`, or a source whose every declared target is `disjoint`).
  */
 type UnmappedMode = "provided" | "fixed" | "other-map" | "none";
 /** Provenance of a translation, which map (and which group's systems) produced it. */
@@ -680,11 +731,21 @@ interface MapProvenance {
     /** The target code system of the group that matched, when known. */
     readonly targetSystem?: string;
 }
-/** A successful translation: one or more matches, never empty (an empty result is `unmapped`). */
+/**
+ * A successful translation: one or more matches, never empty (an empty result is `unmapped`), and
+ * **at least one of them asserts a relationship** to the source. A `disjoint` row still appears in
+ * `matches`, in its declared position, whenever some other target for the same source does assert a
+ * relationship: nothing the map said is dropped. When *every* declared target asserts non-relation
+ * there is no relationship to report, so the result is a {@link TranslateUnmapped} carrying those
+ * rows on `notRelated` instead.
+ */
 interface TranslateMatched {
     /** Discriminant: the source mapped. */
     readonly unmapped: false;
-    /** The target concepts, in declared order. Non-empty and frozen. */
+    /**
+     * The target concepts, in declared order. Non-empty and frozen. At least one carries a
+     * relationship other than `not-related-to`.
+     */
     readonly matches: readonly TranslateMatch[];
     /** Where this translation came from. */
     readonly provenance: MapProvenance;
@@ -694,6 +755,11 @@ interface TranslateMatched {
  * **no target is ever guessed**. Any `group.unmapped` fallback the author declared is reported via
  * {@link UnmappedMode} (and `fixedTarget`/`otherMapUrl`) for the caller to accept or reject: the
  * engine does not silently substitute it.
+ *
+ * A source whose every declared target asserts non-relation (R4 `disjoint` or `unmatched`) reports
+ * here too: the map said these concepts are *not* related, which is an answer, not a translation.
+ * The `disjoint` rows it asserted are carried on `notRelated`, verbatim. Any target on this result
+ * was declared in the map; none of it is a mapping.
  */
 interface TranslateUnmapped {
     /** Discriminant: the source did not map. */
@@ -704,6 +770,13 @@ interface TranslateUnmapped {
     readonly mode: UnmappedMode;
     /** The original source {@link Coding}, surfaced untouched. */
     readonly source: Coding;
+    /**
+     * The `disjoint` rows the map declared for this source, in declared order, when it declared any:
+     * explicit assertions that those targets are **not related** to the source. Present (frozen and
+     * non-empty) only when every declared target asserted non-relation, which is what put the result
+     * here; omitted otherwise. These are declared non-mappings, never candidates to fall back to.
+     */
+    readonly notRelated?: readonly TranslateNotRelated[];
     /** For `mode: "fixed"`, the author's fixed fallback coding: reported, not auto-applied. */
     readonly fixedTarget?: Coding;
     /** For `mode: "other-map"`, the referenced map's URL: reported, not auto-followed. */
@@ -831,7 +904,10 @@ declare function loadConceptMap(json: unknown): ConceptMap;
  * a **typed {@link TranslateUnmapped}**. Two invariants govern it:
  *
  * 1. **Never fabricate.** An unmapped source yields a surfaced `unmapped` result: never a guessed
- *    target. Every target returned is drawn verbatim from the map; the engine invents nothing.
+ *    target. Every target returned is drawn verbatim from the map; the engine invents nothing. A
+ *    map that explicitly asserts non-relation (R4 `disjoint`) has answered, so that source reports
+ *    as not translated with the asserted rows carried on `notRelated`: reading a declared
+ *    "not related" as a successful translation would be a fabrication of the same kind.
  * 2. **Never invert.** Translation reads the map in its authored direction only: a source coding is
  *    matched against `group.element.code` (the source side) and **never** against target codes. A
  *    directional map therefore cannot be run backwards: reverse translation requires an explicit
@@ -846,9 +922,14 @@ declare function loadConceptMap(json: unknown): ConceptMap;
  * Matches the coding's `code` against each applicable group's `element.code` (the **source** side,
  * never targets, so the map is never inverted) and returns every declared target for it. A target
  * with an `unmatched` equivalence, or with no `code`, is treated as "no target" (the FHIR way of
- * asserting a non-mapping), and does not count as a match. When nothing matches, the map author's
- * `group.unmapped` directive (if any) is *reported* via the result's {@link UnmappedMode} but never
- * silently applied.
+ * asserting a non-mapping), and does not count as a match. A `disjoint` target is the map's
+ * explicit assertion that the target is *not related* to the source, so it does not count as a
+ * match either: when **every** declared target for the source asserts non-relation the result is
+ * `unmapped`, carrying those `disjoint` rows verbatim on `notRelated`. When at least one target
+ * does assert a relationship, the result is matched and carries every declared target, `disjoint`
+ * rows included, in declared order. When nothing matches, the map author's `group.unmapped`
+ * directive (if any) is *reported* via the result's {@link UnmappedMode} but never silently
+ * applied.
  *
  * @param sourceCoding - The source concept to translate.
  * @param map - A {@link ConceptMap} from {@link loadConceptMap}.
@@ -1589,7 +1670,16 @@ interface ConceptSetFilter {
 interface ConceptRef {
     /** The code, drawn verbatim from the value set. */
     readonly code: string;
-    /** The display, when the value set supplied one (carried verbatim, never fabricated). */
+    /**
+     * The display, when the value set supplied one (carried verbatim, never fabricated).
+     *
+     * This is the value set's **own** display and it always wins. Where the value set supplies none,
+     * {@link expand} falls back to the display the supplied {@link CodeSystem} release carries for the
+     * same code, again **verbatim**: the engine still synthesizes nothing, so a member whose release
+     * was not supplied, or which that release carries with no display, comes back with no display at
+     * all. A code a *usable* release does not carry is a membership question rather than a display
+     * one: see {@link ConceptSetComponent.concept}.
+     */
     readonly display?: string;
 }
 /**
@@ -1600,9 +1690,28 @@ interface ConceptRef {
 interface ConceptSetComponent {
     /** The code system these codes are drawn from (canonical URI), when the component names one. */
     readonly system?: string;
-    /** The code system version to pin the selection to, when declared. */
+    /**
+     * The code system version to pin the selection to, when declared.
+     *
+     * Wherever the selection actually resolves a supplied {@link CodeSystem} (a `filter`, or a
+     * whole-system component with no {@link concept} list), the pin is **checked** against that
+     * release's own `version`: a disagreement, or a release that declares no version to agree with, is
+     * a typed {@link DiagnosticCode.TERM_VALUESET_CANNOT_EXPAND} that marks the outcome incomplete or
+     * undetermined, never membership computed from the other release. The check is that the two
+     * declarations agree, not that either is true: a mislabelled release is still trusted.
+     */
     readonly version?: string;
-    /** An explicit, enumerated code list (extensional). Mutually exclusive with {@link filter} in FHIR. */
+    /**
+     * An explicit, enumerated code list (extensional). Mutually exclusive with {@link filter} in FHIR.
+     *
+     * An entry is admitted as a member only where the evidence the caller supplied does not
+     * contradict it. Where a release keyed by this component's {@link system} is in hand and the
+     * declared {@link version} (if any) agrees with it, a code that release does not define is **not**
+     * a member: {@link expand} omits it, reporting one typed
+     * {@link DiagnosticCode.TERM_VALUESET_ENUMERATED_CODE_UNDEFINED} for this component while staying
+     * `complete: true`, and {@link validateCodeInValueSet} decides it a non-member. Where no usable
+     * release was supplied, the engine holds no contrary evidence and every enumerated code stands.
+     */
     readonly concept?: readonly ConceptRef[];
     /** Intensional filters over {@link system}. Each code must satisfy **all** filters. */
     readonly filter?: readonly ConceptSetFilter[];
@@ -1615,6 +1724,21 @@ interface ValueSetCompose {
     readonly include: readonly ConceptSetComponent[];
     /** The `exclude` components: codes removed from the include union. */
     readonly exclude: readonly ConceptSetComponent[];
+    /**
+     * `ValueSet.compose.inactive`, when the resource declares one: whether codes the supplied release
+     * marks as **not active** belong to the membership.
+     *
+     * A declared `false` is an **active-only** value set, and the engine honours it: an `include`
+     * contributes only the codes the supplied {@link CodeSystem} release marks active. A release that
+     * carries no status for a selected concept is not evidence of inactivity, so that member is kept;
+     * a component whose activity cannot be checked against any usable release contributes **nothing**
+     * and marks the outcome incomplete, so `contains` stays a lower bound rather than a set that may
+     * hold inactive codes.
+     *
+     * Absent, or `true`, and no code is ever omitted on activity grounds. This is the value set's own
+     * declaration and nothing else: `$expand`'s `activeOnly` **request** parameter is not modelled.
+     */
+    readonly inactive?: boolean;
 }
 /** One `ValueSet.expansion.contains` entry from a **pre-computed** expansion. */
 interface ExpansionContains {
@@ -1640,9 +1764,26 @@ interface ValueSetExpansion {
     /**
      * Derived at load: the expansion is **incomplete**. True when `total` exceeds `contains.length`, or
      * the `http://hl7.org/fhir/StructureDefinition/valueset-toocostly` extension flagged it too-costly
-     * (the VSAC >1200-code truncation hazard). A truncated expansion never reads as complete membership.
+     * (the VSAC >1200-code truncation hazard), or {@link unclosed} is set. A truncated expansion never
+     * reads as complete membership.
      */
     readonly truncated: boolean;
+    /**
+     * Derived at load: the server marked the expansion `unclosed`
+     * (`http://hl7.org/fhir/StructureDefinition/valueset-unclosed`), meaning the value set is
+     * **unbounded** because it includes post-coordinated content (SNOMED CT, UCUM), so codes other
+     * than the ones listed may be valid and no expansion can enumerate its membership.
+     *
+     * A source of incompleteness in its own right: whenever this is `true` so is {@link truncated}.
+     * It is carried separately so a caller can tell an unbounded value set from a truncated page, and
+     * the mark is read **fail-safe**: an entry that names the extension but carries no readable
+     * boolean is taken as set, and only an explicit `valueBoolean: false` reads as absent.
+     *
+     * The engine only ever **reads** this off a supplied expansion. It never sets it on an expansion
+     * it computes: `expand` runs over consumer-supplied code systems and cannot assert
+     * post-coordination.
+     */
+    readonly unclosed: boolean;
 }
 /**
  * A loaded, immutable `ValueSet`: the subset of the FHIR R4 `ValueSet` resource the binding layer
@@ -1676,9 +1817,17 @@ interface ExpansionContext {
     /** Referenced value sets, keyed by canonical URL, for `compose.include.valueSet`. */
     readonly valueSets?: ReadonlyMap<string, ValueSet>;
 }
-/** A surfaced expansion concern: a part that could not be expanded, or a truncated snapshot. */
+/**
+ * A surfaced expansion concern: a part that could not be expanded, a truncated snapshot, or an
+ * enumerated code the supplied release does not define.
+ */
 interface ExpansionDiagnostic {
-    /** The stable code (`TERM_VALUESET_CANNOT_EXPAND` / `TERM_VALUESET_EXPANSION_TRUNCATED`). */
+    /**
+     * The stable code (`TERM_VALUESET_CANNOT_EXPAND` / `TERM_VALUESET_EXPANSION_TRUNCATED` /
+     * `TERM_VALUESET_ENUMERATED_CODE_UNDEFINED`). Branch on it: the first two mean the answer is a
+     * lower bound, the third reports a **decided** answer the engine narrowed on the caller's own
+     * evidence.
+     */
     readonly code: DiagnosticCode;
     /** A **value-free** structural description of the concern (never echoes a patient value). */
     readonly detail: string;
@@ -1699,9 +1848,15 @@ interface ExpansionDiagnostic {
  * The result of {@link expand}: the flattened membership plus an honest **completeness** signal.
  *
  * `complete` is `false` whenever any part could not be fully computed (a missing code system, an
- * unresolved referenced value set, an unimplemented `filter` op, or a truncated pre-computed
- * expansion). A `false` here is the never-fabricate contract in action: the `contains` set is a
+ * unresolved referenced value set, an unimplemented `filter` op, a truncated pre-computed
+ * expansion, or a component whose declared {@link ConceptSetComponent.version} disagrees with the
+ * supplied release). A `false` here is the never-fabricate contract in action: the `contains` set is a
  * **lower bound**, so it must never be read as exhaustive membership.
+ *
+ * An enumerated code the supplied release does not define does **not** set it: that member was
+ * decided, not left unresolved, so the answer stays `complete: true` and carries a
+ * {@link DiagnosticCode.TERM_VALUESET_ENUMERATED_CODE_UNDEFINED} diagnostic instead. A `complete`
+ * expansion can therefore carry diagnostics: read {@link diagnostics} on both.
  */
 interface ExpandResult {
     /** Whether the expansion is exhaustive. When `false`, `contains` is a lower bound, not the whole set. */
@@ -1760,9 +1915,11 @@ type ValueSetMembership = ValueSetMemberDecided | ValueSetMemberUndetermined;
  * Load an untrusted FHIR R4 `ValueSet` JSON value into an immutable {@link ValueSet}.
  *
  * Accepts the standard resource shape: `resourceType: "ValueSet"` with an optional intensional
- * `compose` (`include`/`exclude` of `system`/`concept`/`filter`/`valueSet`) and/or a **pre-computed**
- * `expansion` (`contains`, with `total` and the `valueset-toocostly` extension read into a derived
- * `truncated` flag). The result is deep-frozen. Anything structurally unusable throws a
+ * `compose` (`include`/`exclude` of `system`/`concept`/`filter`/`valueSet`, plus the `inactive`
+ * declaration that decides whether non-active codes belong to the membership) and/or a **pre-computed**
+ * `expansion` (`contains`, with `total` and the `valueset-toocostly` / `valueset-unclosed`
+ * extensions read into a derived `truncated` flag, the last of them also surfaced on its own
+ * `unclosed` flag). The result is deep-frozen. Anything structurally unusable throws a
  * {@link TerminologyError} carrying {@link FATAL_CODES.TERM_VALUESET_MALFORMED}.
  *
  * @param json - The untrusted resource (typically `JSON.parse` output, hence `unknown`).
@@ -1796,13 +1953,26 @@ declare function loadValueSet(json: unknown): ValueSet;
  *   releases: the union of `include` components minus the union of `exclude` components. Each component
  *   selects by explicit `concept`, by `filter` (subsumption + property predicates), by the whole
  *   `system`, and/or by intersecting referenced value sets.
+ * - A `compose` that declares `inactive: false` is **active-only**: a code the supplied release marks
+ *   not active is omitted from every `include` branch alike, and a component whose activity no
+ *   supplied release can decide contributes nothing and marks the result incomplete.
  *
  * **Never fabricate.** A part that cannot be computed (a missing code system, an unresolved
- * referenced value set, an unimplemented `filter` operator) yields a typed
+ * referenced value set, an unimplemented `filter` operator, or a component whose declared code
+ * system version disagrees with the supplied release) yields a typed
  * {@link ../common/diagnostics.DIAGNOSTIC_CODES.TERM_VALUESET_CANNOT_EXPAND} and marks the result
  * `complete: false`, so the `contains` set is an explicit **lower bound**, never a silently-empty or
  * fabricated membership.
  *
+ * The same rule read the other way bounds an **enumeration**: a `concept` entry is admitted only
+ * where the evidence the caller supplied does not contradict it. Where a usable release for the
+ * component's `system` is in hand and does not define the code, the code is **not** a member, the
+ * answer stays decided and `complete: true` (the engine decided it, on that evidence), and the drop
+ * is surfaced as a typed
+ * {@link ../common/diagnostics.DIAGNOSTIC_CODES.TERM_VALUESET_ENUMERATED_CODE_UNDEFINED} rather
+ * than happening silently. Where no usable release was supplied there is no contrary evidence, so
+ * the value set's own enumeration stands untouched.
+ *
  * @packageDocumentation
  */
 
@@ -1845,10 +2015,21 @@ declare function expand(vs: ValueSet, ctx?: ExpansionContext): ExpandResult;
  * (`result: true`/`false`) **only when it can prove it**: a code found in a computable `include` and
  * not removed by any computable `exclude` is a definite member; a code absent from a fully-evaluated
  * value set is a definite non-member. When any relevant part cannot be evaluated (a missing code
- * system, a truncated pre-computed expansion, an unimplemented `filter`), the answer is a typed
+ * system, a truncated pre-computed expansion, an unimplemented `filter`, a component whose declared
+ * code system version disagrees with the supplied release, or an active-only value set whose
+ * activity no supplied release can decide), the answer is a typed
  * {@link ValueSetMemberUndetermined}: **never** a fabricated `false` (a false "not a member" is a
  * clinical error).
  *
+ * The mirror of that rule is that a code is never decided a member on evidence the caller did not
+ * supply either: a `Coding` carrying no `system` names no code in a system-scoped component, so such
+ * a component is a definite non-match, and a value set whose components all name a system decides
+ * `false` rather than asserting an unqualified code into it. Nor is it decided a member against
+ * evidence the caller DID supply: a code an `include` enumerates but the usable release for that
+ * component's `system` does not define is a definite non-member, matching the entry {@link expand}
+ * drops for the same reason. Where no usable release was supplied, the enumeration alone decides,
+ * exactly as before.
+ *
  * @packageDocumentation
  */
 
@@ -1959,8 +2140,11 @@ interface FilterMatch {
  * Evaluate one {@link ConceptSetFilter} against one {@link Concept}, using the release's hierarchy.
  *
  * The `concept` filter property (and the hierarchy operators regardless of property) reads the code
- * itself / its subsumption; other properties read the concept's `property` values. An unimplemented
- * operator returns `{ supported: false }`: never a coerced `matched`.
+ * itself / its subsumption; other properties read the concept's `property` values. `CodeSystem
+ * .concept.property` is `0..*`, so **every** value the concept carries for the property is read:
+ * `=` and `in` match on ANY of them, `not-in` matches only where NONE of them is in the filter's
+ * set, and `exists` follows whether the concept carries any at all. An unimplemented operator
+ * returns `{ supported: false }`: never a coerced `matched`.
  *
  * @param concept - The concept under test.
  * @param filter - The filter predicate.
@@ -3637,6 +3821,9 @@ declare function isSynonymTermType(tty: TermType): boolean;
  * - {@link loadConceptMap} + {@link translate}: the ConceptMap `$translate` engine, with the
  *   **never-fabricate / never-invert** invariants: an unmapped source is a typed
  *   {@link TranslateUnmapped}, never a guessed target; a directional map is never run backwards.
+ *   A source whose every declared target asserts non-relation (R4 `disjoint` / `unmatched`) is not
+ *   translated either: it reports as {@link TranslateUnmapped}, carrying the `disjoint` rows the
+ *   map asserted on `notRelated`.
  *
  * **The CodeSystem load layer**, with the FHIR `$lookup` / `$validate-code` operations:
  *
@@ -3655,6 +3842,9 @@ declare function isSynonymTermType(tty: TermType): boolean;
  * - {@link expand}: flatten membership over the supplied {@link CodeSystem}s (`include`/`exclude`,
  *   explicit `concept` lists, `is-a`/property `filter`s, referenced value sets), with an honest
  *   `complete` flag: an unresolvable part is a typed `TERM_VALUESET_CANNOT_EXPAND`, never a guess.
+ *   An enumerated code the release you supplied for that component does not define is not a member
+ *   either: it is omitted, the answer stays `complete: true`, and the drop is a typed
+ *   `TERM_VALUESET_ENUMERATED_CODE_UNDEFINED` rather than a silent one.
  * - {@link validateCodeInValueSet}: binding membership, returning a **decided** `result` only when
  *   proven and a typed `undetermined` otherwise (a truncated expansion never reads as complete).
  *
@@ -3749,4 +3939,4 @@ declare function isSynonymTermType(tty: TermType): boolean;
  */
 declare const VERSION: string;
 
-export { type AnnotationNode, type ApproximateMatchOptions, type BillableFlag, COMPLEX_MAP_SOURCE_SYSTEM, type CodeSystem, type CodeSystemSource, type CodeableConcept, type Coding, type ComplexMap, type ComplexMapApplyResult, type ComplexMapContextRequired, type ComplexMapEntry, type ComplexMapGroupNoMap, type ComplexMapGroupResolved, type ComplexMapGroupResult, type ComplexMapInput, type ComplexMapLoadWarning, type ComplexMapMatched, type ComponentNode, type Concept, type ConceptActivity, type ConceptMap, type ConceptMapElement, type ConceptMapGroup, type ConceptMapTarget, type ConceptMapUnmapped, type ConceptRef, type ConceptSetComponent, type ConceptSetFilter, type ConceptStatus, type CrosswalkNoMap, type CrosswalkUnmapped, type CsvColumnMap, type CsvSource, DIAGNOSTIC_CODES, type DiagnosticCode, type ExpandResult, type ExpansionContains, type ExpansionContext, type ExpansionDiagnostic, FATAL_CODES, type FactorNode, type FatalCode, type FhirCodeSystemSource, type FieldSlice, type FilterMatch, type FilterOperator, type FixedWidthFieldMap, type FixedWidthPropertyField, type FixedWidthSource, type GemApplyResult, type GemChoiceList, type GemDirection, type GemEntry, type GemFlags, type GemLoadWarning, type GemMap, type GemMatched, type GemScenario, type GemSource, type GroupNode, HL7_V2_OID_ROOT, HL7_V2_URL_PREFIX, ICD10CM_ORDER_FILE_FIELDS, ICD10CM_SYSTEM, ICD9CM_SYSTEM, type LinearReduction, type LoadWarning, type LookupOutcome, type LookupResult, type LookupUnknown, MAP_CATEGORIES, type MapCategoryId, type MapProvenance, NO_MAP_CATEGORIES, type NdcResolution, type NdcResult, type NdcStatus, type NdcUnmapped, type ParseFailure, type ParseResult, type PatientContext, type Property, type R4Equivalence, RELA, RELA_INVERSE, RXNORM_SYSTEM, type Reduction, type RelaName, type Relationship, type ResolveSystemResult, type RrfColumnMap, type RrfPropertyColumn, type RrfSource, type RxNormApproximateMatch, type RxNormConcept, type RxNormEdge, type RxNormGraph, type RxNormGraphSource, type RxNormLoadWarning, type RxNormNavResult, type RxNormRelated, type RxNormUnknown, SNOMEDCT_SYSTEM, SYSTEM_IDENTITIES, type SimpleUnitNode, type SpecialReduction, type StatusMapper, type Subsumption, type SystemIdentity, TERM_TYPES, type TermType, TerminologyError, type TranslateMatch, type TranslateMatched, type TranslateResult, type TranslateUnmapped, type UcumAtom, type UcumEssence, type UcumPrefix, type UcumValidation, type UnitNode, type UnknownSystem, type UnmappedMode, VERSION, type ValidateCodeResult, type ValueSet, type ValueSetCompose, type ValueSetExpansion, type ValueSetMemberDecided, type ValueSetMemberUndetermined, type ValueSetMembership, applyComplexMap, applyGem, approximateMatch, asTermType, brandsFor, buildSubsumption, codeableConcept, coding, consistsOf, defaultStatusMapper, doseFormsOf, expand, genericFor, getArray, getBoolean, getConcept, getNumber, getString, ingredientsOf, invertGem, isA, isJsonObject, isSynonymTermType, isUnknownSystem, loadCodeSystem, loadComplexMap, loadConceptMap, loadGems, loadRxNormGraph, loadUcumEssence, loadValueSet, lookup, makeStatus, matchesFilter, parseCsv, parseCsvSource, parseFhirCodeSystem, parseFixedWidth, parseRrf, parseRrfLine, parseUcum, reduce, relatedByRela, resolveNdc, resolveSystem, sliceField, translate, ucumEqual, unsupportedOps, validateCode, validateCodeInValueSet, validateUcum };
+export { type AnnotationNode, type ApproximateMatchOptions, type BillableFlag, COMPLEX_MAP_SOURCE_SYSTEM, type CodeSystem, type CodeSystemSource, type CodeableConcept, type Coding, type ComplexMap, type ComplexMapApplyResult, type ComplexMapContextRequired, type ComplexMapEntry, type ComplexMapGroupNoMap, type ComplexMapGroupResolved, type ComplexMapGroupResult, type ComplexMapInput, type ComplexMapLoadWarning, type ComplexMapMatched, type ComponentNode, type Concept, type ConceptActivity, type ConceptMap, type ConceptMapElement, type ConceptMapGroup, type ConceptMapTarget, type ConceptMapUnmapped, type ConceptRef, type ConceptSetComponent, type ConceptSetFilter, type ConceptStatus, type CrosswalkNoMap, type CrosswalkUnmapped, type CsvColumnMap, type CsvSource, DIAGNOSTIC_CODES, type DiagnosticCode, type ExpandResult, type ExpansionContains, type ExpansionContext, type ExpansionDiagnostic, FATAL_CODES, type FactorNode, type FatalCode, type FhirCodeSystemSource, type FieldSlice, type FilterMatch, type FilterOperator, type FixedWidthFieldMap, type FixedWidthPropertyField, type FixedWidthSource, type GemApplyResult, type GemChoiceList, type GemDirection, type GemEntry, type GemFlags, type GemLoadWarning, type GemMap, type GemMatched, type GemScenario, type GemSource, type GroupNode, HL7_V2_OID_ROOT, HL7_V2_URL_PREFIX, ICD10CM_ORDER_FILE_FIELDS, ICD10CM_SYSTEM, ICD9CM_SYSTEM, type LinearReduction, type LoadWarning, type LookupOutcome, type LookupResult, type LookupUnknown, MAP_CATEGORIES, type MapCategoryId, type MapProvenance, NO_MAP_CATEGORIES, type NdcResolution, type NdcResult, type NdcStatus, type NdcUnmapped, type ParseFailure, type ParseResult, type PatientContext, type Property, type R4Equivalence, RELA, RELA_INVERSE, RXNORM_SYSTEM, type Reduction, type RelaName, type Relationship, type ResolveSystemResult, type RrfColumnMap, type RrfPropertyColumn, type RrfSource, type RxNormApproximateMatch, type RxNormConcept, type RxNormEdge, type RxNormGraph, type RxNormGraphSource, type RxNormLoadWarning, type RxNormNavResult, type RxNormRelated, type RxNormUnknown, SNOMEDCT_SYSTEM, SYSTEM_IDENTITIES, type SimpleUnitNode, type SpecialReduction, type StatusMapper, type Subsumption, type SystemIdentity, TERM_TYPES, type TermType, TerminologyError, type TranslateMatch, type TranslateMatched, type TranslateNotRelated, type TranslateResult, type TranslateUnmapped, type UcumAtom, type UcumEssence, type UcumPrefix, type UcumValidation, type UnitNode, type UnknownSystem, type UnmappedMode, VERSION, type ValidateCodeResult, type ValueSet, type ValueSetCompose, type ValueSetExpansion, type ValueSetMemberDecided, type ValueSetMemberUndetermined, type ValueSetMembership, applyComplexMap, applyGem, approximateMatch, asTermType, brandsFor, buildSubsumption, codeableConcept, coding, consistsOf, defaultStatusMapper, doseFormsOf, expand, genericFor, getArray, getBoolean, getConcept, getNumber, getString, ingredientsOf, invertGem, isA, isJsonObject, isSynonymTermType, isUnknownSystem, loadCodeSystem, loadComplexMap, loadConceptMap, loadGems, loadRxNormGraph, loadUcumEssence, loadValueSet, lookup, makeStatus, matchesFilter, parseCsv, parseCsvSource, parseFhirCodeSystem, parseFixedWidth, parseRrf, parseRrfLine, parseUcum, reduce, relatedByRela, resolveNdc, resolveSystem, sliceField, translate, ucumEqual, unsupportedOps, validateCode, validateCodeInValueSet, validateUcum };