ezmedicationinput 0.1.45 → 0.1.46

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

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;

package/dist/hpsg/lexical-classes.d.ts

@@ -0,0 +1,89 @@
+import { EventTiming, FhirCoding } from "../types";
+type MealRelation = "before" | "after" | "with";
+type MealTimingByRelation = Map<MealRelation, Map<EventTiming, EventTiming>>;
+type BodySiteFeatureKind = "nominal" | "partitive" | "locative";
+type CompoundDoseUnit = {
+    head: string;
+    tails: string[];
+    unit: string;
+};
+export declare const SITE_ANCHORS: Set<string>;
+export declare const SITE_SELF_DISPLAY_ANCHORS: Set<string>;
+export declare const SITE_FILLERS: Set<string>;
+export declare const BODY_SITE_LOCATIVE_RELATIONS: Set<string>;
+export declare const BODY_SITE_LOCATIVE_RENDER_PREPOSITIONS: Map<string, string>;
+export declare const BODY_SITE_SPATIAL_RELATION_CODINGS: Map<string, FhirCoding>;
+export declare const BODY_SITE_PARTITIVE_HEADS: Set<string>;
+export declare const BODY_SITE_PARTITIVE_MODIFIERS: Set<string>;
+export declare const BODY_SITE_PARTITIVE_CONNECTORS: Set<string>;
+export declare const BODY_SITE_BARE_NOMINAL_PREFIXES: Set<string>;
+export declare const OTIC_SITE_WORDS: Set<string>;
+export declare const OPHTHALMIC_SITE_WORDS: Set<string>;
+export declare const NASAL_SITE_WORDS: Set<string>;
+export declare const BODY_SITE_ADJECTIVE_SUFFIXES: readonly string[];
+export declare const BODY_SITE_DISPLAY_PENALTY_WORDS: Set<string>;
+export declare const BODY_SITE_FEATURE_SCORE_BONUS: Map<BodySiteFeatureKind, number>;
+export declare const CONNECTORS: Set<string>;
+export declare const ROUTE_SITE_PREPOSITIONS: Set<string>;
+export declare const SITE_DISPLAY_FILLERS: Set<string>;
+export declare const NON_SITE_ANCHORED_PHRASES: Set<string>;
+export declare const EXTERNAL_SITE_LOCATIVE_PREFIXES: Set<string>;
+export declare const ROUTE_BLOCKED_BY_FOLLOWING_PARTITIVE_HEADS: Set<string>;
+export declare const PRN_LEADS: Set<string>;
+export declare const PRN_REASON_LEAD_INS: Set<string>;
+export declare const PRN_STANDALONE_REASON_LEADS: Set<string>;
+export declare const PRN_REASON_MULTIWORD_LEAD_INS: Set<string>;
+export declare const PRN_REASON_SITE_CONNECTORS: Set<string>;
+export declare const PRN_REASON_COORDINATORS: Set<string>;
+export declare const PRN_CONDITIONAL_SITE_BOUNDARY_ANCHORS: Set<string>;
+export declare const PRN_PREDICATE_REASON_NORMALIZATIONS: Map<string, string>;
+export declare const PRN_GENERIC_LOCATED_HEADS: Map<string, string>;
+export declare const PRN_DEFAULT_SITE_CONNECTOR: string;
+export declare const PRN_COMPACT_REASON_SEPARATORS: Set<string>;
+export declare const SITE_ROUTE_HINTS_ALLOWED_IN_GRAMMAR: Set<import("../types").SNOMEDCTRouteCodes>;
+export declare const PRODUCT_METHOD_TEXT: Record<string, Partial<Record<string, string>>>;
+export declare const PRODUCT_METHOD_THAI: Record<string, string>;
+export declare const COMPOUND_DOSE_UNITS: CompoundDoseUnit[];
+export declare const MILLION_DOSE_MULTIPLIER_TOKENS: Set<string>;
+export declare const SCHEDULE_UNIT_SEPARATOR_TOKENS: Set<string>;
+export declare const COMPACT_LIST_SEPARATORS: Set<string>;
+export declare const EVERY_INTERVAL_TOKENS_DATA: Set<string>;
+export declare const COUNT_MARKER_TOKENS_DATA: Set<string>;
+export declare const COUNT_CONNECTOR_WORDS_DATA: Set<string>;
+export declare const FREQUENCY_SIMPLE_WORDS_DATA: Record<string, number>;
+export declare const FREQUENCY_NUMBER_WORDS_DATA: Record<string, number>;
+export declare const FREQUENCY_TIMES_WORDS_DATA: Set<string>;
+export declare const FREQUENCY_CONNECTOR_WORDS_DATA: Set<string>;
+export declare const FREQUENCY_ADVERB_UNITS_DATA: Map<string, string>;
+export declare const INTERVAL_UNIT_TOKENS_DATA: Map<string, string>;
+export declare const WORKFLOW_START_WORDS: Set<string>;
+export declare const WORKFLOW_NOUNS: Set<string>;
+export declare const ANTE_MERIDIEM_TOKENS: Set<string>;
+export declare const POST_MERIDIEM_TOKENS: Set<string>;
+export declare const MERIDIEM_TOKENS: Set<string>;
+export declare const LIST_SEPARATORS: Set<string>;
+export declare const MEDICATION_OBJECT_FILLERS: Set<string>;
+export declare const CLOCK_LEAD_TOKENS: Set<string>;
+export declare const EVENT_PREPOSITIONS: Set<string>;
+export declare const EVENT_ARTICLE_TOKENS: Set<string>;
+export declare const FIXED_EVENT_PHRASES: Map<string, EventTiming>;
+export declare const MEAL_RELATION_BY_TOKEN: Map<string, MealRelation>;
+export declare const MEAL_TIMING_BY_RELATION: MealTimingByRelation;
+export declare const SLEEP_EVENT_ALIASES: Set<string>;
+export declare const WAKE_EVENT_ALIASES: Set<string>;
+export declare const FOOD_EVENT_ALIASES: Set<string>;
+export declare const DAY_RANGE_CONNECTORS: Set<string>;
+export declare const RANGE_CONNECTORS: Set<string>;
+export declare const DURATION_LEAD_TOKENS: Set<string>;
+export declare const INSTRUCTION_LEADING_SEPARATORS: Set<string>;
+export declare const INSTRUCTION_START_WORDS: Set<string>;
+export declare const WORKFLOW_CONTINUATION_LICENSES: Set<string>;
+export declare const AS_NEEDED_LEAD_PHRASES: Set<string>;
+export declare const PRN_BREAKING_COORDINATORS: Set<string>;
+export declare const EYE_SITE_ABBREVIATIONS: Set<string>;
+export declare const NON_OCULAR_DOSE_UNITS: Set<string>;
+export declare const OCULAR_ROUTE_CODES: Set<import("../types").SNOMEDCTRouteCodes>;
+export declare const HARD_SEGMENT_BOUNDARY_TOKENS: Set<string>;
+export declare const CLAUSE_LEAD_WORDS: Set<string>;
+export declare const LATERAL_MODIFIER_WORDS: Set<string>;
+export {};

