@pdfvector/util 0.0.31 → 0.1.0

package/.tsc/lib/api-source.d.ts

@@ -1,3 +1,3 @@
-export declare const apiSources: readonly ["make", "zapier", "n8n", "sdk", "playground", "api", "unknown"];
+export declare const apiSources: readonly ["make", "zapier", "n8n", "sdk", "mcp", "playground", "api", "unknown"];
 export type APISource = (typeof apiSources)[number];
 //# sourceMappingURL=api-source.d.ts.map

package/.tsc/lib/api-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-source.d.ts","sourceRoot":"","sources":["../../lib/api-source.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,YACtB,MAAM,EACN,QAAQ,EACR,KAAK,EACL,KAAK,EACL,YAAY,EACZ,KAAK,EACL,SAAS,CACA,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"api-source.d.ts","sourceRoot":"","sources":["../../lib/api-source.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,YACtB,MAAM,EACN,QAAQ,EACR,KAAK,EACL,KAAK,EACL,KAAK,EACL,YAAY,EACZ,KAAK,EACL,SAAS,CACA,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/.tsc/lib/api-source.js

@@ -3,6 +3,7 @@ export const apiSources = [
     "zapier",
     "n8n",
     "sdk",
+    "mcp",
     "playground",
     "api",
     "unknown",

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

@@ -0,0 +1,7 @@
+import type { InferContractRouterInputs, InferContractRouterOutputs } from "@orpc/contract";
+import * as contract from "./router/index.js";
+export * from "./mcp-account.js";
+export { contract };
+export type ContractInputs = InferContractRouterInputs<typeof contract>;
+export type ContractOutputs = InferContractRouterOutputs<typeof contract>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/contract/gateway/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,yBAAyB,EACzB,0BAA0B,EAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,yBAAyB,CAAC,OAAO,QAAQ,CAAC,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,0BAA0B,CAAC,OAAO,QAAQ,CAAC,CAAC"}

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

@@ -0,0 +1,3 @@
+import * as contract from "./router/index.js";
+export * from "./mcp-account.js";
+export { contract };

package/.tsc/lib/contract/gateway/mcp-account.d.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+export declare const mcpAccountRequestSchema: z.ZodObject<{
+    authentication: z.ZodEnum<{
+        "api-key": "api-key";
+        oauth: "oauth";
+    }>;
+    resource: z.ZodString;
+}, z.core.$strict>;
+export declare const mcpAccountResponseSchema: z.ZodObject<{
+    workspace: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    profile: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+    }, z.core.$strict>>;
+    plan: z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>;
+    billing: z.ZodObject<{
+        planKey: z.ZodString;
+        interval: z.ZodNullable<z.ZodEnum<{
+            annual: "annual";
+            monthly: "monthly";
+        }>>;
+        asOf: z.ZodISODateTime;
+        source: z.ZodLiteral<"stripe">;
+    }, z.core.$strict>;
+    credits: z.ZodObject<{
+        total: z.ZodNumber;
+        used: z.ZodNumber;
+        remaining: z.ZodNumber;
+    }, z.core.$strict>;
+    asOf: z.ZodISODateTime;
+    accuracy: z.ZodLiteral<"cached">;
+    billingPermission: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const mcpCheckoutRequestSchema: z.ZodObject<{
+    authentication: z.ZodEnum<{
+        "api-key": "api-key";
+        oauth: "oauth";
+    }>;
+    resource: z.ZodString;
+    plan: z.ZodObject<{
+        key: z.ZodEnum<{
+            basic: "basic";
+            pro: "pro";
+        }>;
+        annual: z.ZodBoolean;
+    }, z.core.$strict>;
+    requestId: z.ZodUUID;
+}, z.core.$strict>;
+export declare const mcpCheckoutResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+    status: z.ZodEnum<{
+        checkout: "checkout";
+        upgrade_confirmation: "upgrade_confirmation";
+    }>;
+    paymentRequired: z.ZodLiteral<true>;
+}, z.core.$strict>;
+//# sourceMappingURL=mcp-account.d.ts.map

package/.tsc/lib/contract/gateway/mcp-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-account.d.ts","sourceRoot":"","sources":["../../../../lib/contract/gateway/mcp-account.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;;;;;kBAGlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBnC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;kBAGnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;kBAIpC,CAAC"}

package/.tsc/lib/contract/gateway/mcp-account.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export const mcpAccountRequestSchema = z.strictObject({
+    authentication: z.enum(["oauth", "api-key"]),
+    resource: z.string().url(),
+});
+export const mcpAccountResponseSchema = z.strictObject({
+    workspace: z.strictObject({
+        id: z.number().int().positive(),
+        name: z.string(),
+    }),
+    profile: z
+        .strictObject({ id: z.string(), name: z.string(), email: z.string() })
+        .nullable(),
+    plan: z.strictObject({ key: z.string(), label: z.string() }),
+    billing: z.strictObject({
+        planKey: z.string(),
+        interval: z.enum(["monthly", "annual"]).nullable(),
+        asOf: z.iso.datetime(),
+        source: z.literal("stripe"),
+    }),
+    credits: z.strictObject({
+        total: z.number(),
+        used: z.number(),
+        remaining: z.number(),
+    }),
+    asOf: z.iso.datetime(),
+    accuracy: z.literal("cached"),
+    billingPermission: z.boolean(),
+});
+export const mcpCheckoutRequestSchema = mcpAccountRequestSchema.extend({
+    plan: z.strictObject({ key: z.enum(["basic", "pro"]), annual: z.boolean() }),
+    requestId: z.uuid(),
+});
+export const mcpCheckoutResponseSchema = z.strictObject({
+    url: z.string().url(),
+    status: z.enum(["checkout", "upgrade_confirmation"]),
+    paymentRequired: z.literal(true),
+});

package/.tsc/lib/contract/gateway/router/admin/billing.d.ts

@@ -0,0 +1,50 @@
+import * as z from "zod";
+export declare const listBilling: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    disableCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    users: z.ZodArray<z.ZodObject<{
+        stripeCustomerId: z.ZodString;
+        userName: z.ZodString;
+        userEmail: z.ZodString;
+        planKey: z.ZodString;
+        usedCredits: z.ZodNumber;
+        aggregatedCredits: z.ZodNumber;
+        subscriptionStatus: z.ZodNullable<z.ZodString>;
+        subscriptionId: z.ZodNullable<z.ZodString>;
+        currentPeriodStart: z.ZodNullable<z.ZodDate>;
+        currentPeriodEnd: z.ZodNullable<z.ZodDate>;
+        cancelAtPeriodEnd: z.ZodBoolean;
+        openInvoiceCount: z.ZodNumber;
+        uncollectibleInvoiceCount: z.ZodNumber;
+        totalAmountDue: z.ZodNumber;
+        hasIssues: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodString>;
+        oldestIssueDate: z.ZodNullable<z.ZodDate>;
+        createdAt: z.ZodDate;
+        invoices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            number: z.ZodNullable<z.ZodString>;
+            status: z.ZodString;
+            amountDue: z.ZodNumber;
+            amountPaid: z.ZodNumber;
+            amountRemaining: z.ZodNumber;
+            currency: z.ZodString;
+            dueDate: z.ZodNullable<z.ZodDate>;
+            created: z.ZodDate;
+            periodStart: z.ZodDate;
+            periodEnd: z.ZodDate;
+            billingReason: z.ZodNullable<z.ZodString>;
+            attemptCount: z.ZodNumber;
+            nextPaymentAttempt: z.ZodNullable<z.ZodDate>;
+            hostedInvoiceUrl: z.ZodNullable<z.ZodString>;
+            invoicePdf: z.ZodNullable<z.ZodString>;
+            paid: z.ZodBoolean;
+            collectionMethod: z.ZodString;
+            subtotal: z.ZodNumber;
+            total: z.ZodNumber;
+            tax: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    cachedAt: z.ZodNullable<z.ZodDate>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=billing.d.ts.map

package/.tsc/lib/contract/gateway/router/admin/billing.d.ts.map

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

package/.tsc/lib/contract/gateway/router/admin/billing.js

@@ -0,0 +1,51 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const invoiceSchema = z.object({
+    id: z.string(),
+    number: z.string().nullable(),
+    status: z.string(),
+    amountDue: z.number(),
+    amountPaid: z.number(),
+    amountRemaining: z.number(),
+    currency: z.string(),
+    dueDate: z.date().nullable(),
+    created: z.date(),
+    periodStart: z.date(),
+    periodEnd: z.date(),
+    billingReason: z.string().nullable(),
+    attemptCount: z.number(),
+    nextPaymentAttempt: z.date().nullable(),
+    hostedInvoiceUrl: z.string().nullable(),
+    invoicePdf: z.string().nullable(),
+    paid: z.boolean(),
+    collectionMethod: z.string(),
+    subtotal: z.number(),
+    total: z.number(),
+    tax: z.number().nullable(),
+});
+export const listBilling = oc
+    .input(z.object({ disableCache: z.boolean().optional() }))
+    .output(z.object({
+    users: z.array(z.object({
+        stripeCustomerId: z.string(),
+        userName: z.string(),
+        userEmail: z.string(),
+        planKey: z.string(),
+        usedCredits: z.number(),
+        aggregatedCredits: z.number(),
+        subscriptionStatus: z.string().nullable(),
+        subscriptionId: z.string().nullable(),
+        currentPeriodStart: z.date().nullable(),
+        currentPeriodEnd: z.date().nullable(),
+        cancelAtPeriodEnd: z.boolean(),
+        openInvoiceCount: z.number(),
+        uncollectibleInvoiceCount: z.number(),
+        totalAmountDue: z.number(),
+        hasIssues: z.boolean(),
+        reasons: z.array(z.string()),
+        oldestIssueDate: z.date().nullable(),
+        createdAt: z.date(),
+        invoices: z.array(invoiceSchema),
+    })),
+    cachedAt: z.date().nullable(),
+}));

package/.tsc/lib/contract/gateway/router/admin/blog.d.ts

@@ -0,0 +1,38 @@
+import * as z from "zod";
+export declare const importBlogPosts: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    posts: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        slug: z.ZodString;
+        keyword: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        metaDescription: z.ZodOptional<z.ZodString>;
+        coverImage: z.ZodOptional<z.ZodString>;
+        publishedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    imported: z.ZodNumber;
+    skipped: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const listBlogPosts: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    posts: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        slug: z.ZodString;
+        keyword: z.ZodNullable<z.ZodString>;
+        metaDescription: z.ZodNullable<z.ZodString>;
+        coverImage: z.ZodNullable<z.ZodString>;
+        publishedAt: z.ZodDate;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const deleteBlogPost: 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=blog.d.ts.map

package/.tsc/lib/contract/gateway/router/admin/blog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blog.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/admin/blog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAYzB,eAAO,MAAM,eAAe;;;;;;;;;;;;;8DAEqC,CAAC;AAElE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;8DAwBxB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;8DAEiB,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/blog.js

@@ -0,0 +1,36 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const blogPostImportSchema = z.object({
+    title: z.string(),
+    slug: z.string(),
+    keyword: z.string().optional(),
+    content: z.string(),
+    metaDescription: z.string().optional(),
+    coverImage: z.string().optional(),
+    publishedAt: z.string(),
+});
+export const importBlogPosts = oc
+    .input(z.object({ posts: z.array(blogPostImportSchema) }))
+    .output(z.object({ imported: z.number(), skipped: z.number() }));
+export const listBlogPosts = oc
+    .input(z.object({
+    search: z.string().optional(),
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(100).default(15),
+}))
+    .output(z.object({
+    posts: z.array(z.object({
+        id: z.number(),
+        title: z.string(),
+        slug: z.string(),
+        keyword: z.string().nullable(),
+        metaDescription: z.string().nullable(),
+        coverImage: z.string().nullable(),
+        publishedAt: z.date(),
+        createdAt: z.date(),
+    })),
+    total: z.number(),
+}));
+export const deleteBlogPost = oc
+    .input(z.object({ id: z.number() }))
+    .output(z.object({ success: z.boolean() }));

package/.tsc/lib/contract/gateway/router/admin/feedback.d.ts

@@ -0,0 +1,48 @@
+import * as z from "zod";
+export declare const resolveFeedback: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+    resolved: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const listFeedback: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    feedback: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        type: z.ZodString;
+        message: z.ZodString;
+        resolved: z.ZodBoolean;
+        userName: z.ZodString;
+        userEmail: z.ZodString;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const listFreeFeedback: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodString>;
+    tool: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    feedback: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        tool: z.ZodString;
+        type: z.ZodString;
+        message: z.ZodString;
+        email: z.ZodString;
+        ip: z.ZodString;
+        resolved: z.ZodBoolean;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const resolveFreeFeedback: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    id: z.ZodNumber;
+    resolved: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=feedback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/admin/feedback.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;8DAOgB,CAAC;AAE7C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;8DAuBvB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;8DAyB3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;8DAOY,CAAC"}

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

@@ -0,0 +1,52 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+export const resolveFeedback = oc
+    .input(z.object({
+    id: z.number(),
+    resolved: z.boolean(),
+}))
+    .output(z.object({ success: z.boolean() }));
+export const listFeedback = oc
+    .input(z.object({
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(100).default(15),
+    type: z.string().optional(),
+}))
+    .output(z.object({
+    feedback: z.array(z.object({
+        id: z.number(),
+        type: z.string(),
+        message: z.string(),
+        resolved: z.boolean(),
+        userName: z.string(),
+        userEmail: z.string(),
+        createdAt: z.date(),
+    })),
+    total: z.number(),
+}));
+export const listFreeFeedback = oc
+    .input(z.object({
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(100).default(15),
+    type: z.string().optional(),
+    tool: z.string().optional(),
+}))
+    .output(z.object({
+    feedback: z.array(z.object({
+        id: z.number(),
+        tool: z.string(),
+        type: z.string(),
+        message: z.string(),
+        email: z.string(),
+        ip: z.string(),
+        resolved: z.boolean(),
+        createdAt: z.date(),
+    })),
+    total: z.number(),
+}));
+export const resolveFreeFeedback = oc
+    .input(z.object({
+    id: z.number(),
+    resolved: z.boolean(),
+}))
+    .output(z.object({ success: z.boolean() }));

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

@@ -0,0 +1,8 @@
+import * as z from "zod";
+export declare const listInstances: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    domain: z.ZodString;
+    isGeneral: z.ZodBoolean;
+}, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=instances.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+export const listInstances = oc.output(z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+    domain: z.string(),
+    isGeneral: z.boolean(),
+})));

