@pdfvector/util 0.0.31 → 0.1.0

package/.tsc/lib/contract/gateway/router/feedback.js

@@ -0,0 +1,15 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const feedbackTypeSchema = z.enum([
+    "bug",
+    "feature",
+    "improvement",
+    "question",
+    "other",
+]);
+export const submit = oc
+    .input(z.object({
+    type: feedbackTypeSchema,
+    message: z.string().min(10).max(500),
+}))
+    .output(z.object({ id: z.number() }));

package/.tsc/lib/contract/gateway/router/free-feedback.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod";
+export declare const submit: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    tool: z.ZodEnum<{
+        bankStatementConverter: "bankStatementConverter";
+        doiToPdf: "doiToPdf";
+        jsonSchemaEditor: "jsonSchemaEditor";
+    }>;
+    type: z.ZodEnum<{
+        bug: "bug";
+        feature: "feature";
+        improvement: "improvement";
+        other: "other";
+    }>;
+    message: z.ZodString;
+    email: z.ZodEmail;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=free-feedback.d.ts.map

package/.tsc/lib/contract/gateway/router/free-feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"free-feedback.d.ts","sourceRoot":"","sources":["../../../../../lib/contract/gateway/router/free-feedback.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;8DASmB,CAAC"}

package/.tsc/lib/contract/gateway/router/free-feedback.js

@@ -0,0 +1,10 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+export const submit = oc
+    .input(z.object({
+    tool: z.enum(["bankStatementConverter", "jsonSchemaEditor", "doiToPdf"]),
+    type: z.enum(["feature", "bug", "improvement", "other"]),
+    message: z.string().min(10).max(500),
+    email: z.email(),
+}))
+    .output(z.object({ id: z.number() }));

package/.tsc/lib/contract/gateway/router/greeting.d.ts

@@ -0,0 +1,7 @@
+import * as z from "zod";
+export declare const greeting: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=greeting.d.ts.map

package/.tsc/lib/contract/gateway/router/greeting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greeting.d.ts","sourceRoot":"","sources":["../../../../../lib/contract/gateway/router/greeting.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,QAAQ;;;;8DAES,CAAC"}

package/.tsc/lib/contract/gateway/router/greeting.js

@@ -0,0 +1,11 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const greetingInputSchema = z.object({
+    name: z.string(),
+});
+const greetingOutputSchema = z.object({
+    message: z.string(),
+});
+export const greeting = oc
+    .input(greetingInputSchema)
+    .output(greetingOutputSchema);

package/.tsc/lib/contract/gateway/router/health.d.ts

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

package/.tsc/lib/contract/gateway/router/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../../../lib/contract/gateway/router/health.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAMzB,eAAO,MAAM,MAAM;;8DAAgC,CAAC"}

package/.tsc/lib/contract/gateway/router/health.js

@@ -0,0 +1,6 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const healthOutputSchema = z.object({
+    status: z.string(),
+});
+export const health = oc.output(healthOutputSchema);

package/.tsc/lib/contract/gateway/router/index.d.ts

@@ -0,0 +1,10 @@
+export * as admin from "./admin.js";
+export * as billing from "./billing.js";
+export * as blog from "./blog.js";
+export * as feedback from "./feedback.js";
+export * as freeFeedback from "./free-feedback.js";
+export * from "./greeting.js";
+export * from "./health.js";
+export * as instance from "./instance.js";
+export * as workspace from "./workspace.js";
+//# sourceMappingURL=index.d.ts.map

package/.tsc/lib/contract/gateway/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/contract/gateway/router/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC"}

package/.tsc/lib/contract/gateway/router/index.js

@@ -0,0 +1,9 @@
+export * as admin from "./admin.js";
+export * as billing from "./billing.js";
+export * as blog from "./blog.js";
+export * as feedback from "./feedback.js";
+export * as freeFeedback from "./free-feedback.js";
+export * from "./greeting.js";
+export * from "./health.js";
+export * as instance from "./instance.js";
+export * as workspace from "./workspace.js";

