ezmedicationinput 0.1.43 → 0.1.44

package/dist/ir.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCanonicalSigClauses = buildCanonicalSigClauses;
+exports.shiftCanonicalSigClauses = shiftCanonicalSigClauses;
+function computeTrimmedInputRange(input) {
+    var _a;
+    if (!input) {
+        return undefined;
+    }
+    const start = input.search(/\S/);
+    if (start === -1) {
+        return undefined;
+    }
+    let end = input.length;
+    while (end > start && /\s/.test((_a = input[end - 1]) !== null && _a !== void 0 ? _a : "")) {
+        end -= 1;
+    }
+    return { start, end };
+}
+function clampConfidence(value) {
+    if (value < 0) {
+        return 0;
+    }
+    if (value > 1) {
+        return 1;
+    }
+    return Number(value.toFixed(2));
+}
+function cloneCoding(coding) {
+    if (!(coding === null || coding === void 0 ? void 0 : coding.code) && !(coding === null || coding === void 0 ? void 0 : coding.display) && !(coding === null || coding === void 0 ? void 0 : coding.system)) {
+        return undefined;
+    }
+    return {
+        code: coding.code,
+        display: coding.display,
+        system: coding.system
+    };
+}
+function cloneAdditionalInstruction(instruction) {
+    return {
+        text: instruction.text,
+        coding: cloneCoding(instruction.coding),
+        frames: instruction.frames ? [...instruction.frames] : undefined
+    };
+}
+function buildSourceSpan(input, start, end, tokenIndices) {
+    return {
+        start,
+        end,
+        text: input.slice(start, end),
+        tokenIndices: (tokenIndices === null || tokenIndices === void 0 ? void 0 : tokenIndices.length) ? [...tokenIndices] : undefined
+    };
+}
+function buildRangeSourceSpan(input, range, tokenIndices) {
+    const safeRange = range !== null && range !== void 0 ? range : { start: 0, end: input.length };
+    return buildSourceSpan(input, safeRange.start, safeRange.end, tokenIndices);
+}
+function spanFromTokenIndices(input, tokens, tokenIndices) {
+    let start;
+    let end;
+    const resolvedIndices = [];
+    for (const tokenIndex of tokenIndices) {
+        const token = tokens[tokenIndex];
+        if (!token) {
+            continue;
+        }
+        resolvedIndices.push(tokenIndex);
+        start = start === undefined ? token.sourceStart : Math.min(start, token.sourceStart);
+        end = end === undefined ? token.sourceEnd : Math.max(end, token.sourceEnd);
+    }
+    if (start === undefined || end === undefined) {
+        return undefined;
+    }
+    return buildSourceSpan(input, start, end, resolvedIndices);
+}
+function buildEvidence(rule, span, note, score) {
+    if (!span) {
+        return [];
+    }
+    return [
+        {
+            rule,
+            spans: [
+                Object.assign(Object.assign({}, span), { tokenIndices: span.tokenIndices ? [...span.tokenIndices] : undefined })
+            ],
+            note,
+            score
+        }
+    ];
+}
+function collectLeftoverSpans(internal) {
+    const groups = [];
+    let current = [];
+    const flush = () => {
+        if (!current.length) {
+            return;
+        }
+        const span = spanFromTokenIndices(internal.input, internal.tokens, current);
+        if (span) {
+            groups.push(span);
+        }
+        current = [];
+    };
+    for (const token of internal.tokens) {
+        if (internal.consumed.has(token.index)) {
+            flush();
+            continue;
+        }
+        if (current.length > 0 && token.index !== current[current.length - 1] + 1) {
+            flush();
+        }
+        current.push(token.index);
+    }
+    flush();
+    return groups;
+}
+function findTokensByLower(internal, matcher) {
+    const matches = [];
+    for (const token of internal.tokens) {
+        if (!internal.consumed.has(token.index)) {
+            continue;
+        }
+        if (matcher(token.lower)) {
+            matches.push(token.index);
+        }
+    }
+    return matches;
+}
+function buildClauseConfidence(internal, leftovers) {
+    let confidence = 1;
+    confidence -= Math.min(0.4, leftovers.length * 0.12);
+    confidence -= Math.min(0.2, internal.warnings.length * 0.08);
+    if (!internal.routeCode && !internal.routeText && !internal.siteText && !internal.timingCode) {
+        confidence -= 0.05;
+    }
+    return clampConfidence(confidence);
+}
+function buildCanonicalSigClauses(internal) {
+    return internal.clauses;
+}
+function shiftCanonicalSigClauses(clauses, offset) {
+    var _a, _b, _c, _d, _e;
+    for (const clause of clauses) {
+        if (clause.span) {
+            clause.span = {
+                start: clause.span.start + offset,
+                end: clause.span.end + offset
+            };
+        }
+        clause.raw = Object.assign(Object.assign({}, clause.raw), { start: clause.raw.start + offset, end: clause.raw.end + offset });
+        for (const leftover of clause.leftovers) {
+            leftover.start += offset;
+            leftover.end += offset;
+        }
+        const shiftEvidenceSpans = (evidence) => {
+            if (!evidence) {
+                return;
+            }
+            for (const entry of evidence) {
+                for (const span of entry.spans) {
+                    span.start += offset;
+                    span.end += offset;
+                }
+            }
+        };
+        shiftEvidenceSpans(clause.evidence);
+        shiftEvidenceSpans((_a = clause.dose) === null || _a === void 0 ? void 0 : _a.evidence);
+        shiftEvidenceSpans((_b = clause.route) === null || _b === void 0 ? void 0 : _b.evidence);
+        shiftEvidenceSpans((_c = clause.site) === null || _c === void 0 ? void 0 : _c.evidence);
+        shiftEvidenceSpans((_d = clause.schedule) === null || _d === void 0 ? void 0 : _d.evidence);
+        shiftEvidenceSpans((_e = clause.prn) === null || _e === void 0 ? void 0 : _e.evidence);
+        if (clause.additionalInstructions) {
+            for (const instruction of clause.additionalInstructions) {
+                shiftEvidenceSpans(instruction.evidence);
+            }
+        }
+    }
+}

