@pdfvector/util 0.0.31 → 0.0.32

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

@@ -0,0 +1,65 @@
+import { oc } from "@orpc/contract";
+import { apiSources } from "@pdfvector/util";
+import * as z from "zod";
+const breakdownItemSchema = z.object({
+    label: z.string(),
+    count: z.number(),
+});
+export const getUsageOverview = oc
+    .input(z.object({
+    period: z.enum(["7d", "30d", "90d", "all"]).default("30d"),
+    instanceId: z.number().nullable().optional(),
+    sources: z.array(z.enum(apiSources)).optional(),
+}))
+    .output(z.object({
+    totalRequests: z.number(),
+    totalCredits: z.number(),
+    successCount: z.number(),
+    userErrorCount: z.number(),
+    systemErrorCount: z.number(),
+    avgDuration: z.number(),
+    p95Duration: z.number(),
+    uniqueUsers: z.number(),
+    avgPages: z.number().nullable(),
+    totalFileSize: z.number(),
+    daily: z.array(z.object({
+        date: z.string(),
+        success: z.number(),
+        userError: z.number(),
+        systemError: z.number(),
+        credits: z.number(),
+    })),
+    dailyByOperation: z.array(z.object({
+        date: z.string(),
+        operation: z.string(),
+        count: z.number(),
+    })),
+    dailyBySource: z.array(z.object({
+        date: z.string(),
+        source: z.enum(apiSources),
+        count: z.number(),
+    })),
+    byOperation: z.array(breakdownItemSchema),
+    byModel: z.array(breakdownItemSchema),
+    byDocumentType: z.array(breakdownItemSchema),
+    byIp: z.array(breakdownItemSchema),
+    topActualModels: z.array(breakdownItemSchema),
+    topModels: z.array(breakdownItemSchema),
+    topRequestedModels: z.array(breakdownItemSchema),
+    topSources: z.array(breakdownItemSchema),
+    topSystemErrors: z.array(z.object({
+        message: z.string(),
+        count: z.number(),
+    })),
+    topUserErrors: z.array(z.object({
+        message: z.string(),
+        count: z.number(),
+    })),
+    topUsers: z.array(z.object({
+        workspaceId: z.number(),
+        label: z.string(),
+        sublabel: z.string().nullable(),
+        requestCount: z.number(),
+        totalCredits: z.number(),
+    })),
+}));

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

@@ -0,0 +1,71 @@
+import * as z from "zod";
+export declare const listUsage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    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";
+    }>>;
+    instanceId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    sortBy: z.ZodDefault<z.ZodEnum<{
+        createdAt: "createdAt";
+        credits: "credits";
+        duration: "duration";
+        operation: "operation";
+        requestedModel: "requestedModel";
+    }>>;
+    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;
+        source: z.ZodEnum<{
+            api: "api";
+            make: "make";
+            n8n: "n8n";
+            playground: "playground";
+            sdk: "sdk";
+            unknown: "unknown";
+            zapier: "zapier";
+        }>;
+        createdAt: z.ZodDate;
+        userEmail: z.ZodNullable<z.ZodString>;
+        userName: z.ZodNullable<z.ZodString>;
+    }, 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=records.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../../../../../../lib/contract/gateway/router/admin/usage/records.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAyDpB,CAAC"}

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

@@ -0,0 +1,55 @@
+import { oc } from "@orpc/contract";
+import { apiSources } from "@pdfvector/util";
+import * as z from "zod";
+export const listUsage = oc
+    .input(z.object({
+    search: z.string().optional(),
+    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"),
+    instanceId: z.number().nullable().optional(),
+    sortBy: z
+        .enum([
+        "createdAt",
+        "operation",
+        "requestedModel",
+        "credits",
+        "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(),
+        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(),
+        source: z.enum(apiSources),
+        createdAt: z.date(),
+        userEmail: z.string().nullable(),
+        userName: z.string().nullable(),
+    })),
+    total: z.number(),
+    successCount: z.number(),
+    userErrorCount: z.number(),
+    systemErrorCount: z.number(),
+}));

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