package/.tsc/lib/contract/gateway/router/instance/api-keys.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod";
+export declare const listApiKeys: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    instanceId: z.ZodNumber;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    key: z.ZodString;
+    createdAt: z.ZodDate;
+}, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+export declare const createApiKey: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    instanceId: z.ZodNumber;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    key: z.ZodString;
+    createdAt: z.ZodDate;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const deleteApiKey: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    instanceId: z.ZodNumber;
+    apiKeyId: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const rotateApiKey: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=api-keys.d.ts.map

package/.tsc/lib/contract/gateway/router/instance/api-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-keys.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/instance/api-keys.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AASzB,eAAO,MAAM,WAAW;;;;;;;+DAEO,CAAC;AAEhC,eAAO,MAAM,YAAY;;;;;;;;8DAEH,CAAC;AAEvB,eAAO,MAAM,YAAY;;;;;8DAEmB,CAAC;AAE7C,eAAO,MAAM,YAAY;;;;8DAEc,CAAC"}

package/.tsc/lib/contract/gateway/router/instance/api-keys.js

@@ -0,0 +1,20 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const apiKeySchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    key: z.string(),
+    createdAt: z.date(),
+});
+export const listApiKeys = oc
+    .input(z.object({ instanceId: z.number() }))
+    .output(z.array(apiKeySchema));
+export const createApiKey = oc
+    .input(z.object({ instanceId: z.number(), name: z.string().min(1).max(100) }))
+    .output(apiKeySchema);
+export const deleteApiKey = oc
+    .input(z.object({ instanceId: z.number(), apiKeyId: z.number() }))
+    .output(z.object({ success: z.boolean() }));
+export const rotateApiKey = oc
+    .input(z.object({ id: z.number() }))
+    .output(z.object({ key: z.string() }));

package/.tsc/lib/contract/gateway/router/instance/instances.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod";
+export declare const list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    domain: z.ZodString;
+    isGeneral: z.ZodBoolean;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+export declare const get: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    domain: z.ZodString;
+    isGeneral: z.ZodBoolean;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    lastSyncedAt: z.ZodNullable<z.ZodDate>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    domain: z.ZodString;
+    isGeneral: z.ZodBoolean;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const remove: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=instances.d.ts.map

package/.tsc/lib/contract/gateway/router/instance/instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/instance/instances.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAYzB,eAAO,MAAM,IAAI;;;;;;;;+DAAqC,CAAC;AAEvD,eAAO,MAAM,GAAG;;;;;;;;;;;8DAEsD,CAAC;AAEvE,eAAO,MAAM,MAAM;;;;;;;;;;;8DAOK,CAAC;AAEzB,eAAO,MAAM,MAAM;;;;8DAEyB,CAAC"}

package/.tsc/lib/contract/gateway/router/instance/instances.js

@@ -0,0 +1,24 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const instanceSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    description: z.string().nullable(),
+    domain: z.string(),
+    isGeneral: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export const list = oc.output(z.array(instanceSchema));
+export const get = oc
+    .input(z.object({ id: z.number() }))
+    .output(instanceSchema.extend({ lastSyncedAt: z.date().nullable() }));
+export const create = oc
+    .input(z.object({
+    name: z.string().min(1).max(255),
+    description: z.string().max(1000).optional(),
+}))
+    .output(instanceSchema);
+export const remove = oc
+    .input(z.object({ id: z.number() }))
+    .output(z.object({ success: z.boolean() }));

package/.tsc/lib/contract/gateway/router/instance/proxy.d.ts

