@pdfvector/instance-contract 0.2.8 → 0.2.9

package/.tsc/lib/router/academic/paper-graph.d.ts

@@ -1,113 +0,0 @@
-import { z } from "zod";
-export declare const paperGraph: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
-    id: z.ZodString;
-    citationsLimit: z.ZodDefault<z.ZodNumber>;
-    referencesLimit: z.ZodDefault<z.ZodNumber>;
-    citationsOffset: z.ZodDefault<z.ZodNumber>;
-    referencesOffset: z.ZodDefault<z.ZodNumber>;
-    fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        abstract: "abstract";
-        authors: "authors";
-        date: "date";
-        doi: "doi";
-        pdfURL: "pdfURL";
-        provider: "provider";
-        providerData: "providerData";
-        providerURL: "providerURL";
-        title: "title";
-        totalCitations: "totalCitations";
-        totalReferences: "totalReferences";
-        url: "url";
-        year: "year";
-    }>>>>;
-    callback: z.ZodOptional<z.ZodObject<{
-        url: z.ZodURL;
-        type: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    paper: z.ZodObject<{
-        doi: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        providerURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>>>;
-        date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalCitations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalReferences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        pdfURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            arxiv: "arxiv";
-            crossref: "crossref";
-            eric: "eric";
-            "europe-pmc": "europe-pmc";
-            "google-scholar": "google-scholar";
-            openalex: "openalex";
-            pubmed: "pubmed";
-            "semantic-scholar": "semantic-scholar";
-        }>>>;
-        providerData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>;
-    citations: z.ZodArray<z.ZodObject<{
-        doi: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        providerURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>>>;
-        date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalCitations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalReferences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        pdfURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            arxiv: "arxiv";
-            crossref: "crossref";
-            eric: "eric";
-            "europe-pmc": "europe-pmc";
-            "google-scholar": "google-scholar";
-            openalex: "openalex";
-            pubmed: "pubmed";
-            "semantic-scholar": "semantic-scholar";
-        }>>>;
-        providerData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>>;
-    references: z.ZodArray<z.ZodObject<{
-        doi: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        providerURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        authors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>>>;
-        date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalCitations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        totalReferences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        pdfURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            arxiv: "arxiv";
-            crossref: "crossref";
-            eric: "eric";
-            "europe-pmc": "europe-pmc";
-            "google-scholar": "google-scholar";
-            openalex: "openalex";
-            pubmed: "pubmed";
-            "semantic-scholar": "semantic-scholar";
-        }>>>;
-        providerData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>>;
-    totalCitations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    totalReferences: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    requestId: z.ZodNumber;
-}, z.core.$strip>, Record<never, never>, Record<never, never>>;
-//# sourceMappingURL=paper-graph.d.ts.map

package/.tsc/lib/router/academic/paper-graph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paper-graph.d.ts","sourceRoot":"","sources":["../../../../lib/router/academic/paper-graph.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoDxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA+GpB,CAAC"}

package/.tsc/lib/router/academic/paper-graph.js

