@pdfvector/util 0.0.30 → 0.0.32

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

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const search: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    query: 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";
+    }>>>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    yearFrom: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    yearTo: z.ZodOptional<z.ZodNullable<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<{
+    estimatedTotalResults: z.ZodNumber;
+    results: 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>>;
+    errors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        provider: z.ZodEnum<{
+            arxiv: "arxiv";
+            crossref: "crossref";
+            eric: "eric";
+            "europe-pmc": "europe-pmc";
+            "google-scholar": "google-scholar";
+            openalex: "openalex";
+            pubmed: "pubmed";
+            "semantic-scholar": "semantic-scholar";
+        }>;
+        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.d.ts.map

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

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

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

@@ -0,0 +1,154 @@
+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 providerErrorSchema = z.object({
+    provider: providerSchema,
+    message: z.string(),
+    code: z.string().nullish(),
+    details: z.record(z.string(), z.unknown()).nullish(),
+});
+const requestExamples = {
+    "Search with default provider": {
+        summary: "Search with Semantic Scholar",
+        value: {
+            query: "deep learning for natural language processing",
+        },
+    },
+    "Search multiple providers": {
+        summary: "Search across multiple databases",
+        value: {
+            query: "CRISPR gene editing",
+            providers: ["semantic-scholar", "pubmed", "openalex"],
+            limit: 10,
+        },
+    },
+    "Search with year filter": {
+        summary: "Search recent papers",
+        value: {
+            query: "large language models",
+            providers: ["semantic-scholar"],
+            yearFrom: 2023,
+            yearTo: 2026,
+            limit: 20,
+        },
+    },
+};
+export const search = oc
+    .input(z.object({
+    query: z
+        .string({ message: "query is required and must be a string" })
+        .min(1, "query must not be empty")
+        .max(400, "query must be at most 400 characters")
+        .describe("Search query string for academic papers"),
+    providers: z
+        .array(providerSchema, {
+        message: "providers must be an array of valid provider names",
+    })
+        .default(["semantic-scholar"])
+        .describe("Academic databases to search"),
+    offset: z
+        .number({ message: "offset must be a number" })
+        .int("offset must be a whole number")
+        .min(0, "offset must be 0 or greater")
+        .default(0)
+        .describe("Results offset"),
+    limit: z
+        .number({ message: "limit must be a number" })
+        .int("limit must be a whole number")
+        .min(1, "limit must be at least 1")
+        .max(100, "limit must be at most 100")
+        .default(20)
+        .describe("Results per provider"),
+    yearFrom: z
+        .number({ message: "yearFrom must be a number" })
+        .int("yearFrom must be a whole number")
+        .min(1900, "yearFrom must be 1900 or later")
+        .max(2100, "yearFrom must be 2100 or earlier")
+        .nullish()
+        .describe("Filter papers published from this year"),
+    yearTo: z
+        .number({ message: "yearTo must be a number" })
+        .int("yearTo must be a whole number")
+        .min(1900, "yearTo must be 1900 or later")
+        .max(2100, "yearTo must be 2100 or earlier")
+        .nullish()
+        .describe("Filter papers published up to this year"),
+    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({
+    estimatedTotalResults: z.number(),
+    results: z.array(publicationSchema),
+    errors: z.array(providerErrorSchema).nullish(),
+    requestId: z.number().int(),
+}))
+    .route({
+    summary: "Search academic papers",
+    description: `Search for academic publications across multiple databases with relevance ranking. Costs ${academicCreditCosts.academicSearch} 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-search");
+        return op;
+    },
+});

package/.tsc/lib/contract/instance/router/academic/similar-papers.d.ts

@@ -0,0 +1,89 @@
+import { z } from "zod";
+export declare const similarPapers: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    includeEdges: z.ZodDefault<z.ZodBoolean>;
+    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<{
+    seed: 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>;
+    results: z.ZodArray<z.ZodObject<{
+        publication: 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>;
+        similarity: z.ZodNumber;
+        pageRank: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        distance: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        citingIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        citedByIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+    requestId: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=similar-papers.d.ts.map

package/.tsc/lib/contract/instance/router/academic/similar-papers.d.ts.map

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

package/.tsc/lib/contract/instance/router/academic/similar-papers.js

@@ -0,0 +1,143 @@
+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 similarPaperSchema = z.object({
+    publication: publicationSchema,
+    similarity: z
+        .number()
+        .describe("Combined similarity score from citation network analysis"),
+    pageRank: z.number().nullish().describe("Citation network importance score"),
+    distance: z
+        .number()
+        .int()
+        .nullish()
+        .describe("Graph distance from seed paper"),
+    citingIds: z
+        .array(z.string())
+        .nullish()
+        .describe("OpenAlex IDs of papers in result set that cite this paper (only if includeEdges=true)"),
+    citedByIds: z
+        .array(z.string())
+        .nullish()
+        .describe("OpenAlex IDs of papers in result set cited by this paper (only if includeEdges=true)"),
+});
+const requestExamples = {
+    "Find similar papers by DOI": {
+        summary: "Find papers similar to a given paper",
+        value: {
+            id: "10.1038/nature12373",
+            limit: 20,
+        },
+    },
+    "Find similar with edges": {
+        summary: "Find similar papers with citation graph edges",
+        value: {
+            id: "10.1038/nature12373",
+            limit: 20,
+            includeEdges: true,
+        },
+    },
+    "Find similar by OpenAlex ID": {
+        summary: "Find similar papers using an OpenAlex ID",
+        value: {
+            id: "W2963403868",
+            limit: 10,
+        },
+    },
+};
+export const similarPapers = 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("Seed paper identifier. Supports DOI, Semantic Scholar ID, ArXiv ID, PubMed ID, OpenAlex ID, or URL."),
+    limit: z
+        .number({ message: "limit must be a number" })
+        .int("limit must be a whole number")
+        .min(1, "limit must be at least 1")
+        .max(100, "limit must be at most 100")
+        .default(30)
+        .describe("Maximum number of similar papers to return"),
+    includeEdges: z
+        .boolean({ message: "includeEdges must be a boolean" })
+        .default(false)
+        .describe("Whether to include citing/cited_by edge data for graph construction"),
+    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({
+    seed: publicationSchema,
+    results: z.array(similarPaperSchema),
+    requestId: z.number().int(),
+}))
+    .route({
+    summary: "Find similar papers",
+    description: `Find papers similar to a seed paper using citation network analysis. Returns papers ranked by similarity with optional graph edge data for visualization. Costs ${academicCreditCosts.academicSimilarPapers} 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-similar-papers");
+        return op;
+    },
+});

package/.tsc/lib/contract/instance/router/admin/get-environment.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const getEnvironment: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+    environment: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=get-environment.d.ts.map

package/.tsc/lib/contract/instance/router/admin/get-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-environment.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/admin/get-environment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;8DAW0C,CAAC"}

package/.tsc/lib/contract/instance/router/admin/get-environment.js

@@ -0,0 +1,13 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+export const getEnvironment = oc
+    .route({
+    summary: "Get instance server's environment",
+    description: "Return all environment variables available to the instance server process",
+    tags: ["Admin"],
+    spec: (op) => {
+        op.security = [{ bearerAuth: [] }];
+        return op;
+    },
+})
+    .output(z.object({ environment: z.record(z.string(), z.string()) }));

package/.tsc/lib/contract/instance/router/admin/get-free-usage-records.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const getFreeUsageRecords: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    cursor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        operation: z.ZodString;
+        ip: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        inputSource: z.ZodNullable<z.ZodString>;
+        inputRef: z.ZodNullable<z.ZodString>;
+        fileSize: z.ZodNullable<z.ZodNumber>;
+        documentType: z.ZodNullable<z.ZodString>;
+        pageCount: z.ZodNullable<z.ZodNumber>;
+        error: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            success: "success";
+            system_error: "system_error";
+            user_error: "user_error";
+        }>;
+        errorStage: z.ZodNullable<z.ZodEnum<{
+            auth: "auth";
+            preprocessing: "preprocessing";
+            processing: "processing";
+            validation: "validation";
+        }>>;
+        errorCode: z.ZodNullable<z.ZodString>;
+        duration: z.ZodNumber;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=get-free-usage-records.d.ts.map

package/.tsc/lib/contract/instance/router/admin/get-free-usage-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-free-usage-records.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/admin/get-free-usage-records.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAsB9B,CAAC"}

package/.tsc/lib/contract/instance/router/admin/get-free-usage-records.js

@@ -0,0 +1,38 @@
+import { oc } from "@orpc/contract";
+import { errorStages, usageStatuses } from "@pdfvector/util";
+import { z } from "zod";
+const freeUsageRecordSchema = z.object({
+    id: z.number(),
+    operation: z.string(),
+    ip: z.string(),
+    model: z.string().nullable(),
+    inputSource: z.string().nullable(),
+    inputRef: z.string().nullable(),
+    fileSize: z.number().nullable(),
+    documentType: z.string().nullable(),
+    pageCount: z.number().nullable(),
+    error: z.string().nullable(),
+    status: z.enum(usageStatuses),
+    errorStage: z.enum(errorStages).nullable(),
+    errorCode: z.string().nullable(),
+    duration: z.number(),
+    createdAt: z.number(),
+});
+export const getFreeUsageRecords = oc
+    .route({
+    summary: "Get free usage records",
+    description: "Returns free usage records with id > cursor, ordered by id ascending",
+    tags: ["Admin"],
+    spec: (op) => {
+        op.security = [{ bearerAuth: [] }];
+        return op;
+    },
+})
+    .input(z.object({
+    cursor: z.number().optional().default(0),
+    limit: z.number().optional().default(1000),
+}))
+    .output(z.object({
+    records: z.array(freeUsageRecordSchema),
+    hasMore: z.boolean(),
+}));

package/.tsc/lib/contract/instance/router/admin/get-provider-usage-records.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const getProviderUsageRecords: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    cursor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        apiUsageId: z.ZodNullable<z.ZodNumber>;
+        operation: z.ZodString;
+        phase: z.ZodString;
+        provider: z.ZodString;
+        service: z.ZodString;
+        providerModel: z.ZodNullable<z.ZodString>;
+        providerRegion: z.ZodNullable<z.ZodString>;
+        providerResource: z.ZodNullable<z.ZodString>;
+        documentType: z.ZodNullable<z.ZodString>;
+        fileSize: z.ZodNullable<z.ZodNumber>;
+        pageCount: z.ZodNullable<z.ZodNumber>;
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        uncachedInputTokens: z.ZodNullable<z.ZodNumber>;
+        cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+        cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        reasoningTokens: z.ZodNullable<z.ZodNumber>;
+        totalTokens: z.ZodNullable<z.ZodNumber>;
+        featuresJson: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            success: "success";
+            system_error: "system_error";
+            user_error: "user_error";
+        }>;
+        error: z.ZodNullable<z.ZodString>;
+        duration: z.ZodNumber;
+        estimatedCostUsdMicro: z.ZodNullable<z.ZodNumber>;
+        pricingVersion: z.ZodNullable<z.ZodString>;
+        rawUsageJson: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=get-provider-usage-records.d.ts.map

package/.tsc/lib/contract/instance/router/admin/get-provider-usage-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-provider-usage-records.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/admin/get-provider-usage-records.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgCxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAsBlC,CAAC"}