@inflexa-ai/harness 0.1.1

package/dist/tools/lib/iuphar-client.js

@@ -0,0 +1,230 @@
+/**
+ * Pure async client functions for the IUPHAR Guide to Pharmacology
+ * (https://www.guidetopharmacology.org/services/) REST API.
+ *
+ * Used to discover, for any HGNC target or UniProt accession, the obligate
+ * heterodimer complexes that share the same primary protein (e.g., AMY1/
+ * AMY2/AMY3 amylin receptors share the CT receptor protein with the
+ * calcitonin receptor and differ only by their RAMP accessory). Powers
+ * data-driven heterodimer filtering in target-assessment so off-target
+ * panels never list a sibling receptor-complex as a developable hit.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { IUPHAR_BASE, IUPHAR_HEADERS as HEADERS } from "./iuphar-config.js";
+// Validated at the fetch boundary. GtoPdb returns familyIds/complexIds as
+// arrays on every target, and the resolver reads `.length` / iterates them
+// without a guard, so they stay required — a missing value surfaces as
+// `invalid_response` rather than a runtime TypeError. subunitIds and type are
+// only read behind a guard, so they may be absent.
+const IupharTargetSchema = z.object({
+    targetId: z.number(),
+    name: z.string(),
+    type: z.string().nullable().optional(),
+    familyIds: z.array(z.number()),
+    subunitIds: z.array(z.number()).optional(),
+    complexIds: z.array(z.number()),
+    subunitType: z.string().optional(),
+});
+const UNIPROT_ACCESSION_RE = /^[A-Z][0-9][A-Z0-9]{3}[0-9]$/;
+function stripHtml(name) {
+    return name.replace(/<[^>]+>/g, "");
+}
+function notFound(error) {
+    return error.type === "http_status" && (error.status === 404 || error.status === 204);
+}
+async function fetchTargets(query) {
+    const url = `${IUPHAR_BASE}/targets?${query}`;
+    const res = await apiFetchValidated(url, z.array(IupharTargetSchema), { headers: HEADERS });
+    if (res.isErr()) {
+        if (notFound(res.error))
+            return [];
+        throw new Error(describeApiError(res.error));
+    }
+    return Array.isArray(res.value) ? res.value : [];
+}
+export async function findTargetByGeneSymbol(geneSymbol) {
+    const targets = await fetchTargets(`geneSymbol=${encodeURIComponent(geneSymbol)}`);
+    return targets[0] ?? null;
+}
+export async function findTargetByUniprot(accession) {
+    const targets = await fetchTargets(`accession=${encodeURIComponent(accession)}&database=UniProt`);
+    return targets[0] ?? null;
+}
+/**
+ * Resolve a target by either a UniProt accession or HGNC gene symbol.
+ * Tries the format that matches the input shape first, then falls back.
+ */
+export async function resolveTarget(uniprotOrGeneSymbol) {
+    const input = uniprotOrGeneSymbol.trim();
+    if (!input)
+        return null;
+    if (UNIPROT_ACCESSION_RE.test(input)) {
+        return (await findTargetByUniprot(input)) ?? (await findTargetByGeneSymbol(input));
+    }
+    return (await findTargetByGeneSymbol(input)) ?? (await findTargetByUniprot(input));
+}
+export async function getSubunits(complexId) {
+    const url = `${IUPHAR_BASE}/targets/${complexId}/subunits`;
+    const res = await apiFetchValidated(url, z.array(IupharTargetSchema), { headers: HEADERS });
+    if (res.isErr()) {
+        if (notFound(res.error))
+            return [];
+        throw new Error(describeApiError(res.error));
+    }
+    return Array.isArray(res.value) ? res.value : [];
+}
+/**
+ * Get the heterodimer / family complexes that contain the primary target
+ * (e.g., for CALCR → the AMY1/AMY2/AMY3 amylin receptors, each carrying a
+ * RAMP1/2/3 accessory). Names are stripped of IUPHAR's HTML subscript markup.
+ *
+ * Returns [] when the target isn't resolvable in GtoPdb or has no
+ * registered complexes.
+ */
+export async function getFamilyHeterodimers(uniprotOrGeneSymbol) {
+    const target = await resolveTarget(uniprotOrGeneSymbol);
+    if (!target || target.complexIds.length === 0)
+        return [];
+    const url = `${IUPHAR_BASE}/targets/${target.targetId}/complexes`;
+    const res = await apiFetchValidated(url, z.array(IupharTargetSchema), { headers: HEADERS });
+    if (res.isErr()) {
+        if (notFound(res.error))
+            return [];
+        throw new Error(describeApiError(res.error));
+    }
+    const complexes = Array.isArray(res.value) ? res.value : [];
+    const results = [];
+    const concurrency = 5;
+    for (let i = 0; i < complexes.length; i += concurrency) {
+        const batch = complexes.slice(i, i + concurrency);
+        const subunitLists = await Promise.all(batch.map((c) => getSubunits(c.targetId)));
+        for (let j = 0; j < batch.length; j++) {
+            const complex = batch[j];
+            const subunits = subunitLists[j];
+            const cleanedSubunits = subunits.map((s) => ({ ...s, name: stripHtml(s.name) }));
+            const accessories = cleanedSubunits.filter((s) => (s.type ?? "").toLowerCase() === "accessoryprotein");
+            results.push({
+                complex: { ...complex, name: stripHtml(complex.name) },
+                subunits: cleanedSubunits,
+                accessories,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Distinct accessory-protein gene symbols across all heterodimer complexes
+ * containing the primary target. Used to build a runtime regex alternation
+ * for heterodimer-name filtering instead of hardcoding RAMP/MRAP/RGS.
+ *
+ * Example: getAccessoryProteinNames("CALCR") → ["RAMP1", "RAMP2", "RAMP3"].
+ */
+export async function getAccessoryProteinNames(uniprotOrGeneSymbol) {
+    const heterodimers = await getFamilyHeterodimers(uniprotOrGeneSymbol);
+    const names = new Set();
+    for (const h of heterodimers) {
+        for (const acc of h.accessories) {
+            const cleaned = acc.name.trim();
+            if (cleaned)
+                names.add(cleaned);
+        }
+    }
+    return [...names].sort();
+}
+// getFamilySiblingUniprots iterates `targetIds` without a guard, so it stays
+// required; the other fields are not read, so they may be absent.
+const IupharFamilySchema = z.object({
+    familyId: z.number().optional(),
+    name: z.string().optional(),
+    targetIds: z.array(z.number()),
+    parentFamilyIds: z.array(z.number()).optional(),
+    subFamilyIds: z.array(z.number()).optional(),
+});
+export async function getFamily(familyId) {
+    const url = `${IUPHAR_BASE}/targets/families/${familyId}`;
+    const res = await apiFetchValidated(url, IupharFamilySchema, { headers: HEADERS });
+    if (res.isErr()) {
+        if (notFound(res.error))
+            return null;
+        throw new Error(describeApiError(res.error));
+    }
+    return res.value;
+}
+const IupharDatabaseLinkSchema = z.object({
+    accession: z.string().optional(),
+    database: z.string().optional(),
+    species: z.string().optional(),
+});
+/** Fetch the UniProtKB cross-references (human only) for an IUPHAR target. */
+export async function getTargetHumanUniprots(targetId) {
+    const url = `${IUPHAR_BASE}/targets/${targetId}/databaseLinks`;
+    const res = await apiFetchValidated(url, z.array(IupharDatabaseLinkSchema), { headers: HEADERS });
+    if (res.isErr()) {
+        if (notFound(res.error))
+            return [];
+        throw new Error(describeApiError(res.error));
+    }
+    const links = Array.isArray(res.value) ? res.value : [];
+    const out = [];
+    for (const l of links) {
+        if (l.database !== "UniProtKB")
+            continue;
+        if ((l.species ?? "").toLowerCase() !== "human")
+            continue;
+        if (l.accession)
+            out.push(l.accession);
+    }
+    return out;
+}
+/**
+ * UniProt accessions of sibling primary-GPCR targets in the same IUPHAR
+ * family as the input (excludes the input target itself and any target
+ * registered as a complex with subunits). For CALCR this returns the
+ * CALCRL accession; the AMY1/2/3 complexes are excluded because they are
+ * heterodimers, not separate primary proteins.
+ */
+export async function getFamilySiblingUniprots(uniprotOrGeneSymbol) {
+    const self = await resolveTarget(uniprotOrGeneSymbol);
+    if (!self)
+        return [];
+    const selfUniprots = new Set(await getTargetHumanUniprots(self.targetId));
+    const siblingIds = new Set();
+    for (const familyId of self.familyIds) {
+        const family = await getFamily(familyId);
+        if (!family)
+            continue;
+        for (const tid of family.targetIds) {
+            if (tid !== self.targetId)
+                siblingIds.add(tid);
+        }
+    }
+    if (siblingIds.size === 0)
+        return [];
+    const out = new Set();
+    const ids = [...siblingIds];
+    const concurrency = 5;
+    for (let i = 0; i < ids.length; i += concurrency) {
+        const batch = ids.slice(i, i + concurrency);
+        // Fetch target details and their UniProt cross-references in parallel.
+        // Complexes (non-empty subunitIds) are skipped — those are covered by
+        // the family-complexes collector, not the family-sibling resolver.
+        const uniprotLists = await Promise.all(batch.map(async (tid) => {
+            const url = `${IUPHAR_BASE}/targets/${tid}`;
+            const res = await apiFetchValidated(url, IupharTargetSchema, { headers: HEADERS });
+            if (res.isErr())
+                return [];
+            const t = res.value;
+            if (t.subunitIds && t.subunitIds.length > 0)
+                return [];
+            return getTargetHumanUniprots(t.targetId);
+        }));
+        for (const accs of uniprotLists) {
+            for (const a of accs) {
+                if (!selfUniprots.has(a))
+                    out.add(a);
+            }
+        }
+    }
+    return [...out].sort();
+}

package/dist/tools/lib/iuphar-config.d.ts

@@ -0,0 +1,5 @@
+/** Shared constants for the IUPHAR Guide to Pharmacology REST API. */
+export declare const IUPHAR_BASE = "https://www.guidetopharmacology.org/services";
+export declare const IUPHAR_HEADERS: {
+    readonly Accept: "application/json";
+};

package/dist/tools/lib/iuphar-config.js

@@ -0,0 +1,3 @@
+/** Shared constants for the IUPHAR Guide to Pharmacology REST API. */
+export const IUPHAR_BASE = "https://www.guidetopharmacology.org/services";
+export const IUPHAR_HEADERS = { Accept: "application/json" };

package/dist/tools/lib/ncbi-utils.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared NCBI E-utilities helpers for PubMed/PMC tools.
+ *
+ * Provides base URL constants, API key injection, and XML-to-article
+ * mapping functions for PubMed and PMC DTD structures.
+ */
+export declare const NCBI_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils";
+export declare const NCBI_IDCONV = "https://www.ncbi.nlm.nih.gov/pmc/utils/idconv/v1.0";
+/**
+ * Append `api_key` and optional extra params to a base URL.
+ * Omits the key when `apiKey` is undefined.
+ */
+export declare function ncbiUrl(apiKey: string | undefined, base: string, params: Record<string, string | number | undefined>): string;
+export interface PubMedSummary {
+    pmid: string;
+    title: string;
+    journal: string;
+    year: string;
+    authors: string;
+}
+/**
+ * Parse esummary XML into PubMedSummary records.
+ */
+export declare function parseEsummary(xml: string): PubMedSummary[];
+export interface ArticleDetail {
+    pmid: string;
+    title: string;
+    abstract: string;
+    authors: string[];
+    journal: string;
+    year: string;
+    doi: string;
+    meshTerms: string[];
+    pmcId: string | null;
+}
+/**
+ * Parse efetch PubMed XML into ArticleDetail records.
+ * `pmcId` is left null here — resolved separately via ID Converter.
+ */
+export declare function parseEfetch(xml: string): ArticleDetail[];
+/**
+ * Parse ID Converter JSON response into a PMID → PMC ID map.
+ * Returns only entries that have a PMC ID.
+ */
+export declare function parseIdConvResponse(data: unknown): Map<string, string>;
+export interface ArticleSection {
+    heading: string;
+    text: string;
+}
+export interface FullTextResult {
+    fullText: string;
+    sections: ArticleSection[];
+}
+/**
+ * Parse PMC efetch XML into plain text with section structure.
+ * Omits figures, tables, and supplementary material markup.
+ */
+export declare function parsePmcFullText(xml: string): FullTextResult | null;

package/dist/tools/lib/ncbi-utils.js

@@ -0,0 +1,286 @@
+/**
+ * Shared NCBI E-utilities helpers for PubMed/PMC tools.
+ *
+ * Provides base URL constants, API key injection, and XML-to-article
+ * mapping functions for PubMed and PMC DTD structures.
+ */
+import { XMLParser } from "fast-xml-parser";
+// ── NCBI E-utilities base URLs ──────────────────────────────────────
+export const NCBI_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils";
+export const NCBI_IDCONV = "https://www.ncbi.nlm.nih.gov/pmc/utils/idconv/v1.0";
+// ── API key injection ───────────────────────────────────────────────
+/**
+ * Append `api_key` and optional extra params to a base URL.
+ * Omits the key when `apiKey` is undefined.
+ */
+export function ncbiUrl(apiKey, base, params) {
+    const url = new URL(base);
+    if (apiKey) {
+        url.searchParams.set("api_key", apiKey);
+    }
+    for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined) {
+            url.searchParams.set(k, String(v));
+        }
+    }
+    return url.toString();
+}
+// ── XML parser (shared, configured once) ────────────────────────────
+const xmlParser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    isArray: (name) => ["PubmedArticle", "Author", "MeshHeading", "AbstractText", "sec", "p", "record"].includes(name),
+    textNodeName: "#text",
+});
+function getItemValue(items, name) {
+    if (!items)
+        return "";
+    const arr = Array.isArray(items) ? items : [items];
+    const item = arr.find((i) => i["@_Name"] === name);
+    return item?.["#text"] ?? "";
+}
+function getAuthorsFromDocSum(items) {
+    if (!items)
+        return "";
+    const arr = Array.isArray(items) ? items : [items];
+    const authorList = arr.find((i) => i["@_Name"] === "AuthorList");
+    if (!authorList?.Item)
+        return "";
+    const authors = Array.isArray(authorList.Item) ? authorList.Item : [authorList.Item];
+    const names = authors.map((a) => a["#text"] ?? "").filter(Boolean);
+    if (names.length === 0)
+        return "";
+    if (names.length <= 3)
+        return names.join(", ");
+    return `${names[0]} et al.`;
+}
+/**
+ * Parse esummary XML into PubMedSummary records.
+ */
+export function parseEsummary(xml) {
+    const parsed = xmlParser.parse(xml);
+    const result = parsed?.eSummaryResult ?? parsed;
+    const docSums = result?.DocSum;
+    if (!docSums)
+        return [];
+    const docs = Array.isArray(docSums) ? docSums : [docSums];
+    return docs.map((doc) => {
+        const items = doc.Item;
+        const pubDate = getItemValue(items, "PubDate");
+        return {
+            pmid: String(doc.Id ?? ""),
+            title: getItemValue(items, "Title"),
+            journal: getItemValue(items, "FullJournalName") || getItemValue(items, "Source"),
+            year: pubDate ? String(pubDate).slice(0, 4) : "",
+            authors: getAuthorsFromDocSum(items),
+        };
+    });
+}
+/**
+ * Parse efetch PubMed XML into ArticleDetail records.
+ * `pmcId` is left null here — resolved separately via ID Converter.
+ */
+export function parseEfetch(xml) {
+    const parsed = xmlParser.parse(xml);
+    const articleSet = parsed?.PubmedArticleSet;
+    if (!articleSet)
+        return [];
+    const articles = Array.isArray(articleSet.PubmedArticle) ? articleSet.PubmedArticle : articleSet.PubmedArticle ? [articleSet.PubmedArticle] : [];
+    return articles.map((entry) => {
+        const article = entry;
+        const medlineCitation = article.MedlineCitation;
+        const articleData = medlineCitation?.Article;
+        // PMID
+        const pmidObj = medlineCitation?.PMID;
+        const pmid = typeof pmidObj === "object" && pmidObj !== null ? String(pmidObj["#text"] ?? "") : String(pmidObj ?? "");
+        // Title
+        const title = String(articleData?.ArticleTitle ?? "");
+        // Abstract
+        const abstractObj = articleData?.Abstract;
+        let abstract = "";
+        if (abstractObj?.AbstractText) {
+            const texts = Array.isArray(abstractObj.AbstractText) ? abstractObj.AbstractText : [abstractObj.AbstractText];
+            abstract = texts
+                .map((t) => {
+                if (typeof t === "string")
+                    return t;
+                if (typeof t === "object" && t !== null) {
+                    const label = t["@_Label"];
+                    const text = t["#text"] ?? "";
+                    return label ? `${label}: ${text}` : String(text);
+                }
+                return String(t);
+            })
+                .join("\n\n");
+        }
+        // Authors
+        const authorListObj = articleData?.AuthorList;
+        const rawAuthors = authorListObj?.Author;
+        const authorArr = Array.isArray(rawAuthors) ? rawAuthors : rawAuthors ? [rawAuthors] : [];
+        const authors = authorArr.map((a) => {
+            if (a.CollectiveName)
+                return a.CollectiveName;
+            return [a.ForeName ?? a.Initials, a.LastName].filter(Boolean).join(" ");
+        });
+        // Journal + year
+        const journalObj = articleData?.Journal;
+        const journal = String(journalObj?.Title ?? journalObj?.ISOAbbreviation ?? "");
+        const journalIssue = journalObj?.JournalIssue;
+        const pubDate = journalIssue?.PubDate;
+        const year = String(pubDate?.Year ?? "");
+        // DOI
+        let doi = "";
+        const articleIdList = article.PubmedData?.ArticleIdList;
+        if (articleIdList?.ArticleId) {
+            const ids = Array.isArray(articleIdList.ArticleId) ? articleIdList.ArticleId : [articleIdList.ArticleId];
+            for (const idObj of ids) {
+                if (typeof idObj === "object" && idObj !== null) {
+                    const typed = idObj;
+                    if (typed["@_IdType"] === "doi") {
+                        doi = String(typed["#text"] ?? "");
+                    }
+                }
+            }
+        }
+        // MeSH terms
+        const meshList = medlineCitation?.MeshHeadingList;
+        const meshHeadings = meshList?.MeshHeading
+            ? Array.isArray(meshList.MeshHeading)
+                ? meshList.MeshHeading
+                : [meshList.MeshHeading]
+            : [];
+        const meshTerms = meshHeadings
+            .map((h) => {
+            const desc = h.DescriptorName;
+            if (typeof desc === "string")
+                return desc;
+            if (typeof desc === "object" && desc !== null)
+                return desc["#text"] ?? "";
+            return "";
+        })
+            .filter(Boolean);
+        return {
+            pmid,
+            title,
+            abstract,
+            authors,
+            journal,
+            year,
+            doi,
+            meshTerms,
+            pmcId: null, // resolved separately via ID Converter
+        };
+    });
+}
+// ── NCBI ID Converter mapping ───────────────────────────────────────
+/**
+ * Parse ID Converter JSON response into a PMID → PMC ID map.
+ * Returns only entries that have a PMC ID.
+ */
+export function parseIdConvResponse(data) {
+    const map = new Map();
+    const typed = data;
+    if (!typed?.records)
+        return map;
+    for (const rec of typed.records) {
+        if (rec.pmid && rec.pmcid) {
+            map.set(rec.pmid, rec.pmcid);
+        }
+    }
+    return map;
+}
+/**
+ * Parse PMC efetch XML into plain text with section structure.
+ * Omits figures, tables, and supplementary material markup.
+ */
+export function parsePmcFullText(xml) {
+    const parsed = xmlParser.parse(xml);
+    const articleSet = parsed?.["pmc-articleset"];
+    const article = articleSet?.article;
+    if (!article)
+        return null;
+    const body = article.body;
+    if (!body)
+        return null;
+    const sections = [];
+    const rawSecs = body.sec ? (Array.isArray(body.sec) ? body.sec : [body.sec]) : [];
+    for (const sec of rawSecs) {
+        extractSection(sec, sections);
+    }
+    // If no sections found, try to extract body text directly
+    if (sections.length === 0) {
+        const bodyText = extractParagraphs(body);
+        if (bodyText) {
+            sections.push({ heading: "", text: bodyText });
+        }
+    }
+    const fullText = sections.map((s) => (s.heading ? `## ${s.heading}\n\n${s.text}` : s.text)).join("\n\n");
+    return { fullText, sections };
+}
+function extractSection(sec, out) {
+    if (!sec || typeof sec !== "object")
+        return;
+    const s = sec;
+    const heading = typeof s.title === "string" ? s.title : "";
+    const text = extractParagraphs(s);
+    if (text) {
+        out.push({ heading, text });
+    }
+    // Recurse into nested sections
+    if (s.sec) {
+        const nested = Array.isArray(s.sec) ? s.sec : [s.sec];
+        for (const sub of nested) {
+            extractSection(sub, out);
+        }
+    }
+}
+function extractParagraphs(container) {
+    const paragraphs = container.p;
+    if (!paragraphs)
+        return "";
+    const pArr = Array.isArray(paragraphs) ? paragraphs : [paragraphs];
+    return pArr
+        .map((p) => {
+        if (typeof p === "string")
+            return p;
+        if (typeof p === "object" && p !== null) {
+            return flattenTextContent(p);
+        }
+        return String(p);
+    })
+        .filter(Boolean)
+        .join("\n\n");
+}
+/**
+ * Recursively extract text content from a parsed XML node,
+ * ignoring markup like <fig>, <table-wrap>, <xref>, etc.
+ */
+function flattenTextContent(node) {
+    if (typeof node === "string")
+        return node;
+    if (typeof node === "number")
+        return String(node);
+    if (!node || typeof node !== "object")
+        return "";
+    const obj = node;
+    const parts = [];
+    for (const [key, value] of Object.entries(obj)) {
+        // Skip attributes and figure/table elements
+        if (key.startsWith("@_"))
+            continue;
+        if (key === "fig" || key === "table-wrap" || key === "supplementary-material")
+            continue;
+        if (key === "#text") {
+            parts.push(String(value));
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                parts.push(flattenTextContent(item));
+            }
+        }
+        else {
+            parts.push(flattenTextContent(value));
+        }
+    }
+    return parts.filter(Boolean).join("");
+}