@@ -1,144 +0,0 @@
-import { oc } from "@orpc/contract";
-import { getOpenApiCodeSamples } from "@pdfvector/api-docs";
-import { academicCreditCosts } from "@pdfvector/util";
-import { z } from "zod";
-import { providerSchema } from "./provider.js";
-const authorSchema = z.object({
-    name: z.string(),
-    url: z.string().nullish(),
-});
-const publicationSchema = z.object({
-    doi: z.string().nullish(),
-    title: z.string().nullish(),
-    url: z.string().nullish(),
-    providerURL: z.string().nullish(),
-    authors: z.array(authorSchema).nullish(),
-    date: z.string().nullish(),
-    year: z.number().nullish(),
-    totalCitations: z.number().nullish(),
-    totalReferences: z.number().nullish(),
-    abstract: z.string().nullish(),
-    pdfURL: z.string().nullish(),
-    provider: providerSchema.nullish(),
-    providerData: z.record(z.string(), z.unknown()).nullish(),
-});
-const requestExamples = {
-    "Get citations by DOI": {
-        summary: "Get citations and references for a paper by DOI",
-        value: {
-            id: "10.1038/nature12373",
-            citationsLimit: 20,
-            referencesLimit: 20,
-        },
-    },
-    "Get citations by ArXiv ID": {
-        summary: "Get citations and references for an ArXiv paper",
-        value: {
-            id: "2303.08774",
-            citationsLimit: 50,
-            referencesLimit: 50,
-        },
-    },
-    "Paginated citations": {
-        summary: "Page through a paper's citations",
-        value: {
-            id: "10.1038/nature12373",
-            citationsLimit: 20,
-            citationsOffset: 20,
-            referencesLimit: 0,
-        },
-    },
-};
-export const paperGraph = oc
-    .input(z.object({
-    id: z
-        .string({ message: "id is required and must be a string" })
-        .min(1, "id must not be empty")
-        .max(500, "id must be at most 500 characters")
-        .describe("Paper identifier. Supports DOI, Semantic Scholar ID, ArXiv ID, PubMed ID, OpenAlex ID, or URL."),
-    citationsLimit: z
-        .number({ message: "citationsLimit must be a number" })
-        .int("citationsLimit must be a whole number")
-        .min(0, "citationsLimit must be 0 or greater")
-        .max(1000, "citationsLimit must be at most 1000")
-        .default(100)
-        .describe("Maximum number of citing papers to return"),
-    referencesLimit: z
-        .number({ message: "referencesLimit must be a number" })
-        .int("referencesLimit must be a whole number")
-        .min(0, "referencesLimit must be 0 or greater")
-        .max(1000, "referencesLimit must be at most 1000")
-        .default(100)
-        .describe("Maximum number of referenced papers to return"),
-    citationsOffset: z
-        .number({ message: "citationsOffset must be a number" })
-        .int("citationsOffset must be a whole number")
-        .min(0, "citationsOffset must be 0 or greater")
-        .default(0)
-        .describe("Pagination offset for citations"),
-    referencesOffset: z
-        .number({ message: "referencesOffset must be a number" })
-        .int("referencesOffset must be a whole number")
-        .min(0, "referencesOffset must be 0 or greater")
-        .default(0)
-        .describe("Pagination offset for references"),
-    fields: z
-        .array(z.enum([
-        "doi",
-        "title",
-        "url",
-        "providerURL",
-        "authors",
-        "date",
-        "year",
-        "totalCitations",
-        "totalReferences",
-        "abstract",
-        "pdfURL",
-        "provider",
-        "providerData",
-    ]), {
-        message: "fields must be an array of valid publication field names",
-    })
-        .nullish()
-        .describe("Specific publication fields to return. If omitted, returns all fields except providerData."),
-    callback: z
-        .object({
-        url: z
-            .url()
-            .describe("Webhook URL where results will be POSTed when processing completes"),
-        type: z
-            .string()
-            .optional()
-            .describe("Callback type identifier (e.g. 'zapier')"),
-    })
-        .optional()
-        .describe("Optional webhook callback for async processing. " +
-        "When provided, the server returns 202 immediately and POSTs the full response payload to the callback URL when processing completes. " +
-        "On error, the callback receives a POST with X-Pdfvector-Callback-Failed: true header and error details in the body. " +
-        "Useful for long-running operations that may exceed client timeout limits."),
-}))
-    .output(z.object({
-    paper: publicationSchema,
-    citations: z.array(publicationSchema),
-    references: z.array(publicationSchema),
-    totalCitations: z.number().int().nullish(),
-    totalReferences: z.number().int().nullish(),
-    requestId: z.number().int(),
-}))
-    .route({
-    summary: "Get paper citations and references",
-    description: `Fetch a paper's citing papers and referenced papers as full publication objects with automatic provider detection and pagination support. Costs ${academicCreditCosts.academicPaperGraphMin}+ credits per request (scales with result count).`,
-    tags: ["Academic"],
-    spec: (op) => {
-        op.security = [{ bearerAuth: [] }];
-        const reqBody = op.requestBody;
-        if (reqBody?.content) {
-            for (const mediaType of Object.values(reqBody.content)) {
-                mediaType["examples"] = requestExamples;
-            }
-        }
-        op["x-codeSamples"] = getOpenApiCodeSamples("academic-paper-graph");
-        return op;
-    },
-});

