@pdfvector/util 0.0.30 → 0.0.32

package/.tsc/lib/contract/instance/index.js

@@ -0,0 +1,7 @@
+import * as contract from "./router/index.js";
+export { contract };
+import { createORPCClient, ORPCError, onError } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+export * from "./pdfvector-model.js";
+export * from "./pdfvector-model-schema.js";
+export { createORPCClient, ORPCError, onError, RPCLink };

package/.tsc/lib/contract/instance/json-schema-input.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const jsonSchemaInput: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<unknown, string>>, z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+//# sourceMappingURL=json-schema-input.d.ts.map

package/.tsc/lib/contract/instance/json-schema-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-input.d.ts","sourceRoot":"","sources":["../../../../lib/contract/instance/json-schema-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,eAAe,2KAkB1B,CAAC"}

package/.tsc/lib/contract/instance/json-schema-input.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+const schemaObject = z.record(z.string(), z.unknown(), {
+    error: "Schema must be a JSON object",
+});
+export const jsonSchemaInput = z.union([
+    schemaObject,
+    z
+        .string()
+        .transform((str, ctx) => {
+        try {
+            const trimmed = str.startsWith('"') && str.endsWith('"') ? str.slice(1, -1) : str;
+            return JSON.parse(trimmed);
+        }
+        catch {
+            ctx.addIssue({
+                code: "custom",
+                message: "Invalid JSON string for schema",
+            });
+            return z.NEVER;
+        }
+    })
+        .pipe(schemaObject),
+]);

