@pdfvector/util 0.0.31 → 0.1.0

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

@@ -0,0 +1,44 @@
+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;
+        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.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;AAqBxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAsB9B,CAAC"}

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

@@ -0,0 +1,39 @@
+import { oc } from "@orpc/contract";
+import { apiSources, errorStages, usageStatuses } from "@pdfvector/util";
+import { z } from "zod";
+const freeUsageRecordSchema = z.object({
+    id: 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(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"}

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

@@ -0,0 +1,50 @@
+import { oc } from "@orpc/contract";
+import { usageStatuses } from "@pdfvector/util";
+import { z } from "zod";
+const providerUsageRecordSchema = z.object({
+    id: z.number(),
+    apiUsageId: z.number().nullable(),
+    operation: z.string(),
+    phase: z.string(),
+    provider: z.string(),
+    service: z.string(),
+    providerModel: z.string().nullable(),
+    providerRegion: z.string().nullable(),
+    providerResource: z.string().nullable(),
+    documentType: z.string().nullable(),
+    fileSize: z.number().nullable(),
+    pageCount: z.number().nullable(),
+    inputTokens: z.number().nullable(),
+    uncachedInputTokens: z.number().nullable(),
+    cachedInputTokens: z.number().nullable(),
+    cacheWriteTokens: z.number().nullable(),
+    outputTokens: z.number().nullable(),
+    reasoningTokens: z.number().nullable(),
+    totalTokens: z.number().nullable(),
+    featuresJson: z.string().nullable(),
+    status: z.enum(usageStatuses),
+    error: z.string().nullable(),
+    duration: z.number(),
+    estimatedCostUsdMicro: z.number().nullable(),
+    pricingVersion: z.string().nullable(),
+    rawUsageJson: z.string().nullable(),
+    createdAt: z.number(),
+});
+export const getProviderUsageRecords = oc
+    .route({
+    summary: "Get provider usage records",
+    description: "Returns provider-level 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(providerUsageRecordSchema),
+    hasMore: z.boolean(),
+}));

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

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const getUsageRecords: 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;
+        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;
+        actualModel: z.ZodNullable<z.ZodString>;
+        apiKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodDefault<z.ZodEnum<{
+            api: "api";
+            make: "make";
+            mcp: "mcp";
+            n8n: "n8n";
+            playground: "playground";
+            sdk: "sdk";
+            unknown: "unknown";
+            zapier: "zapier";
+        }>>;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=get-usage-records.d.ts.map

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

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

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

@@ -0,0 +1,44 @@
+import { oc } from "@orpc/contract";
+import { apiSources, errorStages, usageStatuses } from "@pdfvector/util";
+import { z } from "zod";
+const usageRecordSchema = z.object({
+    id: 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(usageStatuses),
+    errorStage: z.enum(errorStages).nullable(),
+    errorCode: z.string().nullable(),
+    duration: z.number(),
+    operation: z.string(),
+    pageCount: z.number().nullable(),
+    requestedModel: z.string(),
+    actualModel: z.string().nullable(),
+    apiKey: z.string().nullable(),
+    workspaceId: z.number().nullable(),
+    source: z.enum(apiSources).default("unknown"),
+    createdAt: z.number(),
+});
+export const getUsageRecords = oc
+    .route({
+    summary: "Get usage records",
+    description: "Returns 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(usageRecordSchema),
+    hasMore: z.boolean(),
+}));

package/.tsc/lib/contract/instance/router/admin/health-check.d.ts

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

package/.tsc/lib/contract/instance/router/admin/health-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-check.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/admin/health-check.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,WAAW;;8DAUG,CAAC"}

package/.tsc/lib/contract/instance/router/admin/health-check.js

@@ -0,0 +1,14 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+const adminOutputSchema = z.object({ message: z.string() });
+export const healthCheck = oc
+    .route({
+    summary: "Health check",
+    description: "Check that the instance server and database are operational",
+    tags: ["Admin"],
+    spec: (op) => {
+        op.security = [{ bearerAuth: [] }];
+        return op;
+    },
+})
+    .output(adminOutputSchema);

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

@@ -0,0 +1,9 @@
+export * from "./get-environment.js";
+export * from "./get-free-usage-records.js";
+export * from "./get-provider-usage-records.js";
+export * from "./get-usage-records.js";
+export * from "./health-check.js";
+export * from "./set-domain.js";
+export * from "./set-environment.js";
+export * from "./set-version.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/admin/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,8 @@
+export * from "./get-environment.js";
+export * from "./get-free-usage-records.js";
+export * from "./get-provider-usage-records.js";
+export * from "./get-usage-records.js";
+export * from "./health-check.js";
+export * from "./set-domain.js";
+export * from "./set-environment.js";
+export * from "./set-version.js";

package/.tsc/lib/contract/instance/router/admin/set-domain.d.ts

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

package/.tsc/lib/contract/instance/router/admin/set-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-domain.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/admin/set-domain.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,SAAS;;;;8DAWK,CAAC"}

package/.tsc/lib/contract/instance/router/admin/set-domain.js

@@ -0,0 +1,20 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+const adminOutputSchema = z.object({ message: z.string() });
+const setDomainInputSchema = z.object({
+    domain: z
+        .string()
+        .regex(/^([a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/, "Must be a valid hostname (e.g. app.example.com)"),
+});
+export const setDomain = oc
+    .route({
+    summary: "Set instance server's domain",
+    description: "Update the instance server's domain name",
+    tags: ["Admin"],
+    spec: (op) => {
+        op.security = [{ bearerAuth: [] }];
+        return op;
+    },
+})
+    .input(setDomainInputSchema)
+    .output(adminOutputSchema);

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

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const setEnvironment: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    environment: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=set-environment.d.ts.map

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

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

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

@@ -0,0 +1,41 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+const reservedKeys = new Set([
+    "NODE_ENV",
+    "PDFVECTOR_LOCAL",
+    "VITE_PDFVECTOR_LOCAL",
+    "NEXT_PUBLIC_PDFVECTOR_LOCAL",
+    "PDFVECTOR_RELEASES_REGION",
+    "PDFVECTOR_RELEASES_S3_BUCKET",
+    "PDFVECTOR_RELEASES_DYNAMODB_TABLE",
+    "PDFVECTOR_INSTANCE_SERVER_DOMAIN",
+    "PDFVECTOR_INSTANCE_SERVER_DATA_DIR",
+]);
+export const setEnvironment = oc
+    .route({
+    summary: "Set instance server's environment",
+    description: "Update instance environment variables, or remove them by passing null",
+    tags: ["Admin"],
+    spec: (op) => {
+        op.security = [{ bearerAuth: [] }];
+        return op;
+    },
+})
+    .input(z.object({
+    environment: z
+        .record(z
+        .string()
+        .regex(/^[A-Z_][A-Z0-9_]*$/, "Keys must be valid env var names (e.g. MY_VAR)"), z.union([
+        z
+            .string()
+            .regex(/^[^\0\n\r]*$/, "Values must not contain NULs or newlines"),
+        z.null(),
+    ]))
+        .refine((env) => Object.keys(env).length > 0, {
+        message: "At least one environment variable is required",
+    })
+        .refine((env) => !Object.keys(env).some((key) => reservedKeys.has(key)), {
+        message: `Cannot set reserved keys: ${[...reservedKeys].join(", ")}`,
+    }),
+}))
+    .output(z.object({ message: z.string() }));

package/.tsc/lib/contract/instance/router/admin/set-version.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const setVersion: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    version: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"LATEST">]>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=set-version.d.ts.map

package/.tsc/lib/contract/instance/router/admin/set-version.d.ts.map

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

package/.tsc/lib/contract/instance/router/admin/set-version.js

@@ -0,0 +1,21 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+const setVersionInputSchema = z.object({
+    version: z.union([
+        z.string().regex(/^\d+\.\d+\.\d+$/, "Must be a valid semver (e.g. 1.2.3)"),
+        z.literal("LATEST"),
+    ]),
+});
+const adminOutputSchema = z.object({ message: z.string() });
+export const setVersion = oc
+    .route({
+    summary: "Set instance server's version",
+    description: "Update the instance server to a specific version",
+    tags: ["Admin"],
+    spec: (op) => {
+        op.security = [{ bearerAuth: [] }];
+        return op;
+    },
+})
+    .input(setVersionInputSchema)
+    .output(adminOutputSchema);

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

@@ -0,0 +1,2 @@
+export * from "./validate-credential.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/authenticate/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./validate-credential.js";

package/.tsc/lib/contract/instance/router/authenticate/validate-credential.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const validateCredential: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodOptional<z.ZodObject<{}, z.core.$strip>>, z.ZodObject<{
+    status: z.ZodString;
+    version: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=validate-credential.d.ts.map

package/.tsc/lib/contract/instance/router/authenticate/validate-credential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-credential.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/authenticate/validate-credential.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,kBAAkB;;;;8DAYT,CAAC"}

package/.tsc/lib/contract/instance/router/authenticate/validate-credential.js

@@ -0,0 +1,20 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+const inputSchema = z.object({}).optional();
+const outputSchema = z.object({
+    status: z.string().describe("Server status indicator"),
+    version: z.string().describe("Server version"),
+    timestamp: z.string().describe("Current server timestamp in ISO 8601 format"),
+});
+export const validateCredential = oc
+    .route({
+    summary: "Validate API credential",
+    description: "Verify that the API key is valid and the server is reachable. Returns basic server information.",
+    tags: ["Authenticate"],
+    spec: (op) => {
+        op.security = [{ bearerAuth: [] }];
+        return op;
+    },
+})
+    .input(inputSchema)
+    .output(outputSchema);

package/.tsc/lib/contract/instance/router/bankStatement/ask.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const ask: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+    url: z.ZodOptional<z.ZodURL>;
+    file: z.ZodOptional<z.ZodFile>;
+    base64: z.ZodOptional<z.ZodString>;
+    question: z.ZodString;
+    model: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        max: "max";
+        mini: "mini";
+        nano: "nano";
+        pro: "pro";
+    }>>;
+    documentId: z.ZodOptional<z.ZodString>;
+    callback: z.ZodOptional<z.ZodObject<{
+        url: z.ZodURL;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    markdown: z.ZodString;
+    pageCount: z.ZodNumber;
+    model: z.ZodEnum<{
+        max: "max";
+        mini: "mini";
+        nano: "nano";
+        pro: "pro";
+    }>;
+    credits: z.ZodNumber;
+    requestId: z.ZodNumber;
+    documentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, Record<never, never>, Record<never, never>>;
+//# sourceMappingURL=ask.d.ts.map

package/.tsc/lib/contract/instance/router/bankStatement/ask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../../../../../lib/contract/instance/router/bankStatement/ask.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiGxB,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAYS,CAAC"}

package/.tsc/lib/contract/instance/router/bankStatement/ask.js

@@ -0,0 +1,88 @@
+import { oc } from "@orpc/contract";
+import { getOpenApiCodeSamples } from "@pdfvector/api-docs";
+import { z } from "zod";
+import { fetchableUrlSchema } from "../../fetchable-url-schema.js";
+import { pdfvectorModelSchema } from "../../pdfvector-model-schema.js";
+import { outputAskModelDescription, specializedAskModelDescription, supportedFileFormatsDescription, supportedFileMimeErrorMessage, supportedFileMimes, supportedFileTypesLong, } from "../../supported-mimes.js";
+import { getDefaultSpec } from "./get-default-spec.js";
+const specializedModelSchema = z
+    .enum(["auto", ...pdfvectorModelSchema.options])
+    .default("auto");
+const askInputSchema = z.object({
+    url: fetchableUrlSchema
+        .optional()
+        .describe("URL of the bank statement file to fetch and parse"),
+    file: z
+        .file()
+        .mime([...supportedFileMimes], supportedFileMimeErrorMessage)
+        .optional()
+        .describe(`Bank statement file upload via multipart form-data (${supportedFileFormatsDescription})`),
+    base64: z
+        .string()
+        .optional()
+        .describe("Base64-encoded bank statement file content"),
+    question: z
+        .string()
+        .min(4, "question must be at least 4 characters")
+        .describe("The question to answer about the bank statement"),
+    model: specializedModelSchema.describe(specializedAskModelDescription),
+    documentId: z
+        .string()
+        .trim()
+        .min(1)
+        .max(512)
+        .optional()
+        .describe("Optional external document ID for usage attribution. The x-pdfvector-document-id header takes precedence when both are provided."),
+    callback: z
+        .object({
+        url: fetchableUrlSchema.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."),
+});
+const askOutputSchema = z.object({
+    markdown: z.string().describe("The answer to the question"),
+    pageCount: z.number().int().describe("Total number of pages in the document"),
+    model: pdfvectorModelSchema.describe(outputAskModelDescription),
+    credits: z
+        .number()
+        .int()
+        .describe("Number of credits consumed by this API call. Cost per page: nano=6, mini=10, pro=14, max=18."),
+    requestId: z
+        .number()
+        .int()
+        .describe("Unique request identifier for this API call"),
+    documentId: z
+        .string()
+        .optional()
+        .describe("Document ID if provided via x-pdfvector-document-id header or request body"),
+});
+const requestExamples = {
+    "Ask from URL": {
+        summary: "Ask from URL",
+        value: {
+            url: "https://example.com/bank-statement.pdf",
+            question: "What is the ending balance?",
+        },
+    },
+};
+export const ask = oc
+    .route({
+    summary: "Ask a question about a bank statement",
+    description: `Parse a bank statement and answer a question about its content using AI. Supports ${supportedFileTypesLong}. Provide the document via file upload, a public URL, or a base64-encoded string.`,
+    tags: ["Bank Statement"],
+    spec: (op) => {
+        const spec = getDefaultSpec(op, requestExamples);
+        spec["x-codeSamples"] = getOpenApiCodeSamples("bank-statement-ask");
+        return spec;
+    },
+})
+    .input(askInputSchema)
+    .output(askOutputSchema);