ezmedicationinput 0.1.45 → 0.1.47

package/README.md

@@ -17,6 +17,12 @@
 - Surfaces warnings when discouraged tokens (`QD`, `QOD`, `BLD`) are used and optionally rejects them.
 - Generates upcoming administration timestamps from FHIR dosage data via `nextDueDoses` using configurable clinic clocks.
 - Auto-codes common body-site phrases (e.g. "left arm", "right eye") with SNOMED CT anatomy concepts and supports interactive lookup flows for ambiguous sites.
+- Represents spatial body-site phrases such as `below ear`, `right side of abdomen`, `between fingers`, and Thai forms like `ระหว่างนิ้วมือ` through structured site metadata.
+- Exposes body-site lookup/suggestion/listing helpers and SNOMED postcoordination helpers for UI search and terminology workflows.
+
+## Parser architecture
+
+The parser is built around an HPSG-style lexical/sign grammar: tokens become typed signs, signs unify into clause-level structures, and the final projection emits FHIR `Dosage`. It is **not** a pure academic HPSG implementation; deterministic projection is still required for FHIR shape, terminology lookup, formatting, and compatibility behavior.
 
 ## Installation
 
@@ -255,10 +261,175 @@ result.fhir.site?.coding?.[0];
 // → { system: "http://snomed.info/sct", code: "368208006", display: "Left upper arm structure" }
 ```
 
+Spatial site phrases are preserved as structured metadata on `Dosage.site.extension`
+and in `ParseResult.meta.normalized.site.spatialRelation`.
+
+```ts
+const result = parseSig("apply to area between fingers");
+
+result.fhir.site?.text;
+// → "area between fingers"
+
+result.meta.normalized.site?.spatialRelation;
+// → {
+//      relationText: "between",
+//      targetText: "fingers",
+//      targetCoding: {
+//        system: "http://snomed.info/sct",
+//        code: "7569003",
+//        display: "Finger structure"
+//      }
+//    }
+```
+
+Only relations that exist in the FHIR BodyStructure relative-location ValueSet
+receive `spatialRelation.relationCoding` (for example `Above`, `Beneath`,
+`Posterior`, `Upper`, `Lower`, and `Lateral`). Other useful spatial language,
+such as `between`, `around`, `near`, and `inside`, is preserved as
+`relationText` without pretending there is an official code for it.
+
+Thai and mixed-language site phrases resolve through the same site grammar:
+
+```ts
+parseSig("apply ระหว่างนิ้วมือ", { locale: "th" }).longText;
+// → "ทา บริเวณระหว่างนิ้วมือ."
+
+parseSig("apply ระหว่างนิ้วเท้า", { locale: "th" }).longText;
+// → "ทา บริเวณระหว่างนิ้วเท้า."
+
+parseSig("apply ระหว่างนิ้ว", {
+  locale: "th",
+  context: { bodySiteContext: "feet" }
+}).longText;
+// → "ทา บริเวณระหว่างนิ้วเท้า."
+```
+
 When the parser encounters an unfamiliar site, it leaves the text untouched and records nothing in `meta.siteLookups`. Wrapping the phrase in braces (e.g. `apply to {mole on scalp}`) preserves the same parsing behavior but flags the entry as a **probe** so `meta.siteLookups` always contains the request. This allows UIs to display lookup widgets even before a matching code exists. Braces are optional when the site is already recognized—they simply make the clinician's intent explicit.
 
 Unknown body sites still populate `Dosage.site.text` and `ParseResult.meta.normalized.site.text`, allowing UIs to echo the verbatim phrase while terminology lookups run asynchronously.
 
+For typeahead/search UI, use the exported body-site helpers directly:
+
+```ts
+import {
+  getBodySiteCode,
+  getBodySiteCodeAsync,
+  getBodySiteText,
+  getBodySiteTextAsync,
+  listSupportedBodySiteGrammar,
+  listSupportedBodySiteText,
+  lookupBodySite,
+  suggestBodySiteText,
+  suggestBodySites
+} from "ezmedicationinput";
+
+getBodySiteCode("left ass");
+// → { system: "http://snomed.info/sct", code: "723979003", display: "Structure of left buttock" }
+
+getBodySiteText("723979003");
+// → "left buttock"
+
+getBodySiteText("22253000:363698007=723979003");
+// → "left buttock"
+
+getBodySiteCode("top of head");
+// → { system: "http://snomed.info/sct", code: "69536005:106233006=261183002", display: "top of head" }
+
+getBodySiteCode("top of head", { postcoordination: false });
+// → undefined
+
+getBodySiteText("69536005:106233006=261183002");
+// → "top of head"
+
+getBodySiteCode("right big toe");
+// → { system: "http://snomed.info/sct", code: "78883009:272741003=24028007", display: "right great toe" }
+
+getBodySiteText("78883009:272741003=24028007");
+// → "right great toe"
+
+getBodySiteText("22253000:363698007=723979003", {
+  parsePostcoordination: false
+});
+// → undefined
+
+lookupBodySite("ระหว่างนิ้ว", { bodySiteContext: "feet" });
+// → { text: "between toes", spatialRelation: { relationText: "between", ... }, ... }
+
+suggestBodySites("หนัง", { limit: 5 });
+// → [{ text: "scalp", coding: { code: "41695006", ... }, ... }]
+
+suggestBodySiteText("นิ้วโป้ง", { limit: 5 });
+// → ["thumb", "great toe", ...]
+
+listSupportedBodySiteText({ limit: 10 });
+// → ["abdomen", "affected area", ...]
+
+listSupportedBodySiteGrammar().siteAnchors;
+// → ["above", "around", "at", "beneath", "below", "between", ...]
+```
+
+`getBodySiteCode` and `getBodySiteText` are convenience wrappers for the common
+phrase-to-code and code-to-label cases. `getBodySiteCode` returns direct
+pre-coordinated body-site codings when available; otherwise it can build a
+SNOMED topographical-modifier expression for coded spatial phrases such as
+`top of head` or `below ear`, and SNOMED laterality expressions for digit sites
+such as `right big toe`. Parsed medication orders use the same behavior for
+`Dosage.site.coding` by default and still preserve the structured spatial
+extension; pass `bodySitePostcoordination: false` to `parseSig` when a consumer
+only accepts literal body-site codes. `getBodySiteText` resolves finding-site,
+topographical-modifier, and laterality postcoordination by default. Pass
+`postcoordination: false` or `parsePostcoordination: false` to require literal
+body-site codes only.
+
+`lookupBodySite` returns the full resolved metadata, including spatial relation
+details. `suggestBodySites` returns ranked bundled/custom candidates for
+autocomplete, while `suggestBodySiteText` returns only display labels.
+`listSupportedBodySiteText` exposes the bundled/custom label inventory for UI
+preloading, and `listSupportedBodySiteGrammar` exposes the supported site
+anchors/prepositions, locative relations, partitive heads/modifiers, and
+SNOMED-coded spatial relation metadata. Lookup helpers accept `siteCodeMap`;
+phrase-based helpers also accept `bodySiteContext`, used only for genuinely
+ambiguous shorthand such as Thai `ระหว่างนิ้ว`.
+
+Standalone lookup helpers can also call sync or async terminology hooks:
+
+```ts
+getBodySiteCode("clinic site", {
+  siteCodeMap: {
+    "clinic site": {
+      coding: {
+        system: "http://example.org/sites",
+        code: "CLINIC-SITE",
+        display: "Clinic site"
+      },
+      text: "clinic site"
+    }
+  }
+});
+
+await getBodySiteCodeAsync("remote site", {
+  siteCodeResolvers: async (request) => {
+    if (request.canonical !== "remote site") return undefined;
+    return {
+      coding: {
+        system: "http://example.org/sites",
+        code: "REMOTE-SITE",
+        display: "Remote site"
+      },
+      text: "remote site"
+    };
+  }
+});
+
+await getBodySiteTextAsync(
+  { system: "http://example.org/sites", code: "REMOTE-SITE" },
+  {
+    siteTextResolvers: async (request) =>
+      request.originalCoding.code === "REMOTE-SITE" ? "remote site" : undefined
+  }
+);
+```
+
 You can extend or replace the built-in codings via `ParseOptions`:
 
 ```ts