package/.tsc/lib/contract/gateway/router/admin/usage/free.d.ts

@@ -0,0 +1,108 @@
+import * as z from "zod";
+export declare const syncFreeUsage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const getFreeUsageOverview: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    totalRequests: z.ZodNumber;
+    successCount: z.ZodNumber;
+    userErrorCount: z.ZodNumber;
+    systemErrorCount: z.ZodNumber;
+    avgDuration: z.ZodNumber;
+    p95Duration: z.ZodNumber;
+    uniqueIps: z.ZodNumber;
+    avgPages: z.ZodNullable<z.ZodNumber>;
+    totalFileSize: z.ZodNumber;
+    daily: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+    dailyOperations: z.ZodArray<z.ZodString>;
+    byOperation: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    byIp: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    byModel: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    byDocumentType: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    topSystemErrors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    topUserErrors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const listFreeUsage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    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";
+    }>>;
+    sortBy: z.ZodDefault<z.ZodEnum<{
+        createdAt: "createdAt";
+        duration: "duration";
+        ip: "ip";
+        operation: "operation";
+    }>>;
+    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;
+        operation: z.ZodString;
+        ip: z.ZodString;
+        source: z.ZodDefault<z.ZodEnum<{
+            api: "api";
+            make: "make";
+            mcp: "mcp";
+            n8n: "n8n";
+            playground: "playground";
+            sdk: "sdk";
+            unknown: "unknown";
+            zapier: "zapier";
+        }>>;
+        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.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>>;
+//# sourceMappingURL=free.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"free.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/free.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,aAAa;;8DAEkB,CAAC;AAE7C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAuDhC,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA6CxB,CAAC"}