package/.tsc/lib/router/academic/parse.d.ts

@@ -1,50 +0,0 @@
-import { z } from "zod";
-export declare const parse: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    url: z.ZodOptional<z.ZodURL>;
-    model: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        auto: "auto";
-        max: "max";
-        mini: "mini";
-        nano: "nano";
-        pro: "pro";
-    }>>>;
-    includePages: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    callback: z.ZodOptional<z.ZodObject<{
-        url: z.ZodURL;
-        type: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    doi: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    providerURL: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    pdfURL: z.ZodString;
-    detectedProvider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        arxiv: "arxiv";
-        crossref: "crossref";
-        eric: "eric";
-        "europe-pmc": "europe-pmc";
-        "google-scholar": "google-scholar";
-        openalex: "openalex";
-        pubmed: "pubmed";
-        "semantic-scholar": "semantic-scholar";
-    }>>>;
-    markdown: z.ZodString;
-    pageCount: z.ZodNumber;
-    model: z.ZodEnum<{
-        max: "max";
-        mini: "mini";
-        nano: "nano";
-        pro: "pro";
-    }>;
-    credits: z.ZodNumber;
-    requestId: z.ZodNumber;
-    html: z.ZodOptional<z.ZodString>;
-    pages: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        pageNumber: z.ZodNumber;
-        markdown: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>, Record<never, never>, Record<never, never>>;
-//# sourceMappingURL=parse.d.ts.map

package/.tsc/lib/router/academic/parse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../lib/router/academic/parse.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqJxB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAyBf,CAAC"}

package/.tsc/lib/router/academic/parse.js

