@inflexa-ai/harness 0.13.0 → 0.14.1

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

@@ -0,0 +1,168 @@
+/**
+ * Pure async client functions for the Drug-Gene Interaction Database (DGIdb)
+ * GraphQL API. Free, no key required.
+ *
+ * DGIdb aggregates 30+ sources (ChEMBL, DrugBank, TTD, PharmGKB,
+ * GuideToPharmacology, CIViC, …) and reports per-interaction source counts,
+ * which the caller uses as a confidence signal.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+const DGIDB_GRAPHQL_URL = "https://dgidb.org/api/graphql";
+const GENE_INTERACTIONS_QUERY = `query($genes: [String!]!) {
+  genes(names: $genes) {
+    nodes {
+      name
+      interactions {
+        interactionScore
+        interactionTypes { type directionality }
+        drug { name conceptId }
+        interactionAttributes { name value }
+        publications { pmid }
+        sources { sourceDbName }
+      }
+    }
+  }
+}`;
+const DRUG_INTERACTIONS_QUERY = `query($drugs: [String!]!) {
+  drugs(names: $drugs) {
+    nodes {
+      name
+      conceptId
+      interactions {
+        interactionScore
+        interactionTypes { type directionality }
+        gene { name }
+        interactionAttributes { name value }
+        publications { pmid }
+        sources { sourceDbName }
+      }
+    }
+  }
+}`;
+// Shape of the DGIdb GraphQL payload as it arrives on the wire. Validated at
+// the fetch boundary; `mapInteraction` normalizes each record. Most fields are
+// optional/nullable to match GraphQL's per-field nullability — but
+// `RawNode.name` is required because we key the node map on
+// `name.toLowerCase()`; a node missing it is a contract break we surface as an
+// `invalid_response` error rather than a runtime TypeError.
+const RawInteractionSchema = z.object({
+    interactionScore: z.number().nullable().optional(),
+    interactionTypes: z.array(z.object({ type: z.string().optional(), directionality: z.string().nullable().optional() })).optional(),
+    drug: z.object({ name: z.string().optional(), conceptId: z.string().nullable().optional() }).nullable().optional(),
+    gene: z.object({ name: z.string().optional() }).nullable().optional(),
+    interactionAttributes: z.array(z.object({ name: z.string().optional(), value: z.string().optional() })).optional(),
+    publications: z.array(z.object({ pmid: z.union([z.string(), z.number()]).optional() })).optional(),
+    sources: z.array(z.object({ sourceDbName: z.string().optional() })).optional(),
+});
+const RawNodeSchema = z.object({
+    name: z.string(),
+    conceptId: z.string().nullable().optional(),
+    interactions: z.array(RawInteractionSchema).optional(),
+});
+const DgidbResponseSchema = z.object({
+    data: z
+        .object({
+        genes: z.object({ nodes: z.array(RawNodeSchema).optional() }).optional(),
+        drugs: z.object({ nodes: z.array(RawNodeSchema).optional() }).optional(),
+    })
+        .optional(),
+    errors: z.array(z.object({ message: z.string().optional() })).optional(),
+});
+/** PMIDs kept per interaction — the count travels for the rest. */
+const MAX_PMIDS = 5;
+/** Attributes kept per interaction, and the per-value character ceiling. */
+const MAX_ATTRIBUTES = 10;
+const MAX_ATTRIBUTE_CHARS = 160;
+function mapInteraction(raw, perspective, inputSide, includeAttributes) {
+    const sources = (raw.sources ?? []).map((s) => s.sourceDbName ?? "").filter(Boolean);
+    const pmids = (raw.publications ?? []).map((p) => (p.pmid != null ? String(p.pmid) : "")).filter(Boolean);
+    const types = (raw.interactionTypes ?? []).map((t) => ({
+        type: t.type ?? "",
+        ...(t.directionality ? { directionality: t.directionality } : {}),
+    }));
+    const geneName = perspective === "gene" ? (inputSide.geneName ?? "") : (raw.gene?.name ?? "");
+    const drugName = perspective === "drug" ? (inputSide.drugName ?? "") : (raw.drug?.name ?? "");
+    const drugConceptId = perspective === "drug" ? inputSide.drugConceptId : (raw.drug?.conceptId ?? undefined);
+    return {
+        geneName,
+        drugName,
+        ...(drugConceptId ? { drugConceptId } : {}),
+        interactionTypes: types,
+        ...(raw.interactionScore != null ? { interactionScore: raw.interactionScore } : {}),
+        sourceCount: sources.length,
+        sources,
+        publicationCount: pmids.length,
+        pmids: pmids.slice(0, MAX_PMIDS),
+        ...(includeAttributes
+            ? {
+                attributes: (raw.interactionAttributes ?? []).slice(0, MAX_ATTRIBUTES).map((a) => ({
+                    name: a.name ?? "",
+                    value: (a.value ?? "").slice(0, MAX_ATTRIBUTE_CHARS),
+                })),
+            }
+            : {}),
+    };
+}
+function applyFilters(interactions, filters) {
+    let out = interactions;
+    if (filters.interactionTypes?.length) {
+        const needles = filters.interactionTypes.map((s) => s.toLowerCase());
+        out = out.filter((i) => i.interactionTypes.some((t) => needles.some((n) => t.type.toLowerCase().includes(n))));
+    }
+    if (filters.sourceDbs?.length) {
+        const needles = filters.sourceDbs.map((s) => s.toLowerCase());
+        out = out.filter((i) => i.sources.some((s) => needles.some((n) => s.toLowerCase().includes(n))));
+    }
+    const minSources = filters.minSources ?? 1;
+    if (minSources > 0) {
+        out = out.filter((i) => i.sourceCount >= minSources);
+    }
+    return out;
+}
+/**
+ * Query DGIdb for interactions of the given genes or drugs.
+ *
+ * `onPartialErrors` receives GraphQL partial errors that arrive alongside
+ * usable data — the client itself never logs, so the caller decides.
+ */
+export async function searchDgidb(inputs, searchType, filters = {}, onPartialErrors) {
+    const isGene = searchType === "gene";
+    const res = await apiFetchValidated(DGIDB_GRAPHQL_URL, DgidbResponseSchema, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            query: isGene ? GENE_INTERACTIONS_QUERY : DRUG_INTERACTIONS_QUERY,
+            variables: { [isGene ? "genes" : "drugs"]: inputs },
+        }),
+    });
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    const body = res.value;
+    if (!body || !body.data)
+        throw new Error("DGIdb returned no data");
+    if (body.errors?.length)
+        onPartialErrors?.(body.errors.slice(0, 3));
+    const nodes = (isGene ? body.data.genes?.nodes : body.data.drugs?.nodes) ?? [];
+    const nodeMap = new Map();
+    for (const node of nodes) {
+        nodeMap.set(node.name.toLowerCase(), node);
+        if (!isGene && node.conceptId)
+            nodeMap.set(node.conceptId.toLowerCase(), node);
+    }
+    const limit = filters.limit ?? 20;
+    return inputs.map((input) => {
+        const node = nodeMap.get(input.toLowerCase());
+        if (!node)
+            return { input, found: false, interactions: [], totalInteractions: 0 };
+        const inputSide = isGene ? { geneName: node.name } : { drugName: node.name, drugConceptId: node.conceptId ?? undefined };
+        const mapped = (node.interactions ?? []).map((raw) => mapInteraction(raw, searchType, inputSide, filters.includeAttributes ?? false));
+        const filtered = applyFilters(mapped, filters);
+        const sorted = filtered.sort((a, b) => {
+            if (b.sourceCount !== a.sourceCount)
+                return b.sourceCount - a.sourceCount;
+            return (b.interactionScore ?? 0) - (a.interactionScore ?? 0);
+        });
+        return { input, found: true, interactions: sorted.slice(0, limit), totalInteractions: sorted.length };
+    });
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Pure async client functions for DisGeNET gene-disease associations (GDAs).
+ *
+ * Requires a DisGeNET API key; `getDisgenetHeaders` throws when it is absent.
+ */
+import { z } from "zod";
+declare const GdaSchema: z.ZodPipe<z.ZodObject<{
+    gene_symbol: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    gene_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    geneid: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    disease_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    diseaseid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    disease_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ei: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    year_initial: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    year_final: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    pmid_count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<{
+    geneSymbol: string;
+    geneName: string;
+    geneId: number;
+    diseaseName: string;
+    diseaseId: string;
+    diseaseType: string;
+    score: number;
+    evidenceIndex: number;
+    yearInitial: number | null;
+    yearFinal: number | null;
+    nPmids: number;
+    source: string;
+}, {
+    gene_symbol?: string | null | undefined;
+    gene_name?: string | null | undefined;
+    geneid?: number | null | undefined;
+    disease_name?: string | null | undefined;
+    diseaseid?: string | null | undefined;
+    disease_type?: string | null | undefined;
+    score?: number | null | undefined;
+    ei?: number | null | undefined;
+    year_initial?: number | null | undefined;
+    year_final?: number | null | undefined;
+    pmid_count?: number | null | undefined;
+    source?: string | null | undefined;
+}>>;
+export type Gda = z.infer<typeof GdaSchema>;
+export type DisgenetSearchType = "gene" | "disease";
+export type DisgenetSource = "ALL" | "CURATED" | "ANIMAL_MODELS" | "BEFREE";
+export interface DisgenetSearchOptions {
+    minScore?: number;
+    source?: DisgenetSource;
+    limit?: number;
+}
+export declare function searchDisgenet(apiKey: string, query: string, searchType: DisgenetSearchType, options?: DisgenetSearchOptions): Promise<Gda[]>;
+export {};

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

@@ -0,0 +1,59 @@
+/**
+ * Pure async client functions for DisGeNET gene-disease associations (GDAs).
+ *
+ * Requires a DisGeNET API key; `getDisgenetHeaders` throws when it is absent.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { DISGENET_BASE, getDisgenetHeaders } from "./disgenet-config.js";
+// A single schema that both validates and normalizes one DisGeNET GDA record:
+// the `.object(...)` half is the snake_case wire shape (every field optional —
+// the API omits absent values), the `.transform(...)` half maps it to the
+// camelCase `Gda` we return. Parsing IS the validation (`apiFetchValidated`
+// runs it over the JSON), and because the transform rides on the schema,
+// `z.infer` below is the OUTPUT type — no separate raw interface or mapper.
+const GdaSchema = z
+    .object({
+    gene_symbol: z.string().nullable().optional(),
+    gene_name: z.string().nullable().optional(),
+    geneid: z.number().nullable().optional(),
+    disease_name: z.string().nullable().optional(),
+    diseaseid: z.string().nullable().optional(),
+    disease_type: z.string().nullable().optional(),
+    score: z.number().nullable().optional(),
+    ei: z.number().nullable().optional(),
+    year_initial: z.number().nullable().optional(),
+    year_final: z.number().nullable().optional(),
+    pmid_count: z.number().nullable().optional(),
+    source: z.string().nullable().optional(),
+})
+    .transform((gda) => ({
+    geneSymbol: gda.gene_symbol ?? "",
+    geneName: gda.gene_name ?? "",
+    geneId: gda.geneid ?? 0,
+    diseaseName: gda.disease_name ?? "",
+    diseaseId: gda.diseaseid ?? "",
+    diseaseType: gda.disease_type ?? "",
+    score: gda.score ?? 0,
+    evidenceIndex: gda.ei ?? 0,
+    yearInitial: gda.year_initial ?? null,
+    yearFinal: gda.year_final ?? null,
+    nPmids: gda.pmid_count ?? 0,
+    source: gda.source ?? "",
+}));
+const GdaListSchema = z.array(GdaSchema);
+export async function searchDisgenet(apiKey, query, searchType, options = {}) {
+    const headers = getDisgenetHeaders(apiKey);
+    const minScore = options.minScore ?? 0.1;
+    const limit = options.limit ?? 25;
+    const source = options.source ?? "ALL";
+    const path = searchType === "gene" ? `gene/${encodeURIComponent(query)}` : `disease/${encodeURIComponent(query)}`;
+    let url = `${DISGENET_BASE}/gda/${path}?min_score=${minScore}&limit=${limit}`;
+    if (source !== "ALL")
+        url += `&source=${source}`;
+    const res = await apiFetchValidated(url, GdaListSchema, { headers });
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    // Already validated + normalized to camelCase by GdaSchema's transform.
+    return res.value;
+}

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

@@ -0,0 +1,83 @@
+/**
+ * Pure async client functions for DrugBank.
+ *
+ * Requires a DrugBank API key; `getDrugbankHeaders` throws when it is absent.
+ */
+import { z } from "zod";
+declare const DrugResultSchema: z.ZodPipe<z.ZodObject<{
+    drugbank_id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        category: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    indication: z.ZodOptional<z.ZodString>;
+    pharmacodynamics: z.ZodOptional<z.ZodString>;
+    mechanism_of_action: z.ZodOptional<z.ZodString>;
+    toxicity: z.ZodOptional<z.ZodString>;
+    half_life: z.ZodOptional<z.ZodString>;
+    targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        gene_name: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        known_action: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    drug_interactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        drugbank_id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    drugbankId: string;
+    name: string;
+    description: string;
+    type: string;
+    groups: string[];
+    categories: string[];
+    indication: string;
+    pharmacodynamics: string;
+    mechanismOfAction: string;
+    toxicity: string;
+    halfLife: string;
+    targets: {
+        name: string;
+        geneSymbol: string;
+        actions: string[];
+        knownAction: string;
+    }[];
+    interactions: {
+        drugbankId: string;
+        name: string;
+        description: string;
+    }[];
+}, {
+    drugbank_id?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    type?: string | undefined;
+    groups?: string[] | undefined;
+    categories?: {
+        category?: string | undefined;
+    }[] | undefined;
+    indication?: string | undefined;
+    pharmacodynamics?: string | undefined;
+    mechanism_of_action?: string | undefined;
+    toxicity?: string | undefined;
+    half_life?: string | undefined;
+    targets?: {
+        name?: string | undefined;
+        gene_name?: string | undefined;
+        actions?: string[] | undefined;
+        known_action?: string | undefined;
+    }[] | undefined;
+    drug_interactions?: {
+        drugbank_id?: string | undefined;
+        name?: string | undefined;
+        description?: string | undefined;
+    }[] | undefined;
+}>>;
+export type DrugResult = z.infer<typeof DrugResultSchema>;
+export declare function searchDrugbank(apiKey: string, query: string, searchType: "drug" | "target", limit?: number): Promise<DrugResult[]>;
+export {};

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

@@ -0,0 +1,95 @@
+/**
+ * Pure async client functions for DrugBank.
+ *
+ * Requires a DrugBank API key; `getDrugbankHeaders` throws when it is absent.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { DRUGBANK_BASE, getDrugbankHeaders } from "./drugbank-config.js";
+/** Hard ceiling on each prose field at the parse boundary; callers trim further. */
+const PROSE_CEILING = 500;
+// A single schema that both validates and normalizes one DrugBank record.
+// The `.object(...)` half is the snake_case wire shape (every field optional —
+// the API omits absent values); the `.transform(...)` half maps it into the
+// camelCase result we return. Parsing IS the validation: `apiFetchValidated`
+// runs this schema over the JSON, so a payload whose field TYPES drift (an
+// object where the API used to send an array, a number for a string) is
+// rejected as `invalid_response` instead of being silently mis-mapped. Because
+// the schema carries the transform, `z.infer` below is the OUTPUT (camelCase)
+// type callers receive — there is no separate raw interface or mapper to keep
+// in sync.
+const DrugResultSchema = z
+    .object({
+    drugbank_id: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    type: z.string().optional(),
+    groups: z.array(z.string()).optional(),
+    categories: z.array(z.object({ category: z.string().optional() })).optional(),
+    indication: z.string().optional(),
+    pharmacodynamics: z.string().optional(),
+    mechanism_of_action: z.string().optional(),
+    toxicity: z.string().optional(),
+    half_life: z.string().optional(),
+    targets: z
+        .array(z.object({
+        name: z.string().optional(),
+        gene_name: z.string().optional(),
+        actions: z.array(z.string()).optional(),
+        known_action: z.string().optional(),
+    }))
+        .optional(),
+    drug_interactions: z
+        .array(z.object({
+        drugbank_id: z.string().optional(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+    }))
+        .optional(),
+})
+    .transform((raw) => ({
+    drugbankId: raw.drugbank_id ?? "",
+    name: raw.name ?? "",
+    description: (raw.description ?? "").slice(0, PROSE_CEILING),
+    type: raw.type ?? "",
+    groups: raw.groups ?? [],
+    categories: (raw.categories ?? []).map((c) => c.category ?? "").filter(Boolean),
+    indication: (raw.indication ?? "").slice(0, PROSE_CEILING),
+    pharmacodynamics: (raw.pharmacodynamics ?? "").slice(0, PROSE_CEILING),
+    mechanismOfAction: (raw.mechanism_of_action ?? "").slice(0, PROSE_CEILING),
+    toxicity: (raw.toxicity ?? "").slice(0, PROSE_CEILING),
+    halfLife: raw.half_life ?? "",
+    targets: (raw.targets ?? []).map((t) => ({
+        name: t.name ?? "",
+        geneSymbol: t.gene_name ?? "",
+        actions: t.actions ?? [],
+        knownAction: t.known_action ?? "",
+    })),
+    interactions: (raw.drug_interactions ?? []).map((i) => ({
+        drugbankId: i.drugbank_id ?? "",
+        name: i.name ?? "",
+        description: (i.description ?? "").slice(0, 200),
+    })),
+}));
+// The /drugs endpoint returns a single object (by-id lookup) or an array
+// (query/target lookups); accept either, transforming each element.
+const DrugResponseSchema = z.union([DrugResultSchema, z.array(DrugResultSchema)]);
+export async function searchDrugbank(apiKey, query, searchType, limit = 10) {
+    const headers = getDrugbankHeaders(apiKey);
+    let url;
+    if (searchType === "target") {
+        url = `${DRUGBANK_BASE}/drugs?target=${encodeURIComponent(query)}&limit=${limit}`;
+    }
+    else if (query.startsWith("DB")) {
+        url = `${DRUGBANK_BASE}/drugs/${query}`;
+    }
+    else {
+        url = `${DRUGBANK_BASE}/drugs?q=${encodeURIComponent(query)}&limit=${limit}`;
+    }
+    const res = await apiFetchValidated(url, DrugResponseSchema, { headers });
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    // Already validated + normalized by DrugResultSchema's transform.
+    const drugs = Array.isArray(res.value) ? res.value : [res.value];
+    return drugs.slice(0, limit);
+}

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

@@ -17,8 +17,11 @@ export interface GeneInfo {
 }
 export interface LookupOptions {
     species?: string;
-    expand?: boolean;
 }
+/**
+ * Look up genes by symbol. Gene-level only: `RawGeneSchema`/`mapGene` model the
+ * gene record itself, so there is no transcript or exon detail to ask for.
+ */
 export declare function lookupGenes(symbols: string[], options?: LookupOptions): Promise<{
     genes: GeneInfo[];
     notFound: string[];

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

@@ -38,12 +38,14 @@ function mapGene(symbol, raw) {
         seqRegionName: raw.seq_region_name ?? "",
     };
 }
+/**
+ * Look up genes by symbol. Gene-level only: `RawGeneSchema`/`mapGene` model the
+ * gene record itself, so there is no transcript or exon detail to ask for.
+ */
 export async function lookupGenes(symbols, options = {}) {
     const species = options.species ?? "homo_sapiens";
-    const expand = options.expand ?? false;
     if (symbols.length === 1) {
-        const expandParam = expand ? "?expand=1" : "";
-        const result = await apiFetchValidated(`${ENSEMBL_BASE}/lookup/symbol/${species}/${symbols[0]}${expandParam}`, RawGeneSchema, { headers: HEADERS });
+        const result = await apiFetchValidated(`${ENSEMBL_BASE}/lookup/symbol/${species}/${symbols[0]}`, RawGeneSchema, { headers: HEADERS });
         if (result.isErr()) {
             if (result.error.type === "http_status" && result.error.status === 400) {
                 return { genes: [], notFound: [symbols[0]] };

package/dist/tools/lib/gwas-catalog-client.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Pure async client functions for the NHGRI-EBI GWAS Catalog REST API.
+ *
+ * Public, no key required. Three search paths: by gene (SNP-by-gene lookup then
+ * per-SNP associations), by trait (EFO trait search then its associations), and
+ * by variant (direct rsID associations).
+ */
+import { z } from "zod";
+export interface GwasAssociation {
+    rsId: string;
+    pValue: number;
+    pValueMantissa: number;
+    pValueExponent: number;
+    riskAllele: string;
+    riskFrequency: string;
+    orBeta: number | null;
+    ci: string;
+    trait: string;
+    mappedGenes: string[];
+    studyAccession: string;
+    pubmedId: string;
+    sampleSize: string;
+}
+export type GwasSearchType = "gene" | "trait" | "variant";
+declare const RawGwasAssociationSchema: z.ZodObject<{
+    _snpRsId: z.ZodOptional<z.ZodString>;
+    loci: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        strongestRiskAlleles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            riskAlleleName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        authorReportedGenes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            geneName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    efoTraits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        trait: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    study: z.ZodOptional<z.ZodObject<{
+        accessionId: z.ZodOptional<z.ZodString>;
+        pubmedId: z.ZodOptional<z.ZodString>;
+        initialSampleSize: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    pvalueMantissa: z.ZodOptional<z.ZodNumber>;
+    pvalueExponent: z.ZodOptional<z.ZodNumber>;
+    riskFrequency: z.ZodOptional<z.ZodString>;
+    orPerCopyNum: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    betaNum: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    range: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RawGwasAssociation = z.infer<typeof RawGwasAssociationSchema>;
+export declare function mapAssociation(a: RawGwasAssociation): GwasAssociation;
+export interface GwasSearchOptions {
+    pValueThreshold?: number;
+    limit?: number;
+}
+export declare function searchGwasCatalog(query: string, searchType: GwasSearchType, options?: GwasSearchOptions): Promise<{
+    totalFound: number;
+    associations: GwasAssociation[];
+}>;
+export {};