@@ -0,0 +1,93 @@
+import * as z from "zod";
+export declare const listUsers: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    sortBy: z.ZodDefault<z.ZodEnum<{
+        createdAt: "createdAt";
+        email: "email";
+        name: "name";
+        plan: "plan";
+        remainingCredits: "remainingCredits";
+        role: "role";
+        usedCredits: "usedCredits";
+    }>>;
+    sortDirection: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    users: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+        role: z.ZodNullable<z.ZodString>;
+        emailVerified: z.ZodBoolean;
+        banned: z.ZodNullable<z.ZodBoolean>;
+        banReason: z.ZodNullable<z.ZodString>;
+        banExpires: z.ZodNullable<z.ZodNumber>;
+        createdAt: z.ZodDate;
+        plan: z.ZodNullable<z.ZodString>;
+        usedCredits: z.ZodNullable<z.ZodNumber>;
+        aggregatedCredits: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+export declare const userDetail: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    workspace: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        aggregatedCredits: z.ZodNumber;
+        usedCredits: z.ZodNumber;
+        changedPlans: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            time: z.ZodNumber;
+            credits: z.ZodNumber;
+        }, z.core.$strip>>;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+    plan: z.ZodNullable<z.ZodObject<{
+        currentPlan: z.ZodObject<{
+            key: z.ZodString;
+            annual: z.ZodBoolean;
+            monthlyCredits: z.ZodNumber;
+        }, z.core.$strip>;
+        planSchedule: z.ZodOptional<z.ZodObject<{
+            plan: z.ZodObject<{
+                key: z.ZodString;
+                annual: z.ZodBoolean;
+            }, z.core.$strip>;
+            date: z.ZodDate;
+        }, z.core.$strip>>;
+        planValidity: z.ZodBoolean;
+    }, z.core.$strip>>;
+    stripe: z.ZodNullable<z.ZodObject<{
+        customerId: z.ZodString;
+        subscription: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodString;
+            currentPeriodStart: z.ZodDate;
+            currentPeriodEnd: z.ZodDate;
+            cancelAtPeriodEnd: z.ZodBoolean;
+        }, z.core.$strip>>;
+        invoices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodNullable<z.ZodString>;
+            amountPaid: z.ZodNumber;
+            currency: z.ZodString;
+            created: z.ZodDate;
+            hostedInvoiceUrl: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    usageStats: z.ZodObject<{
+        totalCreditsUsed: z.ZodNumber;
+        totalDocuments: z.ZodNumber;
+        usageByOperation: z.ZodArray<z.ZodObject<{
+            operation: z.ZodString;
+            count: z.ZodNumber;
+            totalCredits: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=users.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/gateway/router/admin/users.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAYzB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DA8BpB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAwEtB,CAAC"}

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

@@ -0,0 +1,101 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const listUsersSortBySchema = z.enum([
+    "name",
+    "email",
+    "createdAt",
+    "role",
+    "plan",
+    "usedCredits",
+    "remainingCredits",
+]);
+export const listUsers = 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),
+    sortBy: listUsersSortBySchema.default("createdAt"),
+    sortDirection: z.enum(["asc", "desc"]).default("desc"),
+}))
+    .output(z.object({
+    users: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+        role: z.string().nullable(),
+        emailVerified: z.boolean(),
+        banned: z.boolean().nullable(),
+        banReason: z.string().nullable(),
+        banExpires: z.number().nullable(),
+        createdAt: z.date(),
+        plan: z.string().nullable(),
+        usedCredits: z.number().nullable(),
+        aggregatedCredits: z.number().nullable(),
+    })),
+    total: z.number(),
+}));
+export const userDetail = oc.input(z.object({ userId: z.string() })).output(z.object({
+    workspace: z
+        .object({
+        id: z.number(),
+        aggregatedCredits: z.number(),
+        usedCredits: z.number(),
+        changedPlans: z.array(z.object({
+            key: z.string(),
+            time: z.number(),
+            credits: z.number(),
+        })),
+        createdAt: z.date(),
+    })
+        .nullable(),
+    plan: z
+        .object({
+        currentPlan: z.object({
+            key: z.string(),
+            annual: z.boolean(),
+            monthlyCredits: z.number(),
+        }),
+        planSchedule: z
+            .object({
+            plan: z.object({
+                key: z.string(),
+                annual: z.boolean(),
+            }),
+            date: z.date(),
+        })
+            .optional(),
+        planValidity: z.boolean(),
+    })
+        .nullable(),
+    stripe: z
+        .object({
+        customerId: z.string(),
+        subscription: z
+            .object({
+            id: z.string(),
+            status: z.string(),
+            currentPeriodStart: z.date(),
+            currentPeriodEnd: z.date(),
+            cancelAtPeriodEnd: z.boolean(),
+        })
+            .nullable(),
+        invoices: z.array(z.object({
+            id: z.string(),
+            status: z.string().nullable(),
+            amountPaid: z.number(),
+            currency: z.string(),
+            created: z.date(),
+            hostedInvoiceUrl: z.string().nullable(),
+        })),
+    })
+        .nullable(),
+    usageStats: z.object({
+        totalCreditsUsed: z.number(),
+        totalDocuments: z.number(),
+        usageByOperation: z.array(z.object({
+            operation: z.string(),
+            count: z.number(),
+            totalCredits: z.number(),
+        })),
+    }),
+}));

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