@@ -0,0 +1,50 @@
+import * as z from "zod";
+export declare const proxyRequest: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    instanceId: z.ZodNumber;
+    apiGroup: z.ZodEnum<{
+        academic: "academic";
+        bankStatement: "bankStatement";
+        document: "document";
+        identity: "identity";
+        invoice: "invoice";
+    }>;
+    operation: z.ZodEnum<{
+        ask: "ask";
+        extract: "extract";
+        fetch: "fetch";
+        findCitations: "findCitations";
+        paperGraph: "paperGraph";
+        parse: "parse";
+        search: "search";
+        searchGrants: "searchGrants";
+        similarPapers: "similarPapers";
+    }>;
+    model: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    base64: z.ZodOptional<z.ZodString>;
+    includePages: z.ZodOptional<z.ZodBoolean>;
+    question: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodString>;
+    documentId: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    paragraph: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    yearFrom: z.ZodOptional<z.ZodNumber>;
+    yearTo: z.ZodOptional<z.ZodNumber>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodOptional<z.ZodString>;
+    citationsLimit: z.ZodOptional<z.ZodNumber>;
+    referencesLimit: z.ZodOptional<z.ZodNumber>;
+    citationsOffset: z.ZodOptional<z.ZodNumber>;
+    referencesOffset: z.ZodOptional<z.ZodNumber>;
+    includeEdges: z.ZodOptional<z.ZodBoolean>;
+    deadlineFrom: z.ZodOptional<z.ZodString>;
+    deadlineTo: z.ZodOptional<z.ZodString>;
+    fundingMin: z.ZodOptional<z.ZodNumber>;
+    fundingMax: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=proxy.d.ts.map

package/.tsc/lib/contract/gateway/router/instance/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/instance/proxy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sGAsDkB,CAAC"}

package/.tsc/lib/contract/gateway/router/instance/proxy.js

@@ -0,0 +1,55 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+export const proxyRequest = oc
+    .input(z.object({
+    instanceId: z.number(),
+    apiGroup: z.enum([
+        "document",
+        "invoice",
+        "identity",
+        "bankStatement",
+        "academic",
+    ]),
+    operation: z.enum([
+        "parse",
+        "ask",
+        "extract",
+        "search",
+        "fetch",
+        "findCitations",
+        "paperGraph",
+        "similarPapers",
+        "searchGrants",
+    ]),
+    model: z.string().optional(),
+    url: z.string().optional(),
+    base64: z.string().optional(),
+    includePages: z.boolean().optional(),
+    question: z.string().optional(),
+    prompt: z.string().optional(),
+    schema: z.string().optional(),
+    documentId: z.string().optional(),
+    // Academic-specific fields
+    query: z.string().optional(),
+    providers: z.array(z.string()).optional(),
+    ids: z.array(z.string()).optional(),
+    paragraph: z.string().optional(),
+    offset: z.number().optional(),
+    limit: z.number().optional(),
+    yearFrom: z.number().optional(),
+    yearTo: z.number().optional(),
+    fields: z.array(z.string()).optional(),
+    // Paper Graph / Similar Papers fields
+    id: z.string().optional(),
+    citationsLimit: z.number().optional(),
+    referencesLimit: z.number().optional(),
+    citationsOffset: z.number().optional(),
+    referencesOffset: z.number().optional(),
+    includeEdges: z.boolean().optional(),
+    // Search Grants fields
+    deadlineFrom: z.string().optional(),
+    deadlineTo: z.string().optional(),
+    fundingMin: z.number().optional(),
+    fundingMax: z.number().optional(),
+}))
+    .output(z.record(z.string(), z.unknown()));

package/.tsc/lib/contract/gateway/router/instance/usage.d.ts