@@ -336,6 +507,7 @@ export interface SiteCodeLookupRequest {
   text: string;         // Brace-free, whitespace-collapsed site text
   normalized: string;   // Lower-case variant of `text`
   canonical: string;    // Normalized key for dictionary lookups
+  spatialRelation?: BodySiteSpatialRelation; // Parsed relation + target, when present
   isProbe: boolean;     // True when the sig used `{placeholder}` syntax
   inputText: string;    // Full sig string the parser received
   sourceText?: string;  // Substring extracted from `inputText`
@@ -361,6 +533,93 @@ export type SiteCodeSuggestionResolver = (
 
 Consumers that only need synchronous resolution can continue calling `parseSig`. If any synchronous resolver accidentally returns a Promise, an error is thrown with guidance to switch to `parseSigAsync`.
 
+#### Standalone body-site helper resolver signatures
+
+The standalone helper callbacks are intentionally smaller than parser callbacks
+because they only resolve one phrase or one code at a time.
+
+```ts
+export interface BodySiteLookupRequest {
+  originalText: string;
+  text: string;
+  normalized: string;
+  canonical: string;
+  bodySiteContext?: string;
+  spatialRelation?: BodySiteSpatialRelation;
+}
+
+export type BodySiteResolver = (
+  request: BodySiteLookupRequest
+) => BodySiteDefinition | null | undefined | Promise<BodySiteDefinition | null | undefined>;
+
+export interface BodySiteTextLookupRequest {
+  coding: BodySiteCode;         // decoded literal site when postcoordination is enabled
+  originalCoding: BodySiteCode; // original input coding/code
+  parsedPostcoordination?: {
+    type: "topographicalModifier" | "laterality" | "findingSite";
+    siteCode: string;
+    modifierCode?: string;
+    lateralityCode?: string;
+    focusCode?: string;
+  };
+}
+
+export type BodySiteTextResolver = (
+  request: BodySiteTextLookupRequest
+) => string | null | undefined | Promise<string | null | undefined>;
+```
+
+#### SNOMED finding-site postcoordination helpers
+
+When a PRN reason has a symptom plus site (for example `pain at abdomen`), the
+library can represent the coded symptom with a SNOMED finding-site expression.
+The helpers are exported for callers that need the same representation outside
+the parser.
+
+This is separate from body-site postcoordination. PRN findings use
+`363698007 | Finding site |`; spatial body-site phrases use
+`106233006 | Topographical modifier |`; laterality on body sites uses
+`272741003 | Laterality |`.
+
+```ts
+import {
+  buildSnomedBodySiteLateralityPostcoordinationCode,
+  buildSnomedFindingSiteCoding,
+  buildSnomedFindingSitePostcoordinationCode,
+  hasSnomedFindingSitePostcoordination
+} from "ezmedicationinput";
+
+buildSnomedBodySiteLateralityPostcoordinationCode("78883009", "24028007");
+// → "78883009:272741003=24028007"
+
+buildSnomedFindingSitePostcoordinationCode("22253000", "85562004");
+// → "22253000:363698007=85562004"
+
+hasSnomedFindingSitePostcoordination("22253000:363698007=85562004");
+// → true
+
+buildSnomedFindingSiteCoding({
+  focusCoding: {
+    system: "http://snomed.info/sct",
+    code: "22253000",
+    display: "Pain"
+  },
+  siteCoding: {
+    system: "http://snomed.info/sct",
+    code: "85562004",
+    display: "Hand"
+  },
+  display: "Pain at hand"
+});
+```
+
+The spatial site extension helpers are also exported:
+`buildBodySiteSpatialRelationExtension`,
+`buildBodySiteSpatialRelationExtensions`,
+`parseBodySiteSpatialRelationExtension`,
+`cloneBodySiteSpatialRelation`, and
+`BODY_SITE_SPATIAL_RELATION_EXTENSION_URL`.
+
 You can specify the number of times (total count) the medication is supposed to be used by ending with `for {number} times`, `x {number} doses`, or simply `x {number}`
 
 ### Advanced parsing options
@@ -368,8 +627,12 @@ You can specify the number of times (total count) the medication is supposed to
 `parseSig` accepts a `ParseOptions` object. Highlights:
 
 - `context`: optional medication context (dosage form, strength, container
-  metadata) used to infer default units when a sig omits explicit units. Pass
-  `null` to explicitly disable context-based inference.
+  metadata, and optional `bodySiteContext`) used to infer defaults and
+  disambiguate shorthand body-site phrases. Pass `null` to explicitly disable
+  context-based inference.
+- `context.bodySiteContext`: optional anatomical context for ambiguous site
+  shorthand. Example: Thai `ระหว่างนิ้ว` defaults to fingers, but resolves to
+  toes when `bodySiteContext` is `"feet"`, `"foot"`, or another foot/toe phrase.
 - `smartMealExpansion`: when `true`, generic AC/PC/C meal abbreviations and
   cadence-only instructions expand into concrete with-meal EventTiming
   combinations (e.g. `1x3` → breakfast/lunch/dinner). This also respects
@@ -462,6 +725,35 @@ const result = calculateTotalUnits({
 
 It can also handle strength-based conversions (e.g. calculating how many 100mL bottles are needed for a 500mg TID dose of a 250mg/5mL suspension).
 
+Natural SIG units are classified from `unit-terminology.json` instead of being treated as one physics-style unit enum. Parsed results expose `meta.normalized.unitKind` / `unitSemantics`, and callers can inspect the same vocabulary with `listDoseUnitTerminology()` or `getDoseUnitSemantics(unit)`.
+
+```ts
+const parsed = parseSig("apply 2 FTU to face twice daily");
+
+calculateTotalUnits({
+  dosage: parsed.fhir,
+  from: "2024-01-01T08:00:00Z",
+  durationValue: 7,
+  durationUnit: "d",
+  timeZone: "Asia/Bangkok"
+});
+
+// → { totalUnits: 28, totalApproximateQuantity: { value: 14, unit: "g", ... } }
+```
+
+Built-in approximations are intentionally conservative and overridable. Current defaults include `FTU -> 0.5 g`, `drop -> 0.05 mL`, `pea-sized amount -> 0.25 mL`, and `shot glass -> 29.5735 mL`; product/device-specific labels should pass `context.unitApproximationMap` when a better value is known. Package-level phrases such as `half bottle` can also be bridged to the inner amount by setting `context.packageUnit`, `containerValue`, and `containerUnit`.
+
+The terminology layer also classifies non-metric SIG units that should not be blindly converted:
+
+- `body_area_proxy`: `palm`, `handprint`, `% BSA`
+- `product_specific_amount`: `pea-sized amount`, `shot glass`, `finger length`, `dropperful`, `applicatorful`, `capful`, `scoop`
+- `device_actuation`: `puff`, `spray`, `pump`, `actuation`, `click`
+- `length_of_product`: `cm ribbon`, `inch ribbon`, `cm strip`, `cm line`, `inch line`
+- `counted_presentation`: `patch`, `ring`, `vial`, `ampule`, `nebule`, `respule`, `packet`, `sachet`, `stick-pack`, and similar package/presentation units
+- `infusion_rate`: `drop/min` / `gtt/min`, exposed as terminology but not parsed as `doseQuantity` until rate parsing and drop-factor conversion are modeled
+
+`calculateTotalUnits` counts presentation units such as patches and rings as discrete administrations. It does not invent gram/mL conversions for puffs, pumps, applicatorfuls, capfuls, ribbons, body-area proxies, clicks, or release-rate products unless the caller supplies product-specific context.
+
 ### Strength parsing
 
 Use `parseStrength` to normalize medication strength strings into FHIR-compliant **Quantity** or **Ratio** structures. It understands percentages, ratios, and composite strengths.

package/dist/advice.d.ts

@@ -13,4 +13,13 @@ export interface AdviceParseContext {
 }
 export declare function parseAdditionalInstructions(sourceText: string, span: TextRange, context?: AdviceParseContext): ParsedAdditionalInstruction[];
 export declare function findAdditionalInstructionDefinitionByCoding(system: string, code: string): AdditionalInstructionDefinition | undefined;
+export declare const __test__: {
+    createDefinitionFromSource(source: {
+        system?: string;
+        code: string;
+        display: string;
+        text: string;
+        thai: string;
+    }): AdditionalInstructionDefinition;
+};
 export declare function buildAdditionalInstructionFramesFromCoding(system: string, code: string, sourceText?: string, span?: TextRange): AdviceFrame[] | undefined;

package/dist/body-site-grammar.d.ts

@@ -0,0 +1,39 @@
+import { BodySiteDefinition, BodySiteSpatialRelation, FhirCoding } from "./types";
+export type BodySiteGrammarKind = "nominal" | "partitive" | "locative";
+export type BodySiteLocativeRelation = "behind" | "around" | "under" | "above" | "below" | "beneath" | "near" | "outside" | "inside" | "between";
+export interface BodySiteNominalFeatures {
+    kind: "nominal";
+    text: string;
+    canonical: string;
+    coding?: FhirCoding;
+    article: "definite" | "bare";
+}
+export interface BodySitePartitiveFeatures {
+    kind: "partitive";
+    part: string;
+    relationKey?: string;
+    whole: BodySiteNominalFeatures;
+}
+export interface BodySiteLocativeFeatures {
+    kind: "locative";
+    relation: BodySiteLocativeRelation;
+    target: BodySiteNominalFeatures | BodySitePartitiveFeatures;
+}
+export type BodySiteFeatureStructure = BodySiteNominalFeatures | BodySitePartitiveFeatures | BodySiteLocativeFeatures;
+export interface ResolvedBodySitePhrase {
+    lookupCanonical: string;
+    resolutionCanonical: string;
+    canonical: string;
+    displayText: string;
+    coding?: FhirCoding;
+    spatialRelation?: BodySiteSpatialRelation;
+    definition?: BodySiteDefinition;
+    features: BodySiteFeatureStructure;
+    englishObjectText: string;
+    preferredPreposition?: "to" | "at" | "in" | "into";
+}
+export interface BodySitePhraseContext {
+    bodySiteContext?: string;
+}
+export declare function lookupBodySiteDefinition(map: Record<string, BodySiteDefinition> | undefined, canonical: string): BodySiteDefinition | undefined;
+export declare function resolveBodySitePhrase(text: string, customSiteMap?: Record<string, BodySiteDefinition>, context?: BodySitePhraseContext): ResolvedBodySitePhrase | undefined;

package/dist/body-site-lookup.d.ts

@@ -0,0 +1,84 @@
+import { BodySiteCode, BodySiteDefinition, BodySiteSpatialRelation, FhirCoding } from "./types";
+export interface BodySiteLookupOptions {
+    siteCodeMap?: Record<string, BodySiteDefinition>;
+    siteCodeResolvers?: BodySiteResolver | BodySiteResolver[];
+    bodySiteContext?: string;
+    /**
+     * Defaults to true. When true, phrase-to-code lookup can return a
+     * SNOMED-coded topographical modifier expression for spatial body-site
+     * phrases that do not have a direct pre-coordinated body-site code.
+     */
+    postcoordination?: boolean;
+    limit?: number;
+}
+export interface BodySiteTextOptions {
+    siteCodeMap?: Record<string, BodySiteDefinition>;
+    siteTextResolvers?: BodySiteTextResolver | BodySiteTextResolver[];
+    system?: string;
+    /**
+     * Defaults to true. When true, SNOMED finding-site postcoordination strings
+     * such as "22253000:363698007=723979003" and topographical modifier
+     * expressions such as "69536005:106233006=261183002" are resolved.
+     */
+    postcoordination?: boolean;
+    parsePostcoordination?: boolean;
+}
+export interface BodySiteLookupResult {
+    text: string;
+    canonical: string;
+    lookupCanonical: string;
+    resolutionCanonical: string;
+    matchedText: string;
+    coding?: BodySiteCode;
+    spatialRelation?: BodySiteSpatialRelation;
+    definition?: BodySiteDefinition;
+    score: number;
+}
+export interface BodySiteLookupRequest {
+    originalText: string;
+    text: string;
+    normalized: string;
+    canonical: string;
+    bodySiteContext?: string;
+    spatialRelation?: BodySiteSpatialRelation;
+}
+export interface BodySiteTextLookupRequest {
+    coding: BodySiteCode;
+    originalCoding: BodySiteCode;
+    parsedPostcoordination?: {
+        type: "topographicalModifier" | "laterality" | "findingSite";
+        siteCode: string;
+        modifierCode?: string;
+        lateralityCode?: string;
+        focusCode?: string;
+    };
+}
+export type BodySiteResolver = (request: BodySiteLookupRequest) => BodySiteDefinition | null | undefined | Promise<BodySiteDefinition | null | undefined>;
+export type BodySiteTextResolver = (request: BodySiteTextLookupRequest) => string | null | undefined | Promise<string | null | undefined>;
+export interface BodySiteVocabularyOptions {
+    siteCodeMap?: Record<string, BodySiteDefinition>;
+    bodySiteContext?: string;
+    limit?: number;
+}
+export interface BodySiteGrammarVocabulary {
+    siteAnchors: string[];
+    siteSelfDisplayAnchors: string[];
+    locativeRelations: string[];
+    partitiveHeads: string[];
+    partitiveModifiers: string[];
+    partitiveConnectors: string[];
+    spatialRelationCodings: Record<string, FhirCoding>;
+}
+type BodySiteCodeInput = string | BodySiteCode | FhirCoding;
+export declare function buildBodySiteTopographicalModifierCoding(relation: BodySiteSpatialRelation | undefined, display?: string, options?: Pick<BodySiteLookupOptions, "postcoordination">): BodySiteCode | undefined;
+export declare function lookupBodySite(input: string, options?: BodySiteLookupOptions): BodySiteLookupResult | undefined;
+export declare function lookupBodySiteAsync(input: string, options?: BodySiteLookupOptions): Promise<BodySiteLookupResult | undefined>;
+export declare function getBodySiteCode(input: string, options?: BodySiteLookupOptions): BodySiteCode | undefined;
+export declare function getBodySiteCodeAsync(input: string, options?: BodySiteLookupOptions): Promise<BodySiteCode | undefined>;
+export declare function getBodySiteText(input: BodySiteCodeInput, options?: BodySiteTextOptions): string | undefined;
+export declare function getBodySiteTextAsync(input: BodySiteCodeInput, options?: BodySiteTextOptions): Promise<string | undefined>;
+export declare function suggestBodySites(input: string, options?: BodySiteLookupOptions): BodySiteLookupResult[];
+export declare function suggestBodySiteText(input: string, options?: BodySiteLookupOptions): string[];
+export declare function listSupportedBodySiteText(options?: BodySiteVocabularyOptions): string[];
+export declare function listSupportedBodySiteGrammar(): BodySiteGrammarVocabulary;
+export {};

package/dist/body-site-resolution.d.ts

@@ -0,0 +1,9 @@
+import { ParserState } from "./parser-state";
+import { FhirCoding } from "./types";
+export interface BodySiteResolutionCandidates {
+    canonicals: string[];
+    codings: FhirCoding[];
+    normalizedSiteText: string;
+    normalizedSiteCodingDisplay: string;
+}
+export declare function collectParsedBodySiteCandidates(internal: ParserState): BodySiteResolutionCandidates;

package/dist/body-site-spatial.d.ts

@@ -0,0 +1,6 @@
+import { BodySiteSpatialRelation, FhirCodeableConcept, FhirExtension } from "./types";
+export declare const BODY_SITE_SPATIAL_RELATION_EXTENSION_URL = "urn:ezmedicationinput:body-site-spatial-relation";
+export declare function cloneBodySiteSpatialRelation(relation: BodySiteSpatialRelation | undefined): BodySiteSpatialRelation | undefined;
+export declare function buildBodySiteSpatialRelationExtension(relation: BodySiteSpatialRelation | undefined): FhirExtension | undefined;
+export declare function buildBodySiteSpatialRelationExtensions(relation: BodySiteSpatialRelation | undefined): FhirExtension[] | undefined;
+export declare function parseBodySiteSpatialRelationExtension(concept: FhirCodeableConcept | undefined): BodySiteSpatialRelation | undefined;

package/dist/clause-tail-grammar.d.ts

@@ -0,0 +1,18 @@
+import { AdviceParseContext, ParsedAdditionalInstruction } from "./advice";
+import { Token } from "./parser-state";
+import { TextRange } from "./types";
+export interface TailTokenSegment {
+    startOffset: number;
+    tokens: Token[];
+    leadingSeparatorTokens: Token[];
+    range: TextRange;
+    text: string;
+}
+export interface ParsedInstructionTokenSegment {
+    segment: TailTokenSegment;
+    instructions: ParsedAdditionalInstruction[];
+}
+export declare function splitTailTokenSegments(input: string, tokens: Token[]): TailTokenSegment[];
+export declare function findStructuredInstructionTailOffset(input: string, tokens: Token[], context: AdviceParseContext): number | undefined;
+export declare function hasInstructionBoundaryBeforeToken(tokens: Token[], tokenIndex: number): boolean;
+export declare function parseInstructionTokenSegments(input: string, tokens: Token[], context: AdviceParseContext): ParsedInstructionTokenSegment[];

package/dist/fhir-translations.d.ts

@@ -1,5 +1,8 @@
-import { FhirPrimitiveElement } from "./types";
+import { FhirExtension, FhirPrimitiveElement } from "./types";
 export declare const FHIR_TRANSLATION_EXTENSION_URL = "http://hl7.org/fhir/StructureDefinition/translation";
+export declare function cloneI18nRecord(i18n: Record<string, string> | undefined): Record<string, string> | undefined;
+export declare function cloneExtension(extension: FhirExtension): FhirExtension;
+export declare function cloneExtensions(extensions: FhirExtension[] | undefined): FhirExtension[] | undefined;
 export declare function clonePrimitiveElement(element: FhirPrimitiveElement | undefined): FhirPrimitiveElement | undefined;
 export declare function buildTranslationPrimitiveElement(translations: Record<string, string> | undefined, base?: FhirPrimitiveElement): FhirPrimitiveElement | undefined;
 export declare function getPrimitiveTranslation(element: FhirPrimitiveElement | undefined, locale: string | undefined): string | undefined;

package/dist/fhir.d.ts

@@ -1,6 +1,14 @@
 import { ParserState } from "./parser-state";
 import { CanonicalSigClause, FhirDosage } from "./types";
-export declare function canonicalToFhir(clause: CanonicalSigClause, textOverride?: string): FhirDosage;
+export interface FhirProjectionOptions {
+    /**
+     * Defaults to true. When true, structured spatial body-site phrases such as
+     * "top of head" can emit a SNOMED topographical modifier expression in
+     * Dosage.site.coding while preserving the spatial-relation extension.
+     */
+    bodySitePostcoordination?: boolean;
+}
+export declare function canonicalToFhir(clause: CanonicalSigClause, textOverride?: string, options?: FhirProjectionOptions): FhirDosage;
 export declare function toFhir(state: ParserState): FhirDosage;
 export declare function canonicalFromFhir(dosage: FhirDosage): CanonicalSigClause;
 export declare function parserStateFromFhir(dosage: FhirDosage): ParserState;

package/dist/hpsg/chart.d.ts

@@ -0,0 +1,14 @@
+import { Token } from "../parser-state";
+import { HpsgGrammar, HpsgSign } from "./signature";
+export interface HpsgChartContext {
+    tokens: Token[];
+}
+export interface HpsgChartOptions {
+    limit?: number;
+    maxIterations?: number;
+}
+export interface HpsgChartParseResult {
+    signs: HpsgSign[];
+    best?: HpsgSign;
+}
+export declare function parseHpsgChart<TContext extends HpsgChartContext>(context: TContext, grammar: HpsgGrammar<TContext>, options?: HpsgChartOptions): HpsgChartParseResult;

package/dist/hpsg/clause-parser.d.ts

@@ -0,0 +1,3 @@
+import { HpsgSign } from "./signature";
+import { HpsgClauseContext } from "./rule-context";
+export declare function parseHpsgClause(context: HpsgClauseContext): HpsgSign | undefined;

package/dist/hpsg/defaults.d.ts

@@ -0,0 +1,9 @@
+import { ParserState } from "../parser-state";
+import { ParseOptions, RouteCode } from "../types";
+export interface HpsgDefaultConstraintDeps {
+    setRoute: (state: ParserState, code: RouteCode, text?: string) => void;
+}
+export declare function applyHpsgDefaultConstraints(state: ParserState, tokens: readonly {
+    lower: string;
+    index: number;
+}[], options: ParseOptions | undefined, deps: HpsgDefaultConstraintDeps): void;