@@ -1,146 +0,0 @@
-import { oc } from "@orpc/contract";
-import { academicParseOpenApiCodeSamples } from "@pdfvector/api-docs";
-import { z } from "zod";
-import { fetchableUrlSchema } from "../../fetchable-url-schema.js";
-import { pageMarkdownSchema } from "../../page-markdown-schema.js";
-import { pdfvectorModelSchema } from "../../pdfvector-model-schema.js";
-import { documentParseModelDescription, outputModelDescription, } from "../../supported-mimes.js";
-import { providerSchema } from "./provider.js";
-const callbackSchema = z
-    .object({
-    url: fetchableUrlSchema.describe("Webhook URL where results will be POSTed when processing completes"),
-    type: z
-        .string()
-        .optional()
-        .describe("Callback type identifier (e.g. 'zapier')"),
-})
-    .optional()
-    .describe("Optional webhook callback for async processing. " +
-    "When provided, the server returns 202 immediately and POSTs the full response payload to the callback URL when processing completes. " +
-    "On error, the callback receives a POST with X-Pdfvector-Callback-Failed: true header and error details in the body. " +
-    "Useful for long-running operations that may exceed client timeout limits.");
-const parseInputSchema = z
-    .object({
-    id: z
-        .string({ message: "id must be a string" })
-        .trim()
-        .min(1, "id must be a non-empty string")
-        .optional()
-        .describe("Publication identifier to resolve and parse. Supports DOI, PubMed ID, ArXiv ID, Semantic Scholar ID, ERIC ID, Europe PMC ID, OpenAlex ID."),
-    url: fetchableUrlSchema
-        .optional()
-        .describe("Publication URL to resolve and parse. Supports known provider URLs such as DOI, ArXiv, PubMed, Semantic Scholar, ERIC, Europe PMC, OpenAlex, Springer, Nature, bioRxiv, and medRxiv."),
-    model: z
-        .enum(["auto", ...pdfvectorModelSchema.options])
-        .optional()
-        .default("auto")
-        .describe(documentParseModelDescription),
-    includePages: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Set to true to include page-separated markdown in the pages array. Existing markdown output is still returned as the full paper text."),
-    callback: callbackSchema,
-})
-    .superRefine((input, ctx) => {
-    const hasId = typeof input.id === "string" && input.id.length > 0;
-    const hasUrl = typeof input.url === "string" && input.url.length > 0;
-    if (hasId === hasUrl) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["id"],
-            message: "Provide exactly one of id or url",
-        });
-    }
-});
-const parseOutputSchema = z.object({
-    id: z.string().describe("Original input identifier or URL"),
-    title: z.string().nullish().describe("Publication title, if available"),
-    doi: z.string().nullish().describe("Publication DOI, if available"),
-    url: z
-        .string()
-        .nullish()
-        .describe("PDF Vector publication URL, if available"),
-    providerURL: z
-        .string()
-        .nullish()
-        .describe("Provider publication page URL, if available"),
-    pdfURL: z.string().describe("Resolved public PDF URL used for parsing"),
-    detectedProvider: providerSchema
-        .nullish()
-        .describe("Provider detected from the input identifier or URL"),
-    markdown: z
-        .string()
-        .describe("Extracted markdown content from the paper PDF"),
-    pageCount: z
-        .number()
-        .int()
-        .describe("Total number of pages in the paper PDF"),
-    model: pdfvectorModelSchema.describe(outputModelDescription),
-    credits: z
-        .number()
-        .int()
-        .describe("Number of credits consumed by this API call. Cost per page: nano=1, mini=2, pro=4, max=8."),
-    requestId: z
-        .number()
-        .int()
-        .describe("Unique request identifier for this API call"),
-    html: z
-        .string()
-        .optional()
-        .describe("Full HTML representation of the paper content. Only available when using the 'max' model."),
-    pages: z
-        .array(pageMarkdownSchema)
-        .optional()
-        .describe("Page-separated markdown content. Returned only when includePages is true."),
-});
-const requestExamples = {
-    "Parse ArXiv paper by ID": {
-        summary: "Parse ArXiv paper by ID",
-        value: {
-            id: "1706.03762",
-            model: "auto",
-        },
-    },
-    "Parse paper by DOI URL": {
-        summary: "Parse paper by DOI URL",
-        value: {
-            url: "https://doi.org/10.1038/nature12373",
-            model: "pro",
-        },
-    },
-    "Parse PubMed paper by ID": {
-        summary: "Parse PubMed paper by ID",
-        value: {
-            id: "33116299",
-            model: "auto",
-        },
-    },
-    "Parse paper with page-separated output": {
-        summary: "Parse paper with page-separated output",
-        value: {
-            id: "1706.03762",
-            model: "auto",
-            includePages: true,
-        },
-    },
-};
-export const parse = oc
-    .input(parseInputSchema)
-    .output(parseOutputSchema)
-    .route({
-    summary: "Parse an academic paper to markdown",
-    description: "Resolve an academic paper URL or identifier to a public PDF URL, parse the PDF, and return markdown using the same model tiers as document.parse. Returns NOT_FOUND when the paper cannot be found or no public PDF is available.",
-    tags: ["Academic"],
-    spec: (op) => {
-        op.security = [{ bearerAuth: [] }];
-        const reqBody = op.requestBody;
-        if (reqBody?.content) {
-            for (const mediaType of Object.values(reqBody.content)) {
-                mediaType["examples"] = requestExamples;
-            }
-        }
-        op["x-codeSamples"] = academicParseOpenApiCodeSamples;
-        return op;
-    },
-});