@@ -0,0 +1,205 @@
+import * as z from "zod";
+export declare const syncUsage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    synced: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const getUsage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+    from: z.ZodOptional<z.ZodDate>;
+    to: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    instanceId: z.ZodNullable<z.ZodNumber>;
+    remoteId: z.ZodNumber;
+    credits: z.ZodNumber;
+    model: z.ZodNullable<z.ZodString>;
+    inputSource: z.ZodString;
+    inputRef: z.ZodNullable<z.ZodString>;
+    fileSize: z.ZodNumber;
+    documentType: z.ZodString;
+    documentId: z.ZodNullable<z.ZodString>;
+    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;
+    operation: z.ZodString;
+    pageCount: z.ZodNullable<z.ZodNumber>;
+    requestedModel: z.ZodString;
+    apiKey: z.ZodNullable<z.ZodString>;
+    workspaceId: z.ZodNullable<z.ZodNumber>;
+    source: z.ZodEnum<{
+        api: "api";
+        make: "make";
+        mcp: "mcp";
+        n8n: "n8n";
+        playground: "playground";
+        sdk: "sdk";
+        unknown: "unknown";
+        zapier: "zapier";
+    }>;
+    createdAt: z.ZodDate;
+}, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+export declare const listUsageRecords: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+    page: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        success: "success";
+        system_error: "system_error";
+        user_error: "user_error";
+    }>>;
+    period: z.ZodDefault<z.ZodEnum<{
+        "30d": "30d";
+        "7d": "7d";
+        "90d": "90d";
+        all: "all";
+    }>>;
+    excludedApiKeys: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        api: "api";
+        make: "make";
+        mcp: "mcp";
+        n8n: "n8n";
+        playground: "playground";
+        sdk: "sdk";
+        unknown: "unknown";
+        zapier: "zapier";
+    }>>>;
+    sortBy: z.ZodDefault<z.ZodEnum<{
+        createdAt: "createdAt";
+        credits: "credits";
+        documentId: "documentId";
+        documentType: "documentType";
+        duration: "duration";
+        error: "error";
+        fileSize: "fileSize";
+        inputRef: "inputRef";
+        inputSource: "inputSource";
+        instanceId: "instanceId";
+        model: "model";
+        operation: "operation";
+        pageCount: "pageCount";
+        remoteId: "remoteId";
+        requestedModel: "requestedModel";
+        source: "source";
+        status: "status";
+        workspaceId: "workspaceId";
+    }>>;
+    sortOrder: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        instanceId: z.ZodNullable<z.ZodNumber>;
+        remoteId: z.ZodNumber;
+        credits: z.ZodNumber;
+        model: z.ZodNullable<z.ZodString>;
+        inputSource: z.ZodString;
+        inputRef: z.ZodNullable<z.ZodString>;
+        fileSize: z.ZodNumber;
+        documentType: z.ZodString;
+        documentId: z.ZodNullable<z.ZodString>;
+        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;
+        operation: z.ZodString;
+        pageCount: z.ZodNullable<z.ZodNumber>;
+        requestedModel: z.ZodString;
+        apiKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodEnum<{
+            api: "api";
+            make: "make";
+            mcp: "mcp";
+            n8n: "n8n";
+            playground: "playground";
+            sdk: "sdk";
+            unknown: "unknown";
+            zapier: "zapier";
+        }>;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    successCount: z.ZodNumber;
+    userErrorCount: z.ZodNumber;
+    systemErrorCount: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const getOverviewStats: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+    totalRequests: z.ZodNumber;
+    totalUserErrors: z.ZodNumber;
+    totalSystemErrors: z.ZodNumber;
+    totalCredits: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const getUsageRecord: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    instanceId: z.ZodNumber;
+    usageRecordId: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    record: z.ZodObject<{
+        id: z.ZodNumber;
+        instanceId: z.ZodNullable<z.ZodNumber>;
+        remoteId: z.ZodNumber;
+        credits: z.ZodNumber;
+        model: z.ZodNullable<z.ZodString>;
+        inputSource: z.ZodString;
+        inputRef: z.ZodNullable<z.ZodString>;
+        fileSize: z.ZodNumber;
+        documentType: z.ZodString;
+        documentId: z.ZodNullable<z.ZodString>;
+        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;
+        operation: z.ZodString;
+        pageCount: z.ZodNullable<z.ZodNumber>;
+        requestedModel: z.ZodString;
+        apiKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodEnum<{
+            api: "api";
+            make: "make";
+            mcp: "mcp";
+            n8n: "n8n";
+            playground: "playground";
+            sdk: "sdk";
+            unknown: "unknown";
+            zapier: "zapier";
+        }>;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=usage.d.ts.map

package/.tsc/lib/contract/gateway/router/instance/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/instance/usage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AA6BzB,eAAO,MAAM,SAAS;;;;8DAEoB,CAAC;AAE3C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAQe,CAAC;AAErC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA6C3B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;8DAO5B,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAMzB,CAAC"}

package/.tsc/lib/contract/gateway/router/instance/usage.js

@@ -0,0 +1,92 @@
+import { oc } from "@orpc/contract";
+import { apiSources } from "@pdfvector/util";
+import * as z from "zod";
+const usageRecordSchema = z.object({
+    id: z.number(),
+    instanceId: z.number().nullable(),
+    remoteId: z.number(),
+    credits: z.number(),
+    model: z.string().nullable(),
+    inputSource: z.string(),
+    inputRef: z.string().nullable(),
+    fileSize: z.number(),
+    documentType: z.string(),
+    documentId: z.string().nullable(),
+    error: z.string().nullable(),
+    status: z.enum(["success", "user_error", "system_error"]),
+    errorStage: z
+        .enum(["auth", "validation", "preprocessing", "processing"])
+        .nullable(),
+    errorCode: z.string().nullable(),
+    duration: z.number(),
+    operation: z.string(),
+    pageCount: z.number().nullable(),
+    requestedModel: z.string(),
+    apiKey: z.string().nullable(),
+    workspaceId: z.number().nullable(),
+    source: z.enum(apiSources),
+    createdAt: z.date(),
+});
+export const syncUsage = oc
+    .input(z.object({ id: z.number() }))
+    .output(z.object({ synced: z.number() }));
+export const getUsage = oc
+    .input(z.object({
+    id: z.number(),
+    from: z.date().optional(),
+    to: z.date().optional(),
+}))
+    .output(z.array(usageRecordSchema));
+export const listUsageRecords = oc
+    .input(z.object({
+    id: z.number(),
+    page: z.number().int().min(1).default(1),
+    pageSize: z.number().int().min(1).max(100).default(10),
+    status: z
+        .enum(["all", "success", "user_error", "system_error"])
+        .default("all"),
+    period: z.enum(["7d", "30d", "90d", "all"]).default("all"),
+    excludedApiKeys: z.array(z.union([z.string(), z.null()])).default([]),
+    sources: z.array(z.enum(apiSources)).optional(),
+    sortBy: z
+        .enum([
+        "createdAt",
+        "operation",
+        "requestedModel",
+        "model",
+        "status",
+        "credits",
+        "duration",
+        "documentType",
+        "pageCount",
+        "fileSize",
+        "inputSource",
+        "inputRef",
+        "remoteId",
+        "documentId",
+        "error",
+        "instanceId",
+        "workspaceId",
+        "source",
+    ])
+        .default("createdAt"),
+    sortOrder: z.enum(["asc", "desc"]).default("desc"),
+}))
+    .output(z.object({
+    items: z.array(usageRecordSchema),
+    total: z.number(),
+    successCount: z.number(),
+    userErrorCount: z.number(),
+    systemErrorCount: z.number(),
+}));
+export const getOverviewStats = oc.output(z.object({
+    totalRequests: z.number(),
+    totalUserErrors: z.number(),
+    totalSystemErrors: z.number(),
+    totalCredits: z.number(),
+}));
+export const getUsageRecord = oc
+    .input(z.object({ instanceId: z.number(), usageRecordId: z.number() }))
+    .output(z.object({
+    record: usageRecordSchema,
+}));

package/.tsc/lib/contract/gateway/router/instance.d.ts

@@ -0,0 +1,5 @@
+export * from "./instance/api-keys.js";
+export * from "./instance/instances.js";
+export * from "./instance/proxy.js";
+export * from "./instance/usage.js";
+//# sourceMappingURL=instance.d.ts.map