@@ -0,0 +1,7 @@
+export * from "./admin/billing.js";
+export * from "./admin/blog.js";
+export * from "./admin/feedback.js";
+export * from "./admin/instances.js";
+export * from "./admin/usage/index.js";
+export * from "./admin/users.js";
+//# sourceMappingURL=admin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../../../../lib/contract/gateway/router/admin.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,6 @@
+export * from "./admin/billing.js";
+export * from "./admin/blog.js";
+export * from "./admin/feedback.js";
+export * from "./admin/instances.js";
+export * from "./admin/usage/index.js";
+export * from "./admin/users.js";

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

@@ -0,0 +1,17 @@
+import * as z from "zod";
+export declare const manage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    returnURL: z.ZodString;
+}, z.core.$strip>, z.ZodString, Record<never, never>, Record<never, never>>;
+export declare const update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    plan: z.ZodObject<{
+        key: z.ZodEnum<{
+            basic: "basic";
+            free: "free";
+            pro: "pro";
+        }>;
+        annual: z.ZodBoolean;
+    }, z.core.$strip>;
+    succeedURL: z.ZodString;
+    returnURL: z.ZodString;
+}, z.core.$strip>, z.ZodOptional<z.ZodString>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=billing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"billing.d.ts","sourceRoot":"","sources":["../../../../../lib/contract/gateway/router/billing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,MAAM;;2EAEC,CAAC;AAErB,eAAO,MAAM,MAAM;;;;;;;;;;;0FAgBY,CAAC"}

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

@@ -0,0 +1,20 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+export const manage = oc
+    .input(z.object({ returnURL: z.string() }))
+    .output(z.string());
+export const update = oc
+    .input(z
+    .object({
+    plan: z.object({
+        key: z.enum(["free", "basic", "pro"]),
+        annual: z.boolean(),
+    }),
+    succeedURL: z.string(),
+    returnURL: z.string(),
+})
+    .refine((data) => !(data.plan.key === "free" && data.plan.annual), {
+    message: "free plan cannot be annual",
+    path: ["plan", "annual"],
+}))
+    .output(z.string().optional());

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

@@ -0,0 +1,35 @@
+import * as z from "zod";
+export declare const publicList: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    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 publicGetBySlug: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    slug: z.ZodString;
+}, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodString;
+    slug: z.ZodString;
+    keyword: z.ZodNullable<z.ZodString>;
+    content: z.ZodString;
+    metaDescription: z.ZodNullable<z.ZodString>;
+    coverImage: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodDate;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+export declare const publicListSlugs: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    slugs: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=blog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blog.d.ts","sourceRoot":"","sources":["../../../../../lib/contract/gateway/router/blog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAezB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;8DAYrB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;+DAEO,CAAC;AAEpC,eAAO,MAAM,eAAe;;8DAEsB,CAAC"}

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

@@ -0,0 +1,29 @@
+import { oc } from "@orpc/contract";
+import * as z from "zod";
+const blogPostSchema = z.object({
+    id: z.number(),
+    title: z.string(),
+    slug: z.string(),
+    keyword: z.string().nullable(),
+    content: z.string(),
+    metaDescription: z.string().nullable(),
+    coverImage: z.string().nullable(),
+    publishedAt: z.date(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export const publicList = oc
+    .input(z.object({
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(50).default(12),
+}))
+    .output(z.object({
+    posts: z.array(blogPostSchema.omit({ content: true, updatedAt: true })),
+    total: z.number(),
+}));
+export const publicGetBySlug = oc
+    .input(z.object({ slug: z.string() }))
+    .output(blogPostSchema.nullable());
+export const publicListSlugs = oc
+    .input(z.object({}))
+    .output(z.object({ slugs: z.array(z.string()) }));

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

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

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

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

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"}