package/dist/tools/lib/openfda-client.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Pure async client functions for the openFDA FAERS adverse-event API.
+ *
+ * Used by §2.6.2 (FAERS summary) and §2.6.6 (class precedent — drugs-in-class
+ * AEs).
+ */
+export interface AdverseEventCount {
+    reaction: string;
+    count: number;
+}
+export interface DrugLabelAction {
+    applicationNumber: string | null;
+    brandName: string | null;
+    genericName: string | null;
+    /** YYYYMMDD on the openFDA payload; we surface the raw token unchanged. */
+    effectiveTime: string | null;
+    boxedWarning: string | null;
+    warningsAndCautions: string | null;
+    hasRems: boolean;
+    sourceUrl: string;
+}
+export interface SeriousnessProfile {
+    totalReports: number;
+    fatalCount: number;
+    hospitalizationCount: number;
+    lifeThreateningCount: number;
+    disablingCount: number;
+    congenitalAnomalyCount: number;
+    otherSeriousCount: number;
+}
+/** Top adverse-reaction terms by count for a generic drug name. */
+export declare function getFaersByDrug(drugName: string, options?: {
+    limit?: number;
+    serious?: boolean;
+}): Promise<{
+    totalReports: number | undefined;
+    adverseEvents: AdverseEventCount[];
+}>;
+/**
+ * Seriousness breakdown for a drug. Aggregates the seriousness flags
+ * (death, hospitalization, life-threatening, disabling) used by §2.6.2 fatal
+ * and §2.6.8 risk summary.
+ */
+export declare function getFaersSeriousness(drugName: string): Promise<SeriousnessProfile | null>;
+/**
+ * Fetch FDA Structured Product Label entries by generic drug name. Returns
+ * the most recent N labels (sorted by effective_time desc); each row carries
+ * the boxed-warning text, the Section 5 warnings_and_cautions excerpt, and a
+ * REMS indicator. Returns [] on 404 / no match.
+ */
+export declare function getDrugLabelActions(genericName: string, options?: {
+    limit?: number;
+}): Promise<DrugLabelAction[]>;