package/dist/lexer/lex.d.ts

@@ -0,0 +1,2 @@
+import { LexToken } from "./token-types";
+export declare function lexInput(input: string): LexToken[];

package/dist/lexer/lex.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lexInput = lexInput;
+const maps_1 = require("../maps");
+const token_types_1 = require("./token-types");
+const surface_1 = require("./surface");
+const PER_SLASH_UNITS = new Set([
+    "d",
+    "day",
+    "days",
+    "wk",
+    "w",
+    "week",
+    "weeks",
+    "mo",
+    "month",
+    "months",
+    "hr",
+    "hrs",
+    "hour",
+    "hours",
+    "h",
+    "min",
+    "mins",
+    "minute",
+    "minutes"
+]);
+const COMPACT_DISCRETE_UNITS_PATTERN = /^(tab|tabs|tablet|tablets|cap|caps|capsule|capsules|mg|mcg|ml|g|drops|drop|puff|puffs|spray|sprays|patch|patches)$/i;
+function classifyLexKind(value) {
+    const lower = value.toLowerCase();
+    if (/^[0-9]+(?:\.[0-9]+)?$/.test(lower)) {
+        return { kind: token_types_1.LexKind.Number, value: parseFloat(value) };
+    }
+    const rangeMatch = lower.match(/^([0-9]+(?:\.[0-9]+)?)-([0-9]+(?:\.[0-9]+)?)$/);
+    if (rangeMatch) {
+        return {
+            kind: token_types_1.LexKind.NumberRange,
+            low: parseFloat(rangeMatch[1]),
+            high: parseFloat(rangeMatch[2])
+        };
+    }
+    if (/^[0-9]+(?:st|nd|rd|th)$/i.test(lower)) {
+        return { kind: token_types_1.LexKind.Ordinal };
+    }
+    if (/^@?\d{1,2}([:.]\d{2})?\s*(am|pm)?$/i.test(lower) ||
+        /^\d{1,2}\s*(am|pm)$/i.test(lower)) {
+        return { kind: token_types_1.LexKind.TimeLike };
+    }
+    if (lower === "," || lower === ";") {
+        return { kind: token_types_1.LexKind.Separator };
+    }
+    if (lower === "@" || lower === "&" || lower === "+") {
+        return { kind: token_types_1.LexKind.Punctuation };
+    }
+    return { kind: token_types_1.LexKind.Word };
+}
+function isNumericText(value) {
+    return /^[0-9]+(?:\.[0-9]+)?$/.test(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasWhitespaceAround(surface, input) {
+    const before = surface.start > 0 ? input[surface.start - 1] : "";
+    const after = surface.end < input.length ? input[surface.end] : "";
+    return /\s/.test(before) && /\s/.test(after);
+}
+function isSurfaceText(surface) {
+    return Boolean(surface && surface.kind === token_types_1.SurfaceTokenKind.Text);
+}
+function buildToken(text, surfaces, input, start, end, derived) {
+    const first = surfaces[0];
+    const last = surfaces[surfaces.length - 1];
+    const sourceStart = start !== null && start !== void 0 ? start : first.start;
+    const sourceEnd = end !== null && end !== void 0 ? end : last.end;
+    const classified = classifyLexKind(text);
+    return {
+        original: text,
+        lower: text.toLowerCase(),
+        index: -1,
+        kind: classified.kind,
+        value: classified.value,
+        low: classified.low,
+        high: classified.high,
+        sourceStart,
+        sourceEnd,
+        surfaceIndices: surfaces.map((surface) => surface.index),
+        sourceText: input.slice(sourceStart, sourceEnd),
+        derived
+    };
+}
+function pushIfPresent(values, value) {
+    if (value !== undefined) {
+        values.push(value);
+    }
+}
+function buildFractionPartToken(part, surface, input, start, end) {
+    if (!part || !surface || start === undefined || end === undefined || end <= start) {
+        return undefined;
+    }
+    return buildToken(part, [surface], input, start, end, true);
+}
+function buildFractionTokens(left, slash, right, input) {
+    const leftMatch = left.lower.match(/^([a-z]*)([0-9]+(?:\.[0-9]+)?)$/i);
+    const rightMatch = right.lower.match(/^([0-9]+(?:\.[0-9]+)?)([a-z]*)$/i);
+    if (!leftMatch || !rightMatch) {
+        return undefined;
+    }
+    const numerator = parseFloat(leftMatch[2]);
+    const denominator = parseFloat(rightMatch[1]);
+    if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator === 0) {
+        return undefined;
+    }
+    const tokens = [];
+    const prefix = leftMatch[1];
+    const suffix = rightMatch[2];
+    const valueText = (numerator / denominator).toString();
+    pushIfPresent(tokens, buildFractionPartToken(prefix, left, input, left.start, left.start + prefix.length));
+    tokens.push(buildToken(valueText, [left, slash, right], input, undefined, undefined, true));
+    pushIfPresent(tokens, buildFractionPartToken(suffix, right, input, right.end - suffix.length, right.end));
+    return tokens;
+}
+function pushSplitParts(output, surface, parts, input) {
+    let searchOffset = 0;
+    const sourceLower = surface.lower;
+    for (const part of parts) {
+        const lowerPart = part.toLowerCase();
+        const pattern = new RegExp(escapeRegExp(lowerPart), "i");
+        const relative = sourceLower.slice(searchOffset).search(pattern);
+        if (relative === -1) {
+            output.push(buildToken(part, [surface], input, undefined, undefined, true));
+            continue;
+        }
+        const partStart = surface.start + searchOffset + relative;
+        const partEnd = partStart + part.length;
+        searchOffset = partEnd - surface.start;
+        output.push(buildToken(part, [surface], input, partStart, partEnd, part !== surface.original ? true : undefined));
+    }
+}
+function splitCompactToken(token) {
+    if (/^[0-9]+(?:\.[0-9]+)?$/.test(token)) {
+        return [token];
+    }
+    const compactTimesWord = token.match(/^([0-9]+(?:\.[0-9]+)?[x*])([A-Za-z]+)$/i);
+    if (compactTimesWord) {
+        return [compactTimesWord[1], compactTimesWord[2]];
+    }
+    const compactPoMeal = token.match(/^(po)(ac|pc|c)$/i);
+    if (compactPoMeal) {
+        return [compactPoMeal[1], compactPoMeal[2]];
+    }
+    if (/^[A-Za-z]+$/.test(token)) {
+        return [token];
+    }
+    const qRange = token.match(/^q([0-9]+(?:\.[0-9]+)?)-([0-9]+(?:\.[0-9]+)?)([A-Za-z]+)$/i);
+    if (qRange) {
+        return [token.charAt(0), `${qRange[1]}-${qRange[2]}`, qRange[3]];
+    }
+    const match = token.match(/^([0-9]+(?:\.[0-9]+)?)([A-Za-z]+)$/);
+    if (match) {
+        const [, numberPart, suffix] = match;
+        if (/^(st|nd|rd|th)$/i.test(suffix)) {
+            return [token];
+        }
+        const compactPoMealUnit = suffix.match(/^(po)(ac|pc|c)$/i);
+        if (compactPoMealUnit) {
+            return [numberPart, compactPoMealUnit[1], compactPoMealUnit[2]];
+        }
+        if (!/^x\d+/i.test(suffix) && !/^q\d+/i.test(suffix)) {
+            return [numberPart, suffix];
+        }
+    }
+    return [token];
+}
+function tryDayRangeToken(surfaces, index, input) {
+    const start = surfaces[index];
+    const hyphen = surfaces[index + 1];
+    const end = surfaces[index + 2];
+    if (!isSurfaceText(start) ||
+        !hyphen ||
+        hyphen.original !== "-" ||
+        !isSurfaceText(end) ||
+        !maps_1.DAY_OF_WEEK_TOKENS[start.lower] ||
+        !maps_1.DAY_OF_WEEK_TOKENS[end.lower]) {
+        return undefined;
+    }
+    return {
+        token: buildToken(`${start.original}-${end.original}`, [start, hyphen, end], input, undefined, undefined, true),
+        nextIndex: index + 3
+    };
+}
+function tryQRangeToken(surfaces, index, input) {
+    const start = surfaces[index];
+    const hyphen = surfaces[index + 1];
+    const end = surfaces[index + 2];
+    if (!isSurfaceText(start) || !hyphen || hyphen.original !== "-" || !isSurfaceText(end)) {
+        return undefined;
+    }
+    const startMatch = start.lower.match(/^q([0-9]+(?:\.[0-9]+)?)$/);
+    const endMatch = end.lower.match(/^([0-9]+(?:\.[0-9]+)?)([a-z]+)$/);
+    if (!startMatch || !endMatch) {
+        return undefined;
+    }
+    return {
+        token: buildToken(`q${startMatch[1]}-${endMatch[1]}${endMatch[2]}`, [start, hyphen, end], input, undefined, undefined, true),
+        nextIndex: index + 3
+    };
+}
+function tryNumericRangeToken(surfaces, index, input) {
+    const start = surfaces[index];
+    const hyphen = surfaces[index + 1];
+    const end = surfaces[index + 2];
+    if (!isSurfaceText(start) ||
+        !hyphen ||
+        hyphen.original !== "-" ||
+        !isSurfaceText(end) ||
+        !isNumericText(start.lower) ||
+        !isNumericText(end.lower)) {
+        return undefined;
+    }
+    return {
+        token: buildToken(`${start.original}-${end.original}`, [start, hyphen, end], input, undefined, undefined, true),
+        nextIndex: index + 3
+    };
+}
+function trySlashUnitExpansion(surfaces, index, input) {
+    const valueToken = surfaces[index];
+    const slash = surfaces[index + 1];
+    const unitToken = surfaces[index + 2];
+    if (!isSurfaceText(valueToken) ||
+        !slash ||
+        slash.original !== "/" ||
+        !isSurfaceText(unitToken) ||
+        !isNumericText(valueToken.lower) ||
+        !PER_SLASH_UNITS.has(unitToken.lower)) {
+        return undefined;
+    }
+    return {
+        tokens: [
+            buildToken(valueToken.original, [valueToken], input),
+            buildToken("per", [slash], input, slash.start, slash.end, true),
+            buildToken(unitToken.original, [unitToken], input)
+        ],
+        nextIndex: index + 3
+    };
+}
+function tryFractionToken(surfaces, index, input) {
+    const left = surfaces[index];
+    const slash = surfaces[index + 1];
+    const right = surfaces[index + 2];
+    if (!isSurfaceText(left) || !slash || slash.original !== "/" || !isSurfaceText(right)) {
+        return undefined;
+    }
+    const tokens = buildFractionTokens(left, slash, right, input);
+    if (!tokens) {
+        return undefined;
+    }
+    return {
+        tokens,
+        nextIndex: index + 3
+    };
+}
+function tryTimeLikeToken(surfaces, index, input) {
+    const hour = surfaces[index];
+    const separator = surfaces[index + 1];
+    const minute = surfaces[index + 2];
+    if (!isSurfaceText(hour) ||
+        !separator ||
+        (separator.original !== ":" && separator.original !== ".") ||
+        !isSurfaceText(minute) ||
+        separator.start !== hour.end ||
+        separator.end !== minute.start ||
+        !/^\d{1,2}$/.test(hour.lower) ||
+        !/^\d{2}$/.test(minute.lower)) {
+        return undefined;
+    }
+    return {
+        token: buildToken(`${hour.original}${separator.original}${minute.original}`, [hour, separator, minute], input, undefined, undefined, true),
+        nextIndex: index + 3
+    };
+}
+function pushTextToken(output, surface, input) {
+    const slashUnitMatch = surface.original.match(/^([0-9]+(?:\.[0-9]+)?)\/(d|day|days|wk|w|week|weeks|mo|month|months|hr|hrs|hour|hours|h|min|mins|minute|minutes)$/i);
+    if (slashUnitMatch) {
+        const slashIndex = surface.original.indexOf("/");
+        const valuePart = slashUnitMatch[1];
+        const unitPart = slashUnitMatch[2];
+        output.push(buildToken(valuePart, [surface], input, surface.start, surface.start + valuePart.length, true));
+        output.push(buildToken("per", [surface], input, surface.start + slashIndex, surface.start + slashIndex + 1, true));
+        output.push(buildToken(unitPart, [surface], input, surface.end - unitPart.length, surface.end, true));
+        return;
+    }
+    const fractionMatch = surface.lower.match(/^([a-z]*)([0-9]+(?:\.[0-9]+)?)\/([0-9]+(?:\.[0-9]+)?)([a-z]*)$/i);
+    if (fractionMatch) {
+        const slashIndex = surface.original.indexOf("/");
+        const left = {
+            original: surface.original.slice(0, slashIndex),
+            lower: surface.lower.slice(0, slashIndex),
+            index: surface.index,
+            kind: surface.kind,
+            start: surface.start,
+            end: surface.start + slashIndex
+        };
+        const slash = {
+            original: "/",
+            lower: "/",
+            index: surface.index,
+            kind: token_types_1.SurfaceTokenKind.Punctuation,
+            start: surface.start + slashIndex,
+            end: surface.start + slashIndex + 1
+        };
+        const right = {
+            original: surface.original.slice(slashIndex + 1),
+            lower: surface.lower.slice(slashIndex + 1),
+            index: surface.index,
+            kind: surface.kind,
+            start: surface.start + slashIndex + 1,
+            end: surface.end
+        };
+        const tokens = buildFractionTokens(left, slash, right, input);
+        if (tokens) {
+            output.push(...tokens);
+            return;
+        }
+    }
+    const compactDiscrete = surface.original.match(/^([0-9]+(?:\.[0-9]+)?)([A-Za-z]+)$/);
+    if (compactDiscrete && COMPACT_DISCRETE_UNITS_PATTERN.test(compactDiscrete[2])) {
+        pushSplitParts(output, surface, [compactDiscrete[1], compactDiscrete[2]], input);
+        return;
+    }
+    pushSplitParts(output, surface, splitCompactToken(surface.original), input);
+}
+function lexInput(input) {
+    const surfaces = (0, surface_1.scanSurfaceTokens)(input);
+    const output = [];
+    let index = 0;
+    while (index < surfaces.length) {
+        const current = surfaces[index];
+        const dayRange = tryDayRangeToken(surfaces, index, input);
+        if (dayRange) {
+            output.push(dayRange.token);
+            index = dayRange.nextIndex;
+            continue;
+        }
+        const qRange = tryQRangeToken(surfaces, index, input);
+        if (qRange) {
+            output.push(qRange.token);
+            index = qRange.nextIndex;
+            continue;
+        }
+        const numericRange = tryNumericRangeToken(surfaces, index, input);
+        if (numericRange) {
+            output.push(numericRange.token);
+            index = numericRange.nextIndex;
+            continue;
+        }
+        const slashUnit = trySlashUnitExpansion(surfaces, index, input);
+        if (slashUnit) {
+            output.push(...slashUnit.tokens);
+            index = slashUnit.nextIndex;
+            continue;
+        }
+        const fraction = tryFractionToken(surfaces, index, input);
+        if (fraction) {
+            output.push(...fraction.tokens);
+            index = fraction.nextIndex;
+            continue;
+        }
+        const timeLike = tryTimeLikeToken(surfaces, index, input);
+        if (timeLike) {
+            output.push(timeLike.token);
+            index = timeLike.nextIndex;
+            continue;
+        }
+        if (current.kind === token_types_1.SurfaceTokenKind.Separator) {
+            if (current.original === "," || current.original === ";") {
+                output.push(buildToken(current.original, [current], input));
+            }
+            index += 1;
+            continue;
+        }
+        if (current.kind === token_types_1.SurfaceTokenKind.Punctuation) {
+            if (current.original === "-" && hasWhitespaceAround(current, input)) {
+                output.push(buildToken(";", [current], input, current.start, current.end, true));
+            }
+            else if (current.original === "@" ||
+                current.original === "&" ||
+                current.original === "+") {
+                output.push(buildToken(current.original, [current], input));
+            }
+            index += 1;
+            continue;
+        }
+        pushTextToken(output, current, input);
+        index += 1;
+    }
+    for (let tokenIndex = 0; tokenIndex < output.length; tokenIndex += 1) {
+        output[tokenIndex].index = tokenIndex;
+    }
+    return output;
+}

package/dist/lexer/meaning.d.ts

@@ -0,0 +1,71 @@
+import { FrequencyDescriptor, RouteSynonym } from "../maps";
+import { EventTiming, FhirDayOfWeek, RouteCode } from "../types";
+import { LexToken } from "./token-types";
+export declare enum ConnectorRole {
+    General = "GENERAL",
+    SiteAnchor = "SITE_ANCHOR",
+    SiteList = "SITE_LIST",
+    MealContext = "MEAL_CONTEXT",
+    DayRange = "DAY_RANGE"
+}
+export declare enum TokenWordClass {
+    AdministrationVerb = "ADMINISTRATION_VERB",
+    SiteSurfaceModifier = "SITE_SURFACE_MODIFIER",
+    WorkflowInstruction = "WORKFLOW_INSTRUCTION",
+    ApplicationVerb = "APPLICATION_VERB",
+    CountKeyword = "COUNT_KEYWORD"
+}
+export interface SiteMeaningCandidate {
+    text: string;
+    route?: RouteCode;
+    source: string;
+}
+export interface RouteMeaningCandidate extends RouteSynonym {
+    source: string;
+}
+export interface TokenAnnotations {
+    eventTiming?: EventTiming;
+    timingAbbreviation?: FrequencyDescriptor;
+    dayOfWeek?: FhirDayOfWeek[];
+    routeCandidates?: RouteMeaningCandidate[];
+    siteCandidates?: SiteMeaningCandidate[];
+    prn?: true;
+    connectorRoles?: ConnectorRole[];
+    wordClasses?: TokenWordClass[];
+}
+export interface AnnotatedLexToken extends LexToken {
+    annotations?: TokenAnnotations;
+}
+interface Lowerable {
+    lower: string;
+    annotations?: TokenAnnotations;
+}
+export declare function expandDayMeaningRange(start: FhirDayOfWeek, end: FhirDayOfWeek): FhirDayOfWeek[];
+export declare function resolveDayMeaning(tokenLower: string): FhirDayOfWeek[] | undefined;
+export declare function annotateLexToken(token: LexToken): AnnotatedLexToken;
+export declare function annotateLexTokens(tokens: LexToken[]): AnnotatedLexToken[];
+export declare function hasConnectorRole(token: AnnotatedLexToken | undefined, role: ConnectorRole): boolean;
+export declare function hasTokenWordClass(token: AnnotatedLexToken | undefined, wordClass: TokenWordClass): boolean;
+export declare function hasDayOfWeekMeaning(token: Lowerable | undefined): boolean;
+export declare function getDayOfWeekMeaning(token: Lowerable | undefined): FhirDayOfWeek[] | undefined;
+export declare function hasEventTimingMeaning(token: Lowerable | undefined): boolean;
+export declare function getEventTimingMeaning(token: Lowerable | undefined): EventTiming | undefined;
+export declare function hasTimingAbbreviationMeaning(token: Lowerable | undefined): boolean;
+export declare function getTimingAbbreviationMeaning(token: Lowerable | undefined): FrequencyDescriptor | undefined;
+export declare function hasRouteMeaning(token: Lowerable | undefined): boolean;
+export declare function getRouteMeaning(token: Lowerable | undefined): RouteMeaningCandidate | undefined;
+export declare function hasSiteMeaningCandidate(token: Lowerable | undefined): boolean;
+export declare function getSiteMeaningCandidates(token: Lowerable | undefined): SiteMeaningCandidate[] | undefined;
+export declare function getPrimarySiteMeaningCandidate(token: Lowerable | undefined): SiteMeaningCandidate | undefined;
+export declare function hasPrnMeaning(token: Lowerable | undefined): boolean;
+export declare function hasConnectorMeaning(token: Lowerable | undefined): boolean;
+export declare function isSiteAnchorWord(word: string): boolean;
+export declare function isSiteListConnectorWord(word: string): boolean;
+export declare function isSiteSurfaceModifierWord(word: string): boolean;
+export declare function isWorkflowInstructionWord(word: string): boolean;
+export declare function isApplicationVerbWord(word: string): boolean;
+export declare function isAdministrationVerbWord(word: string): boolean;
+export declare function isCountKeywordWord(word: string): boolean;
+export declare function isMealContextConnectorWord(word: string): boolean;
+export declare function isDayRangeConnectorWord(word: string): boolean;
+export {};