@sealkeeper/schema 0.0.1 → 0.4.1

package/dist/api.d.ts

@@ -0,0 +1,1212 @@
+import { z } from 'zod';
+export declare const MAX_EVENTS_PER_BATCH = 500;
+export declare const MAX_ENVELOPE_CHARS = 4096;
+export declare const MAX_TASK_SPEC_BYTES = 16384;
+export declare const MAX_SUBMISSION_BYTES = 65536;
+export declare const MAX_TASK_ENVELOPE_CHARS = 131072;
+export declare const TASK_DEFAULT_TTL_HOURS = 24;
+export declare const TASK_MAX_TTL_DAYS = 7;
+export declare const AgentParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>;
+export declare const TaskParams: z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strict>;
+export declare const SignedTaskRequest: z.ZodObject<{
+    envelope: z.ZodString;
+}, z.core.$strict>;
+export type SignedTaskRequest = z.infer<typeof SignedTaskRequest>;
+export declare const RegisterAgentRequest: z.ZodObject<{
+    publicKey: z.ZodString;
+    githubToken: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strict>;
+export type RegisterAgentRequest = z.infer<typeof RegisterAgentRequest>;
+export declare const AgentHandle: z.ZodString;
+export type AgentHandle = z.infer<typeof AgentHandle>;
+export declare const AgentCounts: z.ZodObject<{
+    events: z.ZodInt;
+    verifiedTasks: z.ZodInt;
+    seedTasks: z.ZodOptional<z.ZodInt>;
+    incidents: z.ZodInt;
+    sessions: z.ZodInt;
+    toolCalls: z.ZodInt;
+}, z.core.$strict>;
+export type AgentCounts = z.infer<typeof AgentCounts>;
+export declare const AgentResponse: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    operatedBySealKeeper: z.ZodOptional<z.ZodBoolean>;
+    operatedByVouched: z.ZodOptional<z.ZodBoolean>;
+    handle: z.ZodOptional<z.ZodString>;
+    previousName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    counts: z.ZodOptional<z.ZodObject<{
+        events: z.ZodInt;
+        verifiedTasks: z.ZodInt;
+        seedTasks: z.ZodOptional<z.ZodInt>;
+        incidents: z.ZodInt;
+        sessions: z.ZodInt;
+        toolCalls: z.ZodInt;
+    }, z.core.$strict>>;
+    lastSeenAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    level: z.ZodOptional<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    standing: z.ZodOptional<z.ZodObject<{
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            history_days: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+            distinct_operators: z.ZodInt;
+            safety_incidents_90d: z.ZodInt;
+        }, z.core.$strict>;
+        history_days: z.ZodInt;
+        last_active: z.ZodNullable<z.ZodISODateTime>;
+        dormant_days: z.ZodNullable<z.ZodInt>;
+        quiet: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentResponse = z.infer<typeof AgentResponse>;
+export declare const RENAME_REDIRECT_DAYS = 30;
+export declare const RENAME_MAX_AGE_SEC = 300;
+export declare const RenameAgentRequest: z.ZodObject<{
+    name: z.ZodString;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RenameAgentRequest = z.infer<typeof RenameAgentRequest>;
+export declare const VERSION_CHANGES_PER_DAY = 10;
+export declare const ChangeVersionRequest: z.ZodObject<{
+    version: z.ZodString;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ChangeVersionRequest = z.infer<typeof ChangeVersionRequest>;
+export declare const UpdateAgentRequest: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type UpdateAgentRequest = z.infer<typeof UpdateAgentRequest>;
+export declare const SignedRenameRequest: z.ZodObject<{
+    envelope: z.ZodString;
+}, z.core.$strict>;
+export type SignedRenameRequest = z.infer<typeof SignedRenameRequest>;
+export declare const DELETE_AGENT_MAX_AGE_SEC = 300;
+export declare const DeleteAgentRequest: z.ZodObject<{
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type DeleteAgentRequest = z.infer<typeof DeleteAgentRequest>;
+export declare const DeleteAgentBody: z.ZodUnion<readonly [z.ZodObject<{
+    envelope: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{}, z.core.$strict>]>;
+export type DeleteAgentBody = z.infer<typeof DeleteAgentBody>;
+export declare const AgentHandleParams: z.ZodObject<{
+    login: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type AgentHandleParams = z.infer<typeof AgentHandleParams>;
+export declare const AgentRenamedResponse: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodLiteral<"renamed">;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    id: z.ZodString;
+    handle: z.ZodString;
+}, z.core.$strict>;
+export type AgentRenamedResponse = z.infer<typeof AgentRenamedResponse>;
+export declare const GithubLogin: z.ZodString;
+export type AgentsCursor = {
+    createdAtMicros: string;
+    id: string;
+};
+export declare function encodeAgentsCursor(cursor: AgentsCursor): string;
+export declare function decodeAgentsCursor(raw: string): AgentsCursor | null;
+export declare const AgentsCursorParam: z.ZodPipe<z.ZodString, z.ZodTransform<AgentsCursor, string>>;
+export declare const AgentsListQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<AgentsCursor, string>>>;
+    operator: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AgentsListQuery = z.infer<typeof AgentsListQuery>;
+export declare const TopScore: z.ZodObject<{
+    dimension: z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>;
+    value: z.ZodNumber;
+}, z.core.$strict>;
+export type TopScore = z.infer<typeof TopScore>;
+export declare const AgentSummary: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    handle: z.ZodString;
+    version: z.ZodString;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    operatedBySealKeeper: z.ZodBoolean;
+    operatedByVouched: z.ZodOptional<z.ZodBoolean>;
+    createdAt: z.ZodISODateTime;
+    lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+    topScores: z.ZodArray<z.ZodObject<{
+        dimension: z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strict>>;
+    verifiedTasks: z.ZodInt;
+    seedTasks: z.ZodInt;
+    level: z.ZodOptional<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    standing: z.ZodOptional<z.ZodObject<{
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            history_days: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+            distinct_operators: z.ZodInt;
+            safety_incidents_90d: z.ZodInt;
+        }, z.core.$strict>;
+        history_days: z.ZodInt;
+        last_active: z.ZodNullable<z.ZodISODateTime>;
+        dormant_days: z.ZodNullable<z.ZodInt>;
+        quiet: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentSummary = z.infer<typeof AgentSummary>;
+export declare const AgentsListResponse: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        handle: z.ZodString;
+        version: z.ZodString;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        operatedBySealKeeper: z.ZodBoolean;
+        operatedByVouched: z.ZodOptional<z.ZodBoolean>;
+        createdAt: z.ZodISODateTime;
+        lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+        topScores: z.ZodArray<z.ZodObject<{
+            dimension: z.ZodEnum<{
+                cost_latency: "cost_latency";
+                provenance: "provenance";
+                reliability: "reliability";
+                safety: "safety";
+            }>;
+            value: z.ZodNumber;
+        }, z.core.$strict>>;
+        verifiedTasks: z.ZodInt;
+        seedTasks: z.ZodInt;
+        level: z.ZodOptional<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        standing: z.ZodOptional<z.ZodObject<{
+            counts: z.ZodObject<{
+                events: z.ZodInt;
+                history_days: z.ZodInt;
+                verified_tasks: z.ZodInt;
+                seed_tasks: z.ZodInt;
+                server_checked_tasks: z.ZodInt;
+                confirmed_tasks: z.ZodInt;
+                distinct_operators: z.ZodInt;
+                safety_incidents_90d: z.ZodInt;
+            }, z.core.$strict>;
+            history_days: z.ZodInt;
+            last_active: z.ZodNullable<z.ZodISODateTime>;
+            dormant_days: z.ZodNullable<z.ZodInt>;
+            quiet: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type AgentsListResponse = z.infer<typeof AgentsListResponse>;
+export declare const AgentCardResponse: z.ZodObject<{
+    name: z.ZodString;
+    capabilities: z.ZodObject<{
+        extensions: z.ZodArray<z.ZodObject<{
+            uri: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type AgentCardResponse = z.infer<typeof AgentCardResponse>;
+export declare const EventsBatchRequest: z.ZodObject<{
+    envelopes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type EventsBatchRequest = z.infer<typeof EventsBatchRequest>;
+export declare const EventsBatchResponse: z.ZodObject<{
+    accepted: z.ZodInt;
+    duplicates: z.ZodInt;
+}, z.core.$strict>;
+export type EventsBatchResponse = z.infer<typeof EventsBatchResponse>;
+export declare const PostTaskRequest: z.ZodObject<{
+    taskId: z.ZodUUID;
+    taskType: z.ZodString;
+    spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    verification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"hash">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema">;
+        jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"counterparty">;
+    }, z.core.$strict>], "kind">;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type PostTaskRequest = z.infer<typeof PostTaskRequest>;
+export declare const TaskResponse: z.ZodObject<{
+    id: z.ZodUUID;
+    posterAgentId: z.ZodString;
+    claimantAgentId: z.ZodNullable<z.ZodString>;
+    taskType: z.ZodString;
+    spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    verification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"hash">;
+        sha256: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema">;
+        jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"counterparty">;
+    }, z.core.$strict>], "kind">;
+    state: z.ZodEnum<{
+        claimed: "claimed";
+        expired: "expired";
+        open: "open";
+        submitted: "submitted";
+        verified: "verified";
+    }>;
+    postedAt: z.ZodISODateTime;
+    claimedAt: z.ZodNullable<z.ZodISODateTime>;
+    submittedAt: z.ZodNullable<z.ZodISODateTime>;
+    verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+    expiresAt: z.ZodISODateTime;
+    submission: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TaskResponse = z.infer<typeof TaskResponse>;
+export declare const ClaimTaskRequest: z.ZodObject<{
+    taskId: z.ZodUUID;
+}, z.core.$strict>;
+export type ClaimTaskRequest = z.infer<typeof ClaimTaskRequest>;
+export declare const SubmitTaskRequest: z.ZodObject<{
+    taskId: z.ZodUUID;
+    submission: z.ZodString;
+}, z.core.$strict>;
+export type SubmitTaskRequest = z.infer<typeof SubmitTaskRequest>;
+export declare const TaskOutcomeRequest: z.ZodObject<{
+    taskId: z.ZodUUID;
+    outcome: z.ZodEnum<{
+        failure: "failure";
+        success: "success";
+    }>;
+    evidenceHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TaskOutcomeRequest = z.infer<typeof TaskOutcomeRequest>;
+export declare const ListTasksQuery: z.ZodObject<{
+    state: z.ZodDefault<z.ZodEnum<{
+        claimed: "claimed";
+        expired: "expired";
+        open: "open";
+        submitted: "submitted";
+        verified: "verified";
+    }>>;
+    taskType: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type ListTasksQuery = z.infer<typeof ListTasksQuery>;
+export declare const ListTasksResponse: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        posterAgentId: z.ZodString;
+        claimantAgentId: z.ZodNullable<z.ZodString>;
+        taskType: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        verification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"hash">;
+            sha256: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"schema">;
+            jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"counterparty">;
+        }, z.core.$strict>], "kind">;
+        state: z.ZodEnum<{
+            claimed: "claimed";
+            expired: "expired";
+            open: "open";
+            submitted: "submitted";
+            verified: "verified";
+        }>;
+        postedAt: z.ZodISODateTime;
+        claimedAt: z.ZodNullable<z.ZodISODateTime>;
+        submittedAt: z.ZodNullable<z.ZodISODateTime>;
+        verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+        expiresAt: z.ZodISODateTime;
+        submission: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ListTasksResponse = z.infer<typeof ListTasksResponse>;
+export declare const SignedRatingRequest: z.ZodObject<{
+    envelope: z.ZodString;
+}, z.core.$strict>;
+export type SignedRatingRequest = z.infer<typeof SignedRatingRequest>;
+export declare const RatingValue: z.ZodInt;
+export type RatingValue = z.infer<typeof RatingValue>;
+export declare const RatingRequest: z.ZodObject<{
+    rateeAgentId: z.ZodString;
+    dimension: z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+    value: z.ZodInt;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RatingRequest = z.infer<typeof RatingRequest>;
+export declare const RatingResponse: z.ZodObject<{
+    rateeAgentId: z.ZodString;
+    dimension: z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+    value: z.ZodInt;
+    raterScoreAtTime: z.ZodNumber;
+}, z.core.$strict>;
+export type RatingResponse = z.infer<typeof RatingResponse>;
+export declare const ScoreEntry: z.ZodObject<{
+    version: z.ZodString;
+    dimension: z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+    value: z.ZodNullable<z.ZodNumber>;
+    windowStart: z.ZodNullable<z.ZodISODateTime>;
+    windowEnd: z.ZodNullable<z.ZodISODateTime>;
+    computedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type ScoreEntry = z.infer<typeof ScoreEntry>;
+export declare const ScoreResponse: z.ZodObject<{
+    agentId: z.ZodString;
+    scores: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        dimension: z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+        value: z.ZodNullable<z.ZodNumber>;
+        windowStart: z.ZodNullable<z.ZodISODateTime>;
+        windowEnd: z.ZodNullable<z.ZodISODateTime>;
+        computedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ScoreResponse = z.infer<typeof ScoreResponse>;
+export declare const MeAgent: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    handle: z.ZodString;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    version: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+    scores: z.ZodObject<{
+        agentId: z.ZodString;
+        scores: z.ZodArray<z.ZodObject<{
+            version: z.ZodString;
+            dimension: z.ZodUnion<readonly [z.ZodEnum<{
+                cost_latency: "cost_latency";
+                provenance: "provenance";
+                reliability: "reliability";
+                safety: "safety";
+            }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+            value: z.ZodNullable<z.ZodNumber>;
+            windowStart: z.ZodNullable<z.ZodISODateTime>;
+            windowEnd: z.ZodNullable<z.ZodISODateTime>;
+            computedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    verifiedTasks: z.ZodInt;
+    seedTasks: z.ZodInt;
+    level: z.ZodOptional<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    standing: z.ZodOptional<z.ZodObject<{
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            history_days: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+            distinct_operators: z.ZodInt;
+            safety_incidents_90d: z.ZodInt;
+        }, z.core.$strict>;
+        history_days: z.ZodInt;
+        last_active: z.ZodNullable<z.ZodISODateTime>;
+        dormant_days: z.ZodNullable<z.ZodInt>;
+        quiet: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MeAgent = z.infer<typeof MeAgent>;
+export declare const MeResponse: z.ZodObject<{
+    operator: z.ZodObject<{
+        login: z.ZodString;
+        githubId: z.ZodInt;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        handle: z.ZodString;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        version: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+        scores: z.ZodObject<{
+            agentId: z.ZodString;
+            scores: z.ZodArray<z.ZodObject<{
+                version: z.ZodString;
+                dimension: z.ZodUnion<readonly [z.ZodEnum<{
+                    cost_latency: "cost_latency";
+                    provenance: "provenance";
+                    reliability: "reliability";
+                    safety: "safety";
+                }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+                value: z.ZodNullable<z.ZodNumber>;
+                windowStart: z.ZodNullable<z.ZodISODateTime>;
+                windowEnd: z.ZodNullable<z.ZodISODateTime>;
+                computedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        verifiedTasks: z.ZodInt;
+        seedTasks: z.ZodInt;
+        level: z.ZodOptional<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        standing: z.ZodOptional<z.ZodObject<{
+            counts: z.ZodObject<{
+                events: z.ZodInt;
+                history_days: z.ZodInt;
+                verified_tasks: z.ZodInt;
+                seed_tasks: z.ZodInt;
+                server_checked_tasks: z.ZodInt;
+                confirmed_tasks: z.ZodInt;
+                distinct_operators: z.ZodInt;
+                safety_incidents_90d: z.ZodInt;
+            }, z.core.$strict>;
+            history_days: z.ZodInt;
+            last_active: z.ZodNullable<z.ZodISODateTime>;
+            dormant_days: z.ZodNullable<z.ZodInt>;
+            quiet: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MeResponse = z.infer<typeof MeResponse>;
+export declare const DeleteMeRequest: z.ZodObject<{
+    login: z.ZodString;
+}, z.core.$strict>;
+export type DeleteMeRequest = z.infer<typeof DeleteMeRequest>;
+export declare const CredentialResponse: z.ZodObject<{
+    credential: z.ZodString;
+    seal: z.ZodString;
+    payload: z.ZodObject<{
+        iss: z.ZodLiteral<"sealkeeper.run">;
+        sub: z.ZodString;
+        ver: z.ZodLiteral<1>;
+        iat: z.ZodInt;
+        exp: z.ZodInt;
+        agent_version: z.ZodString;
+        version: z.ZodString;
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            history_days: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+            distinct_operators: z.ZodInt;
+            safety_incidents_90d: z.ZodInt;
+        }, z.core.$strict>;
+        operator: z.ZodObject<{
+            verified: z.ZodBoolean;
+        }, z.core.$strict>;
+        identity: z.ZodArray<z.ZodObject<{
+            provider: z.ZodURL;
+            kind: z.ZodUnion<readonly [z.ZodEnum<{
+                kya: "kya";
+                oidc: "oidc";
+                saml: "saml";
+                verifiable_credential: "verifiable_credential";
+            }>, z.ZodURL]>;
+            ref: z.ZodString;
+            subject_hash: z.ZodString;
+            attested_at: z.ZodInt;
+            scope: z.ZodEnum<{
+                agent: "agent";
+                operator: "operator";
+            }>;
+        }, z.core.$strict>>;
+        last_active: z.ZodNullable<z.ZodInt>;
+        dormant_days: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CredentialResponse = z.infer<typeof CredentialResponse>;
+export declare const LeaderboardQuery: z.ZodObject<{
+    dimension: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type LeaderboardQuery = z.infer<typeof LeaderboardQuery>;
+export declare const LeaderboardEntry: z.ZodObject<{
+    rank: z.ZodInt;
+    agentId: z.ZodString;
+    name: z.ZodString;
+    handle: z.ZodString;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    version: z.ZodString;
+    value: z.ZodNumber;
+    verifiedTasks: z.ZodInt;
+    seedTasks: z.ZodOptional<z.ZodInt>;
+    operatedBySealKeeper: z.ZodBoolean;
+    operatedByVouched: z.ZodOptional<z.ZodBoolean>;
+    level: z.ZodOptional<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    standing: z.ZodOptional<z.ZodObject<{
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            history_days: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+            distinct_operators: z.ZodInt;
+            safety_incidents_90d: z.ZodInt;
+        }, z.core.$strict>;
+        history_days: z.ZodInt;
+        last_active: z.ZodNullable<z.ZodISODateTime>;
+        dormant_days: z.ZodNullable<z.ZodInt>;
+        quiet: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LeaderboardEntry = z.infer<typeof LeaderboardEntry>;
+export declare const LeaderboardResponse: z.ZodObject<{
+    dimension: z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+    entries: z.ZodArray<z.ZodObject<{
+        rank: z.ZodInt;
+        agentId: z.ZodString;
+        name: z.ZodString;
+        handle: z.ZodString;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        version: z.ZodString;
+        value: z.ZodNumber;
+        verifiedTasks: z.ZodInt;
+        seedTasks: z.ZodOptional<z.ZodInt>;
+        operatedBySealKeeper: z.ZodBoolean;
+        operatedByVouched: z.ZodOptional<z.ZodBoolean>;
+        level: z.ZodOptional<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        standing: z.ZodOptional<z.ZodObject<{
+            counts: z.ZodObject<{
+                events: z.ZodInt;
+                history_days: z.ZodInt;
+                verified_tasks: z.ZodInt;
+                seed_tasks: z.ZodInt;
+                server_checked_tasks: z.ZodInt;
+                confirmed_tasks: z.ZodInt;
+                distinct_operators: z.ZodInt;
+                safety_incidents_90d: z.ZodInt;
+            }, z.core.$strict>;
+            history_days: z.ZodInt;
+            last_active: z.ZodNullable<z.ZodISODateTime>;
+            dormant_days: z.ZodNullable<z.ZodInt>;
+            quiet: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LeaderboardResponse = z.infer<typeof LeaderboardResponse>;
+export declare const FeedKind: z.ZodEnum<{
+    flag: "flag";
+    registration: "registration";
+    score_change: "score_change";
+    task_verified: "task_verified";
+    version_change: "version_change";
+}>;
+export type FeedKind = z.infer<typeof FeedKind>;
+export declare const FeedFlagCode: z.ZodEnum<{
+    outcome_disagreement: "outcome_disagreement";
+}>;
+export type FeedFlagCode = z.infer<typeof FeedFlagCode>;
+export declare const FeedPayloads: {
+    registration: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    task_verified: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        taskId: z.ZodUUID;
+        taskType: z.ZodString;
+    }, z.core.$strict>;
+    score_change: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        dimension: z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+        old: z.ZodNullable<z.ZodNumber>;
+        new: z.ZodNumber;
+    }, z.core.$strict>;
+    flag: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        code: z.ZodEnum<{
+            outcome_disagreement: "outcome_disagreement";
+        }>;
+        taskId: z.ZodUUID;
+    }, z.core.$strict>;
+    version_change: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        old: z.ZodString;
+        new: z.ZodString;
+    }, z.core.$strict>;
+};
+export type FeedPayload<K extends FeedKind> = z.infer<(typeof FeedPayloads)[K]>;
+export declare const FeedItem: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodInt;
+    kind: z.ZodLiteral<"registration">;
+    agentId: z.ZodNullable<z.ZodString>;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    handle: z.ZodString;
+    payload: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodInt;
+    kind: z.ZodLiteral<"task_verified">;
+    agentId: z.ZodNullable<z.ZodString>;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    handle: z.ZodString;
+    payload: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        taskId: z.ZodUUID;
+        taskType: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodInt;
+    kind: z.ZodLiteral<"score_change">;
+    agentId: z.ZodNullable<z.ZodString>;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    handle: z.ZodString;
+    payload: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        dimension: z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+        old: z.ZodNullable<z.ZodNumber>;
+        new: z.ZodNumber;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodInt;
+    kind: z.ZodLiteral<"flag">;
+    agentId: z.ZodNullable<z.ZodString>;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    handle: z.ZodString;
+    payload: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        code: z.ZodEnum<{
+            outcome_disagreement: "outcome_disagreement";
+        }>;
+        taskId: z.ZodUUID;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodInt;
+    kind: z.ZodLiteral<"version_change">;
+    agentId: z.ZodNullable<z.ZodString>;
+    operator: z.ZodObject<{
+        login: z.ZodString;
+    }, z.core.$strict>;
+    handle: z.ZodString;
+    payload: z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        old: z.ZodString;
+        new: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>], "kind">;
+export type FeedItem = z.infer<typeof FeedItem>;
+export declare const FEED_RECENT_MAX = 200;
+export declare const FeedRecentQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type FeedRecentQuery = z.infer<typeof FeedRecentQuery>;
+export declare const FeedRecentResponse: z.ZodObject<{
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodLiteral<"registration">;
+        agentId: z.ZodNullable<z.ZodString>;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        handle: z.ZodString;
+        payload: z.ZodObject<{
+            agentId: z.ZodString;
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodLiteral<"task_verified">;
+        agentId: z.ZodNullable<z.ZodString>;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        handle: z.ZodString;
+        payload: z.ZodObject<{
+            agentId: z.ZodString;
+            name: z.ZodString;
+            taskId: z.ZodUUID;
+            taskType: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodLiteral<"score_change">;
+        agentId: z.ZodNullable<z.ZodString>;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        handle: z.ZodString;
+        payload: z.ZodObject<{
+            agentId: z.ZodString;
+            name: z.ZodString;
+            version: z.ZodString;
+            dimension: z.ZodUnion<readonly [z.ZodEnum<{
+                cost_latency: "cost_latency";
+                provenance: "provenance";
+                reliability: "reliability";
+                safety: "safety";
+            }>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+            old: z.ZodNullable<z.ZodNumber>;
+            new: z.ZodNumber;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodLiteral<"flag">;
+        agentId: z.ZodNullable<z.ZodString>;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        handle: z.ZodString;
+        payload: z.ZodObject<{
+            agentId: z.ZodString;
+            name: z.ZodString;
+            code: z.ZodEnum<{
+                outcome_disagreement: "outcome_disagreement";
+            }>;
+            taskId: z.ZodUUID;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodInt;
+        kind: z.ZodLiteral<"version_change">;
+        agentId: z.ZodNullable<z.ZodString>;
+        operator: z.ZodObject<{
+            login: z.ZodString;
+        }, z.core.$strict>;
+        handle: z.ZodString;
+        payload: z.ZodObject<{
+            agentId: z.ZodString;
+            name: z.ZodString;
+            old: z.ZodString;
+            new: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type FeedRecentResponse = z.infer<typeof FeedRecentResponse>;
+export declare const StatsResponse: z.ZodObject<{
+    agents: z.ZodInt;
+    verifiedTasks: z.ZodInt;
+    eventsLast24h: z.ZodInt;
+}, z.core.$strict>;
+export type StatsResponse = z.infer<typeof StatsResponse>;
+export declare const CHECK_DEFAULT_MIN_VERIFIED = 1;
+export declare const CHECK_DEFAULT_MAX_INCIDENTS = 0;
+export declare const CHECK_DEFAULT_MIN_LEVEL = "bronze";
+export declare const CheckQuery: z.ZodObject<{
+    minVerified: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    maxIncidents: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
+    minReliability: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+    minSafety: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+    minLevel: z.ZodDefault<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+}, z.core.$strict>;
+export type CheckQuery = z.infer<typeof CheckQuery>;
+export declare const CheckName: z.ZodEnum<{
+    maxIncidents: "maxIncidents";
+    minLevel: "minLevel";
+    minReliability: "minReliability";
+    minSafety: "minSafety";
+    minVerified: "minVerified";
+    seal: "seal";
+}>;
+export type CheckName = z.infer<typeof CheckName>;
+export declare const SealPresence: z.ZodEnum<{
+    present: "present";
+    withheld: "withheld";
+}>;
+export type SealPresence = z.infer<typeof SealPresence>;
+export declare const Check: z.ZodObject<{
+    name: z.ZodEnum<{
+        maxIncidents: "maxIncidents";
+        minLevel: "minLevel";
+        minReliability: "minReliability";
+        minSafety: "minSafety";
+        minVerified: "minVerified";
+        seal: "seal";
+    }>;
+    required: z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>, z.ZodEnum<{
+        present: "present";
+        withheld: "withheld";
+    }>]>;
+    actual: z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>, z.ZodEnum<{
+        present: "present";
+        withheld: "withheld";
+    }>]>>;
+    ok: z.ZodBoolean;
+}, z.core.$strict>;
+export type Check = z.infer<typeof Check>;
+export declare const CheckResponse: z.ZodObject<{
+    ok: z.ZodBoolean;
+    id: z.ZodString;
+    handle: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            maxIncidents: "maxIncidents";
+            minLevel: "minLevel";
+            minReliability: "minReliability";
+            minSafety: "minSafety";
+            minVerified: "minVerified";
+            seal: "seal";
+        }>;
+        required: z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>, z.ZodEnum<{
+            present: "present";
+            withheld: "withheld";
+        }>]>;
+        actual: z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>, z.ZodEnum<{
+            present: "present";
+            withheld: "withheld";
+        }>]>>;
+        ok: z.ZodBoolean;
+    }, z.core.$strict>>;
+    credential: z.ZodString;
+}, z.core.$strict>;
+export type CheckResponse = z.infer<typeof CheckResponse>;
+export declare const SealCheckResponse: z.ZodObject<{
+    ok: z.ZodBoolean;
+    id: z.ZodString;
+    handle: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            maxIncidents: "maxIncidents";
+            minLevel: "minLevel";
+            minReliability: "minReliability";
+            minSafety: "minSafety";
+            minVerified: "minVerified";
+            seal: "seal";
+        }>;
+        required: z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>, z.ZodEnum<{
+            present: "present";
+            withheld: "withheld";
+        }>]>;
+        actual: z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>, z.ZodEnum<{
+            present: "present";
+            withheld: "withheld";
+        }>]>>;
+        ok: z.ZodBoolean;
+    }, z.core.$strict>>;
+    credential: z.ZodNullable<z.ZodString>;
+    seal: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type SealCheckResponse = z.infer<typeof SealCheckResponse>;
+export declare const SealWithheldResponse: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodLiteral<"no_seal">;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    id: z.ZodString;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type SealWithheldResponse = z.infer<typeof SealWithheldResponse>;
+export declare const SealVerifyRequest: z.ZodObject<{
+    seal: z.ZodString;
+}, z.core.$strict>;
+export type SealVerifyRequest = z.infer<typeof SealVerifyRequest>;
+export declare const SealBrokenReason: z.ZodEnum<{
+    bad_signature: "bad_signature";
+    expired: "expired";
+    malformed: "malformed";
+    not_yet_valid: "not_yet_valid";
+    unknown_kid: "unknown_kid";
+    unsupported_version: "unsupported_version";
+    wrong_issuer: "wrong_issuer";
+}>;
+export type SealBrokenReason = z.infer<typeof SealBrokenReason>;
+export declare const SealVerifyResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    valid: z.ZodLiteral<true>;
+    payload: z.ZodUnion<readonly [z.ZodObject<{
+        iss: z.ZodEnum<{
+            "sealkeeper.run": "sealkeeper.run";
+            "vouched.run": "vouched.run";
+        }>;
+        sub: z.ZodString;
+        ver: z.ZodLiteral<1>;
+        iat: z.ZodInt;
+        exp: z.ZodInt;
+        agent_version: z.ZodString;
+        version: z.ZodString;
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            history_days: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodInt;
+            server_checked_tasks: z.ZodInt;
+            confirmed_tasks: z.ZodInt;
+            distinct_operators: z.ZodInt;
+            safety_incidents_90d: z.ZodInt;
+        }, z.core.$strict>;
+        operator: z.ZodObject<{
+            verified: z.ZodBoolean;
+        }, z.core.$strict>;
+        identity: z.ZodArray<z.ZodObject<{
+            provider: z.ZodURL;
+            kind: z.ZodUnion<readonly [z.ZodEnum<{
+                kya: "kya";
+                oidc: "oidc";
+                saml: "saml";
+                verifiable_credential: "verifiable_credential";
+            }>, z.ZodURL]>;
+            ref: z.ZodString;
+            subject_hash: z.ZodString;
+            attested_at: z.ZodInt;
+            scope: z.ZodEnum<{
+                agent: "agent";
+                operator: "operator";
+            }>;
+        }, z.core.$strict>>;
+        last_active: z.ZodNullable<z.ZodInt>;
+        dormant_days: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>, z.ZodObject<{
+        iss: z.ZodEnum<{
+            "sealkeeper.run": "sealkeeper.run";
+            "vouched.run": "vouched.run";
+        }>;
+        sub: z.ZodString;
+        iat: z.ZodInt;
+        exp: z.ZodInt;
+        version: z.ZodString;
+        scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+            cost_latency: "cost_latency";
+            provenance: "provenance";
+            reliability: "reliability";
+            safety: "safety";
+        }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+        counts: z.ZodObject<{
+            events: z.ZodInt;
+            verified_tasks: z.ZodInt;
+            seed_tasks: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+    expiresIn: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    valid: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        bad_signature: "bad_signature";
+        expired: "expired";
+        malformed: "malformed";
+        not_yet_valid: "not_yet_valid";
+        unknown_kid: "unknown_kid";
+        unsupported_version: "unsupported_version";
+        wrong_issuer: "wrong_issuer";
+    }>;
+}, z.core.$strict>], "valid">;
+export type SealVerifyResponse = z.infer<typeof SealVerifyResponse>;
+export declare const ScoreRunResponse: z.ZodObject<{
+    scored: z.ZodInt;
+}, z.core.$strict>;
+export type ScoreRunResponse = z.infer<typeof ScoreRunResponse>;
+export declare const SeedRunResponse: z.ZodObject<{
+    open: z.ZodInt;
+    added: z.ZodInt;
+}, z.core.$strict>;
+export type SeedRunResponse = z.infer<typeof SeedRunResponse>;
+export declare const ErrorIssue: z.ZodObject<{
+    path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    code: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strict>;
+export declare const ErrorResponse: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ErrorResponse = z.infer<typeof ErrorResponse>;