package/.tsc/lib/router/academic/provider.d.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-export declare const providerSchema: z.ZodEnum<{
-    arxiv: "arxiv";
-    crossref: "crossref";
-    eric: "eric";
-    "europe-pmc": "europe-pmc";
-    "google-scholar": "google-scholar";
-    openalex: "openalex";
-    pubmed: "pubmed";
-    "semantic-scholar": "semantic-scholar";
-}>;
-export declare const grantProviderSchema: z.ZodEnum<{
-    cordis: "cordis";
-    "grants-gov": "grants-gov";
-    "nih-reporter": "nih-reporter";
-    ukri: "ukri";
-}>;
-//# sourceMappingURL=provider.d.ts.map

package/.tsc/lib/router/academic/provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../lib/router/academic/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;EAe1B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;EAM/B,CAAC"}

package/.tsc/lib/router/academic/provider.js

@@ -1,16 +0,0 @@
-import { z } from "zod";
-export const providerSchema = z.enum([
-    "semantic-scholar",
-    "pubmed",
-    "arxiv",
-    "google-scholar",
-    "eric",
-    "europe-pmc",
-    "openalex",
-    "crossref",
-], {
-    message: "Invalid provider. Must be one of: semantic-scholar, pubmed, arxiv, google-scholar, eric, europe-pmc, openalex, crossref",
-});
-export const grantProviderSchema = z.enum(["grants-gov", "nih-reporter", "cordis", "ukri"], {
-    message: "Invalid provider. Must be one of: grants-gov, nih-reporter, cordis, ukri",
-});

package/.tsc/lib/router/academic/search-grants.d.ts

@@ -1,84 +0,0 @@
-import { z } from "zod";
-export declare const searchGrants: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
-    query: z.ZodString;
-    providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        cordis: "cordis";
-        "grants-gov": "grants-gov";
-        "nih-reporter": "nih-reporter";
-        ukri: "ukri";
-    }>>>;
-    offset: z.ZodDefault<z.ZodNumber>;
-    limit: z.ZodDefault<z.ZodNumber>;
-    deadlineFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    deadlineTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    fundingMin: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    fundingMax: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        agency: "agency";
-        closeDate: "closeDate";
-        currency: "currency";
-        deadlineDate: "deadlineDate";
-        description: "description";
-        eligibility: "eligibility";
-        fundingAmountMax: "fundingAmountMax";
-        fundingAmountMin: "fundingAmountMin";
-        grantType: "grantType";
-        keywords: "keywords";
-        openDate: "openDate";
-        organizationName: "organizationName";
-        piName: "piName";
-        program: "program";
-        provider: "provider";
-        providerData: "providerData";
-        region: "region";
-        sourceId: "sourceId";
-        title: "title";
-        url: "url";
-    }>>>>;
-    callback: z.ZodOptional<z.ZodObject<{
-        url: z.ZodURL;
-        type: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    estimatedTotalResults: z.ZodNumber;
-    results: z.ZodArray<z.ZodObject<{
-        sourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        agency: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        program: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        eligibility: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        fundingAmountMin: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        fundingAmountMax: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        currency: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        deadlineDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        openDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        closeDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        grantType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        keywords: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-        piName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        organizationName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            cordis: "cordis";
-            "grants-gov": "grants-gov";
-            "nih-reporter": "nih-reporter";
-            ukri: "ukri";
-        }>>>;
-        providerData: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>>;
-    errors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
-        provider: z.ZodEnum<{
-            cordis: "cordis";
-            "grants-gov": "grants-gov";
-            "nih-reporter": "nih-reporter";
-            ukri: "ukri";
-        }>;
-        message: z.ZodString;
-        code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    }, z.core.$strip>>>>;
-    requestId: z.ZodNumber;
-}, z.core.$strip>, Record<never, never>, Record<never, never>>;
-//# sourceMappingURL=search-grants.d.ts.map

package/.tsc/lib/router/academic/search-grants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search-grants.d.ts","sourceRoot":"","sources":["../../../../lib/router/academic/search-grants.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8DxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAwItB,CAAC"}