package/dist/hpsg/method-lexicon.d.ts

@@ -0,0 +1,13 @@
+import { FhirCoding } from "../types";
+export declare enum MethodAction {
+    Administer = "administer",
+    Apply = "apply",
+    Insert = "insert",
+    Instill = "instill",
+    Spray = "spray",
+    Swallow = "swallow",
+    Wash = "wash"
+}
+export declare const METHOD_ACTION_BY_VERB: Record<string, MethodAction>;
+export declare const METHOD_CODING_BY_ACTION: Record<MethodAction, FhirCoding>;
+export declare function cloneMethodCoding(coding: FhirCoding | undefined): FhirCoding | undefined;

package/dist/hpsg/projection.d.ts

@@ -0,0 +1,12 @@
+import { ParserState, Token } from "../parser-state";
+import { EventTiming, FhirDayOfWeek, RouteCode } from "../types";
+import { HpsgSign } from "./signature";
+export interface HpsgProjectionDeps {
+    addDayOfWeekList: (state: ParserState, days: FhirDayOfWeek[]) => void;
+    addWhen: (target: EventTiming[], whenCode: EventTiming) => void;
+    markToken: (state: ParserState, token: Token) => void;
+    recordEvidence: (state: ParserState, rule: string, startIndex: number, endIndex: number) => void;
+    refreshMethodSurface: (state: ParserState) => void;
+    setRoute: (state: ParserState, code: RouteCode, text?: string) => void;
+}
+export declare function projectHpsgSignToState(sign: HpsgSign, state: ParserState, tokens: Token[], deps: HpsgProjectionDeps): void;