package/.tsc/lib/contract/gateway/router/admin/usage/free.js

@@ -0,0 +1,86 @@
+import { oc } from "@orpc/contract";
+import { apiSources } from "@pdfvector/util";
+import * as z from "zod";
+export const syncFreeUsage = oc
+    .input(z.object({}))
+    .output(z.object({ success: z.boolean() }));
+export const getFreeUsageOverview = oc.input(z.object({})).output(z.object({
+    totalRequests: z.number(),
+    successCount: z.number(),
+    userErrorCount: z.number(),
+    systemErrorCount: z.number(),
+    avgDuration: z.number(),
+    p95Duration: z.number(),
+    uniqueIps: z.number(),
+    avgPages: z.number().nullable(),
+    totalFileSize: z.number(),
+    daily: z.array(z.object({
+        date: z.string(),
+        counts: z.record(z.string(), z.number()),
+    })),
+    dailyOperations: z.array(z.string()),
+    byOperation: z.array(z.object({
+        label: z.string(),
+        count: z.number(),
+    })),
+    byIp: z.array(z.object({
+        label: z.string(),
+        count: z.number(),
+    })),
+    byModel: z.array(z.object({
+        label: z.string(),
+        count: z.number(),
+    })),
+    byDocumentType: z.array(z.object({
+        label: z.string(),
+        count: z.number(),
+    })),
+    topSystemErrors: z.array(z.object({
+        message: z.string(),
+        count: z.number(),
+    })),
+    topUserErrors: z.array(z.object({
+        message: z.string(),
+        count: z.number(),
+    })),
+}));
+export const listFreeUsage = oc
+    .input(z.object({
+    page: z.number().int().min(1).default(1),
+    pageSize: z.number().int().min(1).max(100).default(20),
+    status: z
+        .enum(["all", "success", "user_error", "system_error"])
+        .default("all"),
+    sortBy: z
+        .enum(["createdAt", "operation", "ip", "duration"])
+        .default("createdAt"),
+    sortOrder: z.enum(["asc", "desc"]).default("desc"),
+}))
+    .output(z.object({
+    items: z.array(z.object({
+        id: z.number(),
+        instanceId: z.number().nullable(),
+        remoteId: z.number(),
+        operation: z.string(),
+        ip: z.string(),
+        source: z.enum(apiSources).default("unknown"),
+        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(["success", "user_error", "system_error"]),
+        errorStage: z
+            .enum(["auth", "validation", "preprocessing", "processing"])
+            .nullable(),
+        errorCode: z.string().nullable(),
+        duration: z.number(),
+        createdAt: z.date(),
+    })),
+    total: z.number(),
+    successCount: z.number(),
+    userErrorCount: z.number(),
+    systemErrorCount: z.number(),
+}));

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

@@ -0,0 +1,4 @@
+export * from "./free.js";
+export * from "./overview.js";
+export * from "./records.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}