openpond-sdk 0.11.5 → 0.12.0

package/dist/types/packages/sdk/src/dataset-preparation-contracts.d.ts

@@ -0,0 +1,860 @@
+import { z } from "zod";
+export declare const DatasetPreparationGrantCreateSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    maximumMicroUsd: z.ZodNumber;
+    maximumSandboxSeconds: z.ZodNumber;
+}, z.core.$strict>;
+export declare const DatasetPreparationGrantSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.datasetPreparationGrant.v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    projectId: z.ZodString;
+    maximumMicroUsd: z.ZodNumber;
+    maximumSandboxSeconds: z.ZodNumber;
+    settledMicroUsd: z.ZodNumber;
+    heldMicroUsd: z.ZodNumber;
+    sandboxSeconds: z.ZodNumber;
+    heldSandboxSeconds: z.ZodNumber;
+    unresolvedCalls: z.ZodNumber;
+    cleanupPending: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const DatasetPreparationTaskClassSchema: z.ZodEnum<{
+    coding_change: "coding_change";
+    debugging: "debugging";
+    code_explanation: "code_explanation";
+    structured_text: "structured_text";
+    artifact_work: "artifact_work";
+}>;
+export declare const DatasetPreparationStageSchema: z.ZodEnum<{
+    release: "release";
+    qualification: "qualification";
+    inventory: "inventory";
+    preview: "preview";
+    reconstruction: "reconstruction";
+    grader_authoring: "grader_authoring";
+}>;
+export declare const DatasetPreparationStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    failed: "failed";
+    running: "running";
+    cancelling: "cancelling";
+    completed: "completed";
+    budget_exhausted: "budget_exhausted";
+    draft: "draft";
+    ready: "ready";
+    paused: "paused";
+    pausing: "pausing";
+    needs_attention: "needs_attention";
+    preview_ready: "preview_ready";
+    releasing: "releasing";
+    insufficient_data: "insufficient_data";
+}>;
+export declare const DatasetPreparationSourceSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    from: z.ZodISODateTime;
+    to: z.ZodISODateTime;
+    importCutoff: z.ZodISODateTime;
+    connections: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const DatasetPreparationPolicySchema: z.ZodObject<{
+    source: z.ZodObject<{
+        projectId: z.ZodString;
+        from: z.ZodISODateTime;
+        to: z.ZodISODateTime;
+        importCutoff: z.ZodISODateTime;
+        connections: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    taskClasses: z.ZodArray<z.ZodEnum<{
+        coding_change: "coding_change";
+        debugging: "debugging";
+        code_explanation: "code_explanation";
+        structured_text: "structured_text";
+        artifact_work: "artifact_work";
+    }>>;
+    limits: z.ZodObject<{
+        maximumConversations: z.ZodNumber;
+        maximumCandidates: z.ZodNumber;
+        acceptedTarget: z.ZodNumber;
+        maximumRepairsPerCandidate: z.ZodNumber;
+        maximumEvidenceBytesPerConversation: z.ZodNumber;
+    }, z.core.$strict>;
+    researcher: z.ZodObject<{
+        modelId: z.ZodString;
+        maximumOutputTokens: z.ZodNumber;
+    }, z.core.$strict>;
+    adjudicator: z.ZodObject<{
+        modelId: z.ZodString;
+        maximumOutputTokens: z.ZodNumber;
+    }, z.core.$strict>;
+    grading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"auto">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"existing_only">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"manual">;
+        releases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "mode">;
+    budget: z.ZodObject<{
+        grantId: z.ZodString;
+        maximumMicroUsd: z.ZodNumber;
+        previewMaximumMicroUsd: z.ZodNumber;
+        qualificationMaximumMicroUsdPerCandidate: z.ZodNumber;
+        maximumSandboxSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    finish: z.ZodEnum<{
+        stop_ready: "stop_ready";
+        create_private_version: "create_private_version";
+    }>;
+    execution: z.ZodEnum<{
+        prepare: "prepare";
+        preview_only: "preview_only";
+    }>;
+    allowPartialVersion: z.ZodBoolean;
+    population: z.ZodLiteral<"development">;
+}, z.core.$strict>;
+export declare const DatasetPreparationCreateSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    expectedDatasetRevision: z.ZodNumber;
+    policy: z.ZodObject<{
+        source: z.ZodObject<{
+            projectId: z.ZodString;
+            from: z.ZodISODateTime;
+            to: z.ZodISODateTime;
+            importCutoff: z.ZodISODateTime;
+            connections: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        taskClasses: z.ZodArray<z.ZodEnum<{
+            coding_change: "coding_change";
+            debugging: "debugging";
+            code_explanation: "code_explanation";
+            structured_text: "structured_text";
+            artifact_work: "artifact_work";
+        }>>;
+        limits: z.ZodObject<{
+            maximumConversations: z.ZodNumber;
+            maximumCandidates: z.ZodNumber;
+            acceptedTarget: z.ZodNumber;
+            maximumRepairsPerCandidate: z.ZodNumber;
+            maximumEvidenceBytesPerConversation: z.ZodNumber;
+        }, z.core.$strict>;
+        researcher: z.ZodObject<{
+            modelId: z.ZodString;
+            maximumOutputTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        adjudicator: z.ZodObject<{
+            modelId: z.ZodString;
+            maximumOutputTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        grading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"auto">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"existing_only">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"manual">;
+            releases: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "mode">;
+        budget: z.ZodObject<{
+            grantId: z.ZodString;
+            maximumMicroUsd: z.ZodNumber;
+            previewMaximumMicroUsd: z.ZodNumber;
+            qualificationMaximumMicroUsdPerCandidate: z.ZodNumber;
+            maximumSandboxSeconds: z.ZodNumber;
+        }, z.core.$strict>;
+        finish: z.ZodEnum<{
+            stop_ready: "stop_ready";
+            create_private_version: "create_private_version";
+        }>;
+        execution: z.ZodEnum<{
+            prepare: "prepare";
+            preview_only: "preview_only";
+        }>;
+        allowPartialVersion: z.ZodBoolean;
+        population: z.ZodLiteral<"development">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DatasetPreparationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodEnum<{
+        pause: "pause";
+        resume: "resume";
+        release: "release";
+        start: "start";
+        cancel: "cancel";
+    }>;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"resolve">;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateId: z.ZodString;
+    decision: z.ZodEnum<{
+        exclude: "exclude";
+        retry: "retry";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>], "action">;
+export declare const DatasetPreparationCoverageSchema: z.ZodObject<{
+    conversations: z.ZodNumber;
+    importedTurns: z.ZodNumber;
+    selectedTurns: z.ZodNumber;
+    queuedSnapshots: z.ZodNullable<z.ZodNumber>;
+    failedSessions: z.ZodNullable<z.ZodNumber>;
+    skippedSessions: z.ZodNullable<z.ZodNumber>;
+    lastAdmissionAt: z.ZodNullable<z.ZodISODateTime>;
+    complete: z.ZodBoolean;
+    reasons: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    sourceInventoryHash: z.ZodString;
+}, z.core.$strict>;
+export declare const DatasetPreparationAccountingSchema: z.ZodObject<{
+    maximumMicroUsd: z.ZodNumber;
+    settledMicroUsd: z.ZodNumber;
+    heldMicroUsd: z.ZodNumber;
+    unresolvedCalls: z.ZodNumber;
+    sandboxSeconds: z.ZodNumber;
+    cleanupPending: z.ZodNumber;
+    complete: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const DatasetPreparationPreviewSchema: z.ZodObject<{
+    sampleConversations: z.ZodNumber;
+    sampleTurns: z.ZodNumber;
+    candidateCount: z.ZodNumber;
+    modelId: z.ZodString;
+    modelConfigurationHash: z.ZodString;
+    callReceiptIds: z.ZodArray<z.ZodString>;
+    inputTokens: z.ZodNullable<z.ZodNumber>;
+    outputTokens: z.ZodNullable<z.ZodNumber>;
+    classes: z.ZodArray<z.ZodObject<{
+        taskClass: z.ZodEnum<{
+            coding_change: "coding_change";
+            debugging: "debugging";
+            code_explanation: "code_explanation";
+            structured_text: "structured_text";
+            artifact_work: "artifact_work";
+        }>;
+        candidates: z.ZodNumber;
+        assessment: z.ZodEnum<{
+            executable: "executable";
+            calibrated_judge: "calibrated_judge";
+            unsupported: "unsupported";
+        }>;
+        requirements: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    exclusions: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        count: z.ZodNumber;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    estimates: z.ZodArray<z.ZodObject<{
+        stage: z.ZodEnum<{
+            release: "release";
+            qualification: "qualification";
+            inventory: "inventory";
+            preview: "preview";
+            reconstruction: "reconstruction";
+            grader_authoring: "grader_authoring";
+        }>;
+        minimumMicroUsd: z.ZodNumber;
+        maximumMicroUsd: z.ZodNumber;
+        assumptions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const DatasetPreparationRunSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.datasetPreparationRun.v1">;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    datasetId: z.ZodString;
+    datasetRevision: z.ZodNumber;
+    revision: z.ZodNumber;
+    requestHash: z.ZodString;
+    policy: z.ZodObject<{
+        source: z.ZodObject<{
+            projectId: z.ZodString;
+            from: z.ZodISODateTime;
+            to: z.ZodISODateTime;
+            importCutoff: z.ZodISODateTime;
+            connections: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        taskClasses: z.ZodArray<z.ZodEnum<{
+            coding_change: "coding_change";
+            debugging: "debugging";
+            code_explanation: "code_explanation";
+            structured_text: "structured_text";
+            artifact_work: "artifact_work";
+        }>>;
+        limits: z.ZodObject<{
+            maximumConversations: z.ZodNumber;
+            maximumCandidates: z.ZodNumber;
+            acceptedTarget: z.ZodNumber;
+            maximumRepairsPerCandidate: z.ZodNumber;
+            maximumEvidenceBytesPerConversation: z.ZodNumber;
+        }, z.core.$strict>;
+        researcher: z.ZodObject<{
+            modelId: z.ZodString;
+            maximumOutputTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        adjudicator: z.ZodObject<{
+            modelId: z.ZodString;
+            maximumOutputTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        grading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"auto">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"existing_only">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"manual">;
+            releases: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "mode">;
+        budget: z.ZodObject<{
+            grantId: z.ZodString;
+            maximumMicroUsd: z.ZodNumber;
+            previewMaximumMicroUsd: z.ZodNumber;
+            qualificationMaximumMicroUsdPerCandidate: z.ZodNumber;
+            maximumSandboxSeconds: z.ZodNumber;
+        }, z.core.$strict>;
+        finish: z.ZodEnum<{
+            stop_ready: "stop_ready";
+            create_private_version: "create_private_version";
+        }>;
+        execution: z.ZodEnum<{
+            prepare: "prepare";
+            preview_only: "preview_only";
+        }>;
+        allowPartialVersion: z.ZodBoolean;
+        population: z.ZodLiteral<"development">;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
+        running: "running";
+        cancelling: "cancelling";
+        completed: "completed";
+        budget_exhausted: "budget_exhausted";
+        draft: "draft";
+        ready: "ready";
+        paused: "paused";
+        pausing: "pausing";
+        needs_attention: "needs_attention";
+        preview_ready: "preview_ready";
+        releasing: "releasing";
+        insufficient_data: "insufficient_data";
+    }>;
+    stage: z.ZodEnum<{
+        release: "release";
+        qualification: "qualification";
+        inventory: "inventory";
+        preview: "preview";
+        reconstruction: "reconstruction";
+        grader_authoring: "grader_authoring";
+    }>;
+    coverage: z.ZodNullable<z.ZodObject<{
+        conversations: z.ZodNumber;
+        importedTurns: z.ZodNumber;
+        selectedTurns: z.ZodNumber;
+        queuedSnapshots: z.ZodNullable<z.ZodNumber>;
+        failedSessions: z.ZodNullable<z.ZodNumber>;
+        skippedSessions: z.ZodNullable<z.ZodNumber>;
+        lastAdmissionAt: z.ZodNullable<z.ZodISODateTime>;
+        complete: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        sourceInventoryHash: z.ZodString;
+    }, z.core.$strict>>;
+    preview: z.ZodNullable<z.ZodObject<{
+        sampleConversations: z.ZodNumber;
+        sampleTurns: z.ZodNumber;
+        candidateCount: z.ZodNumber;
+        modelId: z.ZodString;
+        modelConfigurationHash: z.ZodString;
+        callReceiptIds: z.ZodArray<z.ZodString>;
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        classes: z.ZodArray<z.ZodObject<{
+            taskClass: z.ZodEnum<{
+                coding_change: "coding_change";
+                debugging: "debugging";
+                code_explanation: "code_explanation";
+                structured_text: "structured_text";
+                artifact_work: "artifact_work";
+            }>;
+            candidates: z.ZodNumber;
+            assessment: z.ZodEnum<{
+                executable: "executable";
+                calibrated_judge: "calibrated_judge";
+                unsupported: "unsupported";
+            }>;
+            requirements: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        exclusions: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            count: z.ZodNumber;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        estimates: z.ZodArray<z.ZodObject<{
+            stage: z.ZodEnum<{
+                release: "release";
+                qualification: "qualification";
+                inventory: "inventory";
+                preview: "preview";
+                reconstruction: "reconstruction";
+                grader_authoring: "grader_authoring";
+            }>;
+            minimumMicroUsd: z.ZodNumber;
+            maximumMicroUsd: z.ZodNumber;
+            assumptions: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    counts: z.ZodObject<{
+        scannedConversations: z.ZodNumber;
+        scannedTurns: z.ZodNumber;
+        candidates: z.ZodNumber;
+        reconstructed: z.ZodNumber;
+        qualifying: z.ZodNumber;
+        qualified: z.ZodNumber;
+        excluded: z.ZodNumber;
+        needsAttention: z.ZodNumber;
+    }, z.core.$strict>;
+    accounting: z.ZodObject<{
+        maximumMicroUsd: z.ZodNumber;
+        settledMicroUsd: z.ZodNumber;
+        heldMicroUsd: z.ZodNumber;
+        unresolvedCalls: z.ZodNumber;
+        sandboxSeconds: z.ZodNumber;
+        cleanupPending: z.ZodNumber;
+        complete: z.ZodBoolean;
+    }, z.core.$strict>;
+    publication: z.ZodNullable<z.ZodObject<{
+        datasetId: z.ZodString;
+        workspaceRevision: z.ZodNumber;
+        release: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const DatasetPreparationListSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    datasetId: z.ZodString;
+    runs: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.datasetPreparationRun.v1">;
+        id: z.ZodString;
+        operationId: z.ZodString;
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        datasetId: z.ZodString;
+        datasetRevision: z.ZodNumber;
+        revision: z.ZodNumber;
+        requestHash: z.ZodString;
+        policy: z.ZodObject<{
+            source: z.ZodObject<{
+                projectId: z.ZodString;
+                from: z.ZodISODateTime;
+                to: z.ZodISODateTime;
+                importCutoff: z.ZodISODateTime;
+                connections: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            taskClasses: z.ZodArray<z.ZodEnum<{
+                coding_change: "coding_change";
+                debugging: "debugging";
+                code_explanation: "code_explanation";
+                structured_text: "structured_text";
+                artifact_work: "artifact_work";
+            }>>;
+            limits: z.ZodObject<{
+                maximumConversations: z.ZodNumber;
+                maximumCandidates: z.ZodNumber;
+                acceptedTarget: z.ZodNumber;
+                maximumRepairsPerCandidate: z.ZodNumber;
+                maximumEvidenceBytesPerConversation: z.ZodNumber;
+            }, z.core.$strict>;
+            researcher: z.ZodObject<{
+                modelId: z.ZodString;
+                maximumOutputTokens: z.ZodNumber;
+            }, z.core.$strict>;
+            adjudicator: z.ZodObject<{
+                modelId: z.ZodString;
+                maximumOutputTokens: z.ZodNumber;
+            }, z.core.$strict>;
+            grading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"auto">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"existing_only">;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"manual">;
+                releases: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>], "mode">;
+            budget: z.ZodObject<{
+                grantId: z.ZodString;
+                maximumMicroUsd: z.ZodNumber;
+                previewMaximumMicroUsd: z.ZodNumber;
+                qualificationMaximumMicroUsdPerCandidate: z.ZodNumber;
+                maximumSandboxSeconds: z.ZodNumber;
+            }, z.core.$strict>;
+            finish: z.ZodEnum<{
+                stop_ready: "stop_ready";
+                create_private_version: "create_private_version";
+            }>;
+            execution: z.ZodEnum<{
+                prepare: "prepare";
+                preview_only: "preview_only";
+            }>;
+            allowPartialVersion: z.ZodBoolean;
+            population: z.ZodLiteral<"development">;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            running: "running";
+            cancelling: "cancelling";
+            completed: "completed";
+            budget_exhausted: "budget_exhausted";
+            draft: "draft";
+            ready: "ready";
+            paused: "paused";
+            pausing: "pausing";
+            needs_attention: "needs_attention";
+            preview_ready: "preview_ready";
+            releasing: "releasing";
+            insufficient_data: "insufficient_data";
+        }>;
+        stage: z.ZodEnum<{
+            release: "release";
+            qualification: "qualification";
+            inventory: "inventory";
+            preview: "preview";
+            reconstruction: "reconstruction";
+            grader_authoring: "grader_authoring";
+        }>;
+        coverage: z.ZodNullable<z.ZodObject<{
+            conversations: z.ZodNumber;
+            importedTurns: z.ZodNumber;
+            selectedTurns: z.ZodNumber;
+            queuedSnapshots: z.ZodNullable<z.ZodNumber>;
+            failedSessions: z.ZodNullable<z.ZodNumber>;
+            skippedSessions: z.ZodNullable<z.ZodNumber>;
+            lastAdmissionAt: z.ZodNullable<z.ZodISODateTime>;
+            complete: z.ZodBoolean;
+            reasons: z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>;
+            sourceInventoryHash: z.ZodString;
+        }, z.core.$strict>>;
+        preview: z.ZodNullable<z.ZodObject<{
+            sampleConversations: z.ZodNumber;
+            sampleTurns: z.ZodNumber;
+            candidateCount: z.ZodNumber;
+            modelId: z.ZodString;
+            modelConfigurationHash: z.ZodString;
+            callReceiptIds: z.ZodArray<z.ZodString>;
+            inputTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            classes: z.ZodArray<z.ZodObject<{
+                taskClass: z.ZodEnum<{
+                    coding_change: "coding_change";
+                    debugging: "debugging";
+                    code_explanation: "code_explanation";
+                    structured_text: "structured_text";
+                    artifact_work: "artifact_work";
+                }>;
+                candidates: z.ZodNumber;
+                assessment: z.ZodEnum<{
+                    executable: "executable";
+                    calibrated_judge: "calibrated_judge";
+                    unsupported: "unsupported";
+                }>;
+                requirements: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            exclusions: z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                count: z.ZodNumber;
+                reason: z.ZodString;
+            }, z.core.$strict>>;
+            estimates: z.ZodArray<z.ZodObject<{
+                stage: z.ZodEnum<{
+                    release: "release";
+                    qualification: "qualification";
+                    inventory: "inventory";
+                    preview: "preview";
+                    reconstruction: "reconstruction";
+                    grader_authoring: "grader_authoring";
+                }>;
+                minimumMicroUsd: z.ZodNumber;
+                maximumMicroUsd: z.ZodNumber;
+                assumptions: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        counts: z.ZodObject<{
+            scannedConversations: z.ZodNumber;
+            scannedTurns: z.ZodNumber;
+            candidates: z.ZodNumber;
+            reconstructed: z.ZodNumber;
+            qualifying: z.ZodNumber;
+            qualified: z.ZodNumber;
+            excluded: z.ZodNumber;
+            needsAttention: z.ZodNumber;
+        }, z.core.$strict>;
+        accounting: z.ZodObject<{
+            maximumMicroUsd: z.ZodNumber;
+            settledMicroUsd: z.ZodNumber;
+            heldMicroUsd: z.ZodNumber;
+            unresolvedCalls: z.ZodNumber;
+            sandboxSeconds: z.ZodNumber;
+            cleanupPending: z.ZodNumber;
+            complete: z.ZodBoolean;
+        }, z.core.$strict>;
+        publication: z.ZodNullable<z.ZodObject<{
+            datasetId: z.ZodString;
+            workspaceRevision: z.ZodNumber;
+            release: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        error: z.ZodNullable<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/** References only. Evidence bytes are read by authorized owners, never from
+ * caller-supplied spans or a policy-visible task package. */
+export declare const PreparedTaskEvidenceSpanSchema: z.ZodObject<{
+    source: z.ZodObject<{
+        id: z.ZodString;
+        snapshotHash: z.ZodString;
+        boundaryId: z.ZodString;
+        boundaryRevisionHash: z.ZodString;
+    }, z.core.$strict>;
+    startSequence: z.ZodNumber;
+    endSequence: z.ZodNumber;
+    role: z.ZodEnum<{
+        outcome: "outcome";
+        correction: "correction";
+        requirement: "requirement";
+        initial_context: "initial_context";
+        verification: "verification";
+    }>;
+}, z.core.$strict>;
+export declare const PreparedTaskProvenanceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preparedTaskProvenance.v1">;
+    candidateId: z.ZodString;
+    preparationId: z.ZodString;
+    familyKey: z.ZodString;
+    sourceSpans: z.ZodArray<z.ZodObject<{
+        source: z.ZodObject<{
+            id: z.ZodString;
+            snapshotHash: z.ZodString;
+            boundaryId: z.ZodString;
+            boundaryRevisionHash: z.ZodString;
+        }, z.core.$strict>;
+        startSequence: z.ZodNumber;
+        endSequence: z.ZodNumber;
+        role: z.ZodEnum<{
+            outcome: "outcome";
+            correction: "correction";
+            requirement: "requirement";
+            initial_context: "initial_context";
+            verification: "verification";
+        }>;
+    }, z.core.$strict>>;
+    firstAvailableAt: z.ZodISODateTime;
+    initialInputHash: z.ZodString;
+    initialEnvironmentHash: z.ZodString;
+    initialAssetsHash: z.ZodNullable<z.ZodString>;
+    sourceScopeHash: z.ZodString;
+}, z.core.$strict>;
+export declare const PreparedTaskQualificationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preparedTaskQualification.v1">;
+    id: z.ZodString;
+    candidateId: z.ZodString;
+    preparationId: z.ZodString;
+    taskHash: z.ZodString;
+    environmentHash: z.ZodString;
+    packageHash: z.ZodString;
+    graderBindings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        contentHash: z.ZodString;
+        origin: z.ZodEnum<{
+            reused: "reused";
+            adapted: "adapted";
+            authored: "authored";
+        }>;
+    }, z.core.$strict>>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodEnum<{
+            positive: "positive";
+            adversarial: "adversarial";
+            incorrect: "incorrect";
+            incomplete: "incomplete";
+            clean_reset: "clean_reset";
+        }>;
+        executionReceiptId: z.ZodString;
+        expectedPassed: z.ZodBoolean;
+        observedPassed: z.ZodNullable<z.ZodBoolean>;
+        infrastructureError: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    independentEvidenceRefs: z.ZodArray<z.ZodString>;
+    judgeCalibration: z.ZodEnum<{
+        passed: "passed";
+        pending: "pending";
+        failed: "failed";
+        not_applicable: "not_applicable";
+    }>;
+    cleanup: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+    }>;
+    passed: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const DatasetPreparationCandidateSchema: z.ZodObject<{
+    id: z.ZodString;
+    runId: z.ZodString;
+    revision: z.ZodNumber;
+    taskClass: z.ZodEnum<{
+        coding_change: "coding_change";
+        debugging: "debugging";
+        code_explanation: "code_explanation";
+        structured_text: "structured_text";
+        artifact_work: "artifact_work";
+    }>;
+    status: z.ZodEnum<{
+        authoring: "authoring";
+        excluded: "excluded";
+        needs_attention: "needs_attention";
+        qualifying: "qualifying";
+        qualified: "qualified";
+        discovered: "discovered";
+        reconstructing: "reconstructing";
+    }>;
+    objective: z.ZodString;
+    provenance: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.preparedTaskProvenance.v1">;
+        candidateId: z.ZodString;
+        preparationId: z.ZodString;
+        familyKey: z.ZodString;
+        sourceSpans: z.ZodArray<z.ZodObject<{
+            source: z.ZodObject<{
+                id: z.ZodString;
+                snapshotHash: z.ZodString;
+                boundaryId: z.ZodString;
+                boundaryRevisionHash: z.ZodString;
+            }, z.core.$strict>;
+            startSequence: z.ZodNumber;
+            endSequence: z.ZodNumber;
+            role: z.ZodEnum<{
+                outcome: "outcome";
+                correction: "correction";
+                requirement: "requirement";
+                initial_context: "initial_context";
+                verification: "verification";
+            }>;
+        }, z.core.$strict>>;
+        firstAvailableAt: z.ZodISODateTime;
+        initialInputHash: z.ZodString;
+        initialEnvironmentHash: z.ZodString;
+        initialAssetsHash: z.ZodNullable<z.ZodString>;
+        sourceScopeHash: z.ZodString;
+    }, z.core.$strict>>;
+    qualification: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.preparedTaskQualification.v1">;
+        id: z.ZodString;
+        candidateId: z.ZodString;
+        preparationId: z.ZodString;
+        taskHash: z.ZodString;
+        environmentHash: z.ZodString;
+        packageHash: z.ZodString;
+        graderBindings: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            contentHash: z.ZodString;
+            origin: z.ZodEnum<{
+                reused: "reused";
+                adapted: "adapted";
+                authored: "authored";
+            }>;
+        }, z.core.$strict>>;
+        checks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodEnum<{
+                positive: "positive";
+                adversarial: "adversarial";
+                incorrect: "incorrect";
+                incomplete: "incomplete";
+                clean_reset: "clean_reset";
+            }>;
+            executionReceiptId: z.ZodString;
+            expectedPassed: z.ZodBoolean;
+            observedPassed: z.ZodNullable<z.ZodBoolean>;
+            infrastructureError: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        independentEvidenceRefs: z.ZodArray<z.ZodString>;
+        judgeCalibration: z.ZodEnum<{
+            passed: "passed";
+            pending: "pending";
+            failed: "failed";
+            not_applicable: "not_applicable";
+        }>;
+        cleanup: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+        }>;
+        passed: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    reason: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    attempts: z.ZodNumber;
+}, z.core.$strict>;
+export type DatasetPreparationPolicy = z.infer<typeof DatasetPreparationPolicySchema>;
+export type DatasetPreparationGrant = z.infer<typeof DatasetPreparationGrantSchema>;
+export type DatasetPreparationRun = z.infer<typeof DatasetPreparationRunSchema>;
+export type DatasetPreparationCandidate = z.infer<typeof DatasetPreparationCandidateSchema>;
+export type PreparedTaskProvenance = z.infer<typeof PreparedTaskProvenanceSchema>;
+export type PreparedTaskQualification = z.infer<typeof PreparedTaskQualificationSchema>;
+//# sourceMappingURL=dataset-preparation-contracts.d.ts.map