import { z } from "zod";
/** Editor data from a server-validated package; excludes portable file bytes. */
export declare const ModelBatchReviewInspectionSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelBatchReviewInspection.v1">;
    packageHash: z.ZodString;
    definition: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.taskDefinition.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        name: z.ZodString;
        description: z.ZodString;
        instructions: z.ZodString;
        category: z.ZodEnum<{
            coding: "coding";
            custom: "custom";
            question_answering: "question_answering";
            structured: "structured";
            tool_workflow: "tool_workflow";
        }>;
        familyNamespace: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            mediaType: z.ZodString;
            schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>>;
            submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
            maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>>;
        contextRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
        rewardBinding: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        harness: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        execution: z.ZodObject<{
            policy: z.ZodObject<{
                policyVisibleFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
                privilegedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
                hiddenGraderRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
                connectedAppScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>;
            environment: z.ZodObject<{
                protocolVersion: z.ZodLiteral<"openpond.environment.v1">;
                kind: z.ZodEnum<{
                    agent: "agent";
                    custom_program: "custom_program";
                    text: "text";
                    work: "work";
                }>;
                entrypoint: z.ZodString;
                stateful: z.ZodBoolean;
                deterministicSeeds: z.ZodBoolean;
                lifecycle: z.ZodArray<z.ZodEnum<{
                    collect: "collect";
                    create: "create";
                    destroy: "destroy";
                    reset: "reset";
                    step: "step";
                }>>;
                networkPolicy: z.ZodEnum<{
                    declared_read_only: "declared_read_only";
                    declared_scoped: "declared_scoped";
                    none: "none";
                }>;
                defaultTimeoutMs: z.ZodNumber;
            }, z.core.$strict>;
            environmentRelease: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
            tools: z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                inputSchemaHash: z.ZodString;
                sideEffect: z.ZodEnum<{
                    read: "read";
                    write: "write";
                }>;
                timeoutMs: z.ZodNumber;
            }, z.core.$strict>>;
            capabilities: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                required: z.ZodBoolean;
                scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
                portability: z.ZodEnum<{
                    host_adapter: "host_adapter";
                    hosted_only: "hosted_only";
                    local_only: "local_only";
                    portable: "portable";
                }>;
            }, z.core.$strict>>;
            verifierSetRelease: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
        }, z.core.$strict>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    binding: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.rewardBinding.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        name: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        recipeRef: z.ZodOptional<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        sources: z.ZodArray<z.ZodObject<{
            graderId: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            reward: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            role: z.ZodEnum<{
                evaluation: "evaluation";
                training: "training";
            }>;
            normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"identity">;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"linear">;
                minimum: z.ZodNumber;
                maximum: z.ZodNumber;
                direction: z.ZodEnum<{
                    higher: "higher";
                    lower: "lower";
                }>;
            }, z.core.$strict>], "kind">;
            weight: z.ZodNumber;
            required: z.ZodBoolean;
            hardGate: z.ZodBoolean;
            privileged: z.ZodBoolean;
            fixtureRefs: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        aggregation: z.ZodLiteral<"weighted_mean">;
        unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    evidence: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.taskEvidence.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        source: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        submission: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.taskExample.v1">;
            sourceId: z.ZodString;
            idempotencyKey: z.ZodString;
            taskDefinition: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            exampleId: z.ZodString;
            attemptId: z.ZodString;
            occurredAt: z.ZodString;
            familyKey: z.ZodNullable<z.ZodString>;
            split: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
            observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
            expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
            evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
            assets: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>;
            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                path: z.ZodString;
                mediaType: z.ZodString;
                schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>>>;
                submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
                maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strict>>>;
            provenance: z.ZodObject<{
                sourceRecordRef: z.ZodNullable<z.ZodString>;
                mappingHash: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>;
        }, z.core.$strict>;
        supersedes: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        correctionFeedbackId: z.ZodNullable<z.ZodString>;
        receivedAt: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    decisions: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.taskAdmissionDecision.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        evidence: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        supersedes: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        actor: z.ZodObject<{
            kind: z.ZodEnum<{
                human: "human";
                qualified_policy: "qualified_policy";
            }>;
            id: z.ZodString;
            policy: z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>;
        }, z.core.$strict>;
        evidenceValidity: z.ZodEnum<{
            invalid: "invalid";
            pending: "pending";
            valid: "valid";
        }>;
        taskAdmissibility: z.ZodEnum<{
            approved: "approved";
            pending: "pending";
            rejected: "rejected";
        }>;
        observedQuality: z.ZodEnum<{
            failed: "failed";
            passed: "passed";
            unavailable: "unavailable";
            unscored: "unscored";
        }>;
        targetApproval: z.ZodEnum<{
            approved: "approved";
            not_required: "not_required";
            pending: "pending";
            rejected: "rejected";
        }>;
        approvedTarget: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
        grade: z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
            binding: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            taskHash: z.ZodString;
            taskId: z.ZodOptional<z.ZodString>;
            outputHash: z.ZodString;
            results: z.ZodArray<z.ZodObject<{
                graderId: z.ZodString;
                reward: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                    revision: z.ZodNumber;
                }, z.core.$strict>;
                role: z.ZodEnum<{
                    evaluation: "evaluation";
                    training: "training";
                }>;
                status: z.ZodEnum<{
                    failed: "failed";
                    not_applicable: "not_applicable";
                    pending: "pending";
                    scored: "scored";
                    unavailable: "unavailable";
                }>;
                rawScore: z.ZodNullable<z.ZodNumber>;
                normalizedScore: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodNullable<z.ZodBoolean>;
                evidenceHashes: z.ZodArray<z.ZodString>;
                graderEvidence: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
                    graderId: z.ZodString;
                    graderVersion: z.ZodString;
                    status: z.ZodOptional<z.ZodEnum<{
                        failed: "failed";
                        pending: "pending";
                        scored: "scored";
                        unavailable: "unavailable";
                    }>>;
                    score: z.ZodNullable<z.ZodNumber>;
                    passed: z.ZodBoolean;
                    rewardEligible: z.ZodBoolean;
                    failureClass: z.ZodNullable<z.ZodEnum<{
                        cancelled: "cancelled";
                        environment_failure: "environment_failure";
                        grader_failure: "grader_failure";
                        infrastructure_failure: "infrastructure_failure";
                        policy_failure: "policy_failure";
                        timeout: "timeout";
                    }>>;
                    feedback: z.ZodArray<z.ZodString>;
                    visibleEvidenceRefs: z.ZodArray<z.ZodString>;
                    privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
                    modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
                        schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
                        providerId: z.ZodString;
                        modelId: z.ZodString;
                        modelRevision: z.ZodNullable<z.ZodString>;
                        responseId: z.ZodNullable<z.ZodString>;
                        requestHash: z.ZodString;
                        responseHash: z.ZodString;
                        inputTokens: z.ZodNullable<z.ZodNumber>;
                        outputTokens: z.ZodNullable<z.ZodNumber>;
                        costUsd: z.ZodNullable<z.ZodNumber>;
                        transportPolicy: z.ZodOptional<z.ZodObject<{
                            schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
                            responseFormat: z.ZodLiteral<"judgment_json_schema">;
                            reasoningEffort: z.ZodEnum<{
                                high: "high";
                                low: "low";
                                max: "max";
                                medium: "medium";
                                off: "off";
                                xhigh: "xhigh";
                            }>;
                            maximumOutputTokens: z.ZodNumber;
                        }, z.core.$strict>>;
                        effectiveRequestHash: z.ZodOptional<z.ZodString>;
                        finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                        reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                    }, z.core.$strict>>;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                message: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            training: z.ZodObject<{
                status: z.ZodEnum<{
                    not_configured: "not_configured";
                    pending: "pending";
                    scored: "scored";
                    unscorable: "unscorable";
                }>;
                score: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodNullable<z.ZodBoolean>;
            }, z.core.$strict>;
            evaluation: z.ZodObject<{
                status: z.ZodEnum<{
                    not_configured: "not_configured";
                    pending: "pending";
                    scored: "scored";
                    unscorable: "unscorable";
                }>;
                score: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodNullable<z.ZodBoolean>;
            }, z.core.$strict>;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        targetGrade: z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
            binding: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            taskHash: z.ZodString;
            taskId: z.ZodOptional<z.ZodString>;
            outputHash: z.ZodString;
            results: z.ZodArray<z.ZodObject<{
                graderId: z.ZodString;
                reward: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                    revision: z.ZodNumber;
                }, z.core.$strict>;
                role: z.ZodEnum<{
                    evaluation: "evaluation";
                    training: "training";
                }>;
                status: z.ZodEnum<{
                    failed: "failed";
                    not_applicable: "not_applicable";
                    pending: "pending";
                    scored: "scored";
                    unavailable: "unavailable";
                }>;
                rawScore: z.ZodNullable<z.ZodNumber>;
                normalizedScore: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodNullable<z.ZodBoolean>;
                evidenceHashes: z.ZodArray<z.ZodString>;
                graderEvidence: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
                    graderId: z.ZodString;
                    graderVersion: z.ZodString;
                    status: z.ZodOptional<z.ZodEnum<{
                        failed: "failed";
                        pending: "pending";
                        scored: "scored";
                        unavailable: "unavailable";
                    }>>;
                    score: z.ZodNullable<z.ZodNumber>;
                    passed: z.ZodBoolean;
                    rewardEligible: z.ZodBoolean;
                    failureClass: z.ZodNullable<z.ZodEnum<{
                        cancelled: "cancelled";
                        environment_failure: "environment_failure";
                        grader_failure: "grader_failure";
                        infrastructure_failure: "infrastructure_failure";
                        policy_failure: "policy_failure";
                        timeout: "timeout";
                    }>>;
                    feedback: z.ZodArray<z.ZodString>;
                    visibleEvidenceRefs: z.ZodArray<z.ZodString>;
                    privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
                    modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
                        schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
                        providerId: z.ZodString;
                        modelId: z.ZodString;
                        modelRevision: z.ZodNullable<z.ZodString>;
                        responseId: z.ZodNullable<z.ZodString>;
                        requestHash: z.ZodString;
                        responseHash: z.ZodString;
                        inputTokens: z.ZodNullable<z.ZodNumber>;
                        outputTokens: z.ZodNullable<z.ZodNumber>;
                        costUsd: z.ZodNullable<z.ZodNumber>;
                        transportPolicy: z.ZodOptional<z.ZodObject<{
                            schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
                            responseFormat: z.ZodLiteral<"judgment_json_schema">;
                            reasoningEffort: z.ZodEnum<{
                                high: "high";
                                low: "low";
                                max: "max";
                                medium: "medium";
                                off: "off";
                                xhigh: "xhigh";
                            }>;
                            maximumOutputTokens: z.ZodNumber;
                        }, z.core.$strict>>;
                        effectiveRequestHash: z.ZodOptional<z.ZodString>;
                        finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                        reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                    }, z.core.$strict>>;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                message: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            training: z.ZodObject<{
                status: z.ZodEnum<{
                    not_configured: "not_configured";
                    pending: "pending";
                    scored: "scored";
                    unscorable: "unscorable";
                }>;
                score: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodNullable<z.ZodBoolean>;
            }, z.core.$strict>;
            evaluation: z.ZodObject<{
                status: z.ZodEnum<{
                    not_configured: "not_configured";
                    pending: "pending";
                    scored: "scored";
                    unscorable: "unscorable";
                }>;
                score: z.ZodNullable<z.ZodNumber>;
                passed: z.ZodNullable<z.ZodBoolean>;
            }, z.core.$strict>;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        note: z.ZodString;
        decidedAt: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type ModelBatchReviewInspection = z.infer<typeof ModelBatchReviewInspectionSchema>;
export declare const ModelBatchReviewRequestSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelBatchReviewRequest.v1">;
    operationId: z.ZodString;
    modelId: z.ZodString;
    expectedModelRevision: z.ZodNumber;
    tasksetRef: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    rewardBindingRef: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>;
    definition: z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        instructions: z.ZodOptional<z.ZodString>;
        inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
        requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            mediaType: z.ZodString;
            schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>>;
            submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
            maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>>;
    }, z.core.$strict>;
    examples: z.ZodArray<z.ZodObject<{
        evidence: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
        expected: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
        evaluatorContext: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
        proposedTarget: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type ModelBatchReviewRequest = z.infer<typeof ModelBatchReviewRequestSchema>;
/** These are editable evidence and unapproved proposals, never admissions. */
export declare const ModelBatchReviewReceiptSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelBatchReviewReceipt.v1">;
    operationId: z.ZodString;
    modelId: z.ZodString;
    source: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        name: z.ZodString;
        kind: z.ZodEnum<{
            benchmark: "benchmark";
            direct: "direct";
            opentelemetry: "opentelemetry";
            provider: "provider";
            work: "work";
        }>;
        taskDefinition: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        enabled: z.ZodBoolean;
        allowedSplits: z.ZodArray<z.ZodEnum<{
            frozen_eval: "frozen_eval";
            test: "test";
            train: "train";
            validation: "validation";
        }>>;
        mapping: z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.taskSourceMapping.v1">;
            exampleId: z.ZodString;
            attemptId: z.ZodString;
            occurredAt: z.ZodString;
            input: z.ZodString;
            observedOutput: z.ZodNullable<z.ZodString>;
            expected: z.ZodNullable<z.ZodString>;
            evaluatorContext: z.ZodNullable<z.ZodString>;
            familyKey: z.ZodString;
            split: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
        }, z.core.$strict>>;
        adapterVersion: z.ZodNullable<z.ZodString>;
        reviewOrigin: z.ZodOptional<z.ZodObject<{
            modelId: z.ZodString;
            packageHash: z.ZodString;
            taskset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            batch: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            rewardBinding: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
        }, z.core.$strict>>;
        capturedOrigin: z.ZodOptional<z.ZodObject<{
            receiptId: z.ZodString;
            ownerUserId: z.ZodString;
            modelId: z.ZodString;
            packageHash: z.ZodString;
            taskset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
        }, z.core.$strict>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    evidence: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.taskEvidence.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        source: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        submission: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.taskExample.v1">;
            sourceId: z.ZodString;
            idempotencyKey: z.ZodString;
            taskDefinition: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            exampleId: z.ZodString;
            attemptId: z.ZodString;
            occurredAt: z.ZodString;
            familyKey: z.ZodNullable<z.ZodString>;
            split: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
            observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
            expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
            evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
            assets: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>;
            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                path: z.ZodString;
                mediaType: z.ZodString;
                schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>>>;
                submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
                maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strict>>>;
            provenance: z.ZodObject<{
                sourceRecordRef: z.ZodNullable<z.ZodString>;
                mappingHash: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>;
        }, z.core.$strict>;
        supersedes: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        correctionFeedbackId: z.ZodNullable<z.ZodString>;
        receivedAt: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    proposals: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.taskFeedbackRecord.v1">;
        id: z.ZodString;
        submission: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.taskFeedback.v1">;
            sourceId: z.ZodString;
            idempotencyKey: z.ZodString;
            exampleId: z.ZodString;
            attemptId: z.ZodString;
            expectedEvidenceHash: z.ZodNullable<z.ZodString>;
            occurredAt: z.ZodString;
            kind: z.ZodEnum<{
                family_resolution: "family_resolution";
                ground_truth_correction: "ground_truth_correction";
                input_correction: "input_correction";
                outcome: "outcome";
                target_correction: "target_correction";
            }>;
            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
            note: z.ZodString;
        }, z.core.$strict>;
        status: z.ZodEnum<{
            applied: "applied";
            pending_example: "pending_example";
            pending_review: "pending_review";
            rejected: "rejected";
            superseded: "superseded";
        }>;
        evidence: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        createdAt: z.ZodString;
        revision: z.ZodNumber;
        submittedBy: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            role: z.ZodEnum<{
                editor: "editor";
                reviewer: "reviewer";
                source: "source";
            }>;
            sourceId: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>>>;
        review: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            actorId: z.ZodString;
            decision: z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>;
            note: z.ZodString;
            resolvedAt: z.ZodString;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type ModelBatchReviewReceipt = z.infer<typeof ModelBatchReviewReceiptSchema>;
//# sourceMappingURL=model-batch-review-contracts.d.ts.map