package/.tsc/lib/contract/instance/page-markdown-schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const pageMarkdownSchema: z.ZodObject<{
+    pageNumber: z.ZodNumber;
+    markdown: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=page-markdown-schema.d.ts.map

package/.tsc/lib/contract/instance/page-markdown-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-markdown-schema.d.ts","sourceRoot":"","sources":["../../../../lib/contract/instance/page-markdown-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;iBAO7B,CAAC"}

package/.tsc/lib/contract/instance/page-markdown-schema.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const pageMarkdownSchema = z.object({
+    pageNumber: z
+        .number()
+        .int()
+        .min(1)
+        .describe("1-based page number in the source document"),
+    markdown: z.string().describe("Extracted markdown content for this page"),
+});

package/.tsc/lib/contract/instance/pdfvector-model-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const pdfvectorModelSchema: z.ZodEnum<{
+    max: "max";
+    mini: "mini";
+    nano: "nano";
+    pro: "pro";
+}>;
+//# sourceMappingURL=pdfvector-model-schema.d.ts.map

package/.tsc/lib/contract/instance/pdfvector-model-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdfvector-model-schema.d.ts","sourceRoot":"","sources":["../../../../lib/contract/instance/pdfvector-model-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;EAE/B,CAAC"}

package/.tsc/lib/contract/instance/pdfvector-model-schema.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export const pdfvectorModelSchema = z.enum(["nano", "mini", "pro", "max"], {
+    message: "model must be one of: nano, mini, pro, max",
+});

package/.tsc/lib/contract/instance/pdfvector-model.d.ts

@@ -0,0 +1,4 @@
+import type { z } from "zod";
+import type { pdfvectorModelSchema } from "./pdfvector-model-schema.js";
+export type PDFVectorModel = z.infer<typeof pdfvectorModelSchema>;
+//# sourceMappingURL=pdfvector-model.d.ts.map

package/.tsc/lib/contract/instance/pdfvector-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdfvector-model.d.ts","sourceRoot":"","sources":["../../../../lib/contract/instance/pdfvector-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/.tsc/lib/contract/instance/router/academic/fetch.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export declare const fetch: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+    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<{
+    results: z.ZodArray<z.ZodObject<{
+        id: 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";
+        }>>>;
+        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>>;
+    errors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        error: z.ZodString;
+        code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>>;
+    requestId: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=fetch.d.ts.map

package/.tsc/lib/contract/instance/router/academic/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/academic/fetch.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuDxB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAoFf,CAAC"}

package/.tsc/lib/contract/instance/router/academic/fetch.js

@@ -0,0 +1,119 @@
+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({
+    id: z.string().describe("Original input identifier"),
+    detectedProvider: providerSchema
+        .nullish()
+        .describe("Provider that returned this result"),
+    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 fetchErrorSchema = z.object({
+    id: z.string(),
+    error: z.string(),
+    code: z.string().nullish(),
+});
+const requestExamples = {
+    "Fetch by DOI": {
+        summary: "Fetch a paper by DOI",
+        value: {
+            ids: ["10.1038/nature12373"],
+        },
+    },
+    "Fetch multiple IDs": {
+        summary: "Fetch papers by mixed identifier types",
+        value: {
+            ids: ["10.1038/nature12373", "2301.08745", "33293753"],
+        },
+    },
+    "Fetch ArXiv paper": {
+        summary: "Fetch by ArXiv ID",
+        value: {
+            ids: ["2303.08774"],
+        },
+    },
+};
+export const fetch = oc
+    .input(z.object({
+    ids: z
+        .array(z.string({ message: "Each ID must be a string" }), {
+        message: "ids is required and must be an array of strings",
+    })
+        .min(1, "ids must contain at least 1 identifier")
+        .max(100, "ids must contain at most 100 identifiers")
+        .describe("Publication identifiers to fetch. Supports DOI, PubMed ID, ArXiv ID, Semantic Scholar ID, ERIC ID, Europe PMC ID, OpenAlex ID."),
+    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({
+    results: z.array(publicationSchema),
+    errors: z.array(fetchErrorSchema).nullish(),
+    requestId: z.number().int(),
+}))
+    .route({
+    summary: "Fetch academic papers by ID",
+    description: `Fetch specific academic publications by their unique identifiers with automatic provider detection and batch processing. Costs ${academicCreditCosts.academicFetch} credits per request.`,
+    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-fetch");
+        return op;
+    },
+});

package/.tsc/lib/contract/instance/router/academic/find-citations.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export declare const findCitations: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    paragraph: z.ZodString;
+    providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        arxiv: "arxiv";
+        crossref: "crossref";
+        eric: "eric";
+        "europe-pmc": "europe-pmc";
+        "google-scholar": "google-scholar";
+        openalex: "openalex";
+        pubmed: "pubmed";
+        "semantic-scholar": "semantic-scholar";
+    }>>>;
+    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<{
+    results: z.ZodArray<z.ZodObject<{
+        sentence: z.ZodString;
+        citations: z.ZodArray<z.ZodObject<{
+            score: z.ZodNumber;
+            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>>;
+    }, z.core.$strip>>;
+    sentenceCount: z.ZodNumber;
+    totalCitations: z.ZodNumber;
+    errors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    requestId: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=find-citations.d.ts.map

package/.tsc/lib/contract/instance/router/academic/find-citations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-citations.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/academic/find-citations.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgDxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAwFvB,CAAC"}

package/.tsc/lib/contract/instance/router/academic/find-citations.js

@@ -0,0 +1,116 @@
+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 scoredPublicationSchema = z.object({
+    score: z.number().describe("Relevance score (0-10)"),
+    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 sentenceCitationSchema = z.object({
+    sentence: z.string(),
+    citations: z.array(scoredPublicationSchema),
+});
+const requestExamples = {
+    "Find citations for a paragraph": {
+        summary: "Find citations for a research paragraph",
+        value: {
+            paragraph: "Deep learning has revolutionized computer vision and natural language processing. Transformer architectures have become the dominant approach for sequence modeling tasks. Recent large language models demonstrate emergent capabilities not seen in smaller models.",
+        },
+    },
+    "Find citations with multiple providers": {
+        summary: "Search across multiple databases",
+        value: {
+            paragraph: "CRISPR-Cas9 gene editing technology has transformed molecular biology. The ability to precisely modify DNA sequences has opened new avenues for treating genetic diseases.",
+            providers: ["semantic-scholar", "pubmed"],
+        },
+    },
+};
+export const findCitations = oc
+    .input(z.object({
+    paragraph: z
+        .string({ message: "paragraph is required and must be a string" })
+        .min(1, "paragraph must not be empty")
+        .max(5000, "paragraph must be at most 5000 characters")
+        .describe("Text paragraph to find relevant academic citations for"),
+    providers: z
+        .array(providerSchema, {
+        message: "providers must be an array of valid provider names",
+    })
+        .default(["semantic-scholar"])
+        .describe("Academic databases to search for citations"),
+    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 citation 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({
+    results: z.array(sentenceCitationSchema),
+    sentenceCount: z.number().int(),
+    totalCitations: z.number().int(),
+    errors: z.array(z.string()).nullish(),
+    requestId: z.number().int(),
+}))
+    .route({
+    summary: "Find citations for a paragraph",
+    description: `Find relevant academic citations for a paragraph by splitting it into sentences and scoring papers using semantic embedding similarity. Costs ${academicCreditCosts.academicFindCitationsPerSentence} credits per sentence.`,
+    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-find-citations");
+        return op;
+    },
+});

package/.tsc/lib/contract/instance/router/academic/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./fetch.js";
+export * from "./find-citations.js";
+export * from "./paper-graph.js";
+export * from "./parse.js";
+export * from "./search.js";
+export * from "./search-grants.js";
+export * from "./similar-papers.js";
+//# sourceMappingURL=index.d.ts.map

package/.tsc/lib/contract/instance/router/academic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/academic/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}

package/.tsc/lib/contract/instance/router/academic/index.js

@@ -0,0 +1,7 @@
+export * from "./fetch.js";
+export * from "./find-citations.js";
+export * from "./paper-graph.js";
+export * from "./parse.js";
+export * from "./search.js";
+export * from "./search-grants.js";
+export * from "./similar-papers.js";

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

@@ -0,0 +1,113 @@
+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/contract/instance/router/academic/paper-graph.d.ts.map

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