import { z } from "zod";
import type { TasksetRelease } from "@openpond/evals/tasksets";
/** Review snapshots travel with their exact batch; importing them is not a
 * new local admission or permission to train. */
export declare const TasksetPackageLearningResourcesSchema: z.ZodObject<{
    batch: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.taskBatch.v1">;
        id: z.ZodString;
        revision: z.ZodLiteral<1>;
        taskDefinition: 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>;
        purpose: z.ZodEnum<{
            evaluation: "evaluation";
            reward_training: "reward_training";
            supervised_training: "supervised_training";
        }>;
        examples: z.ZodArray<z.ZodObject<{
            evidence: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            decision: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            familyKey: z.ZodString;
            inputHash: z.ZodString;
            split: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
        }, z.core.$strict>>;
        sealedAt: z.ZodString;
        sealedBy: z.ZodString;
        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>>;
    sources: z.ZodArray<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>>;
    assets: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
        id: z.ZodString;
        revision: z.ZodLiteral<1>;
        asset: 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>;
        text: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type TasksetPackageLearningResources = z.infer<typeof TasksetPackageLearningResourcesSchema>;
export declare function learningPackageContextFiles(resources: TasksetPackageLearningResources): {
    asset: {
        id: string;
        path: string;
        contentHash: string;
        sizeBytes: number;
        mediaType: string;
        visibility: "host_private";
    };
    base64: string;
}[];
export declare function validateTasksetLearningResources(taskset: TasksetRelease, input: unknown): {
    batch: {
        schemaVersion: "openpond.taskBatch.v1";
        id: string;
        revision: 1;
        taskDefinition: {
            id: string;
            contentHash: string;
            revision: number;
        };
        rewardBinding: {
            id: string;
            contentHash: string;
            revision: number;
        };
        purpose: "evaluation" | "reward_training" | "supervised_training";
        examples: {
            evidence: {
                id: string;
                contentHash: string;
                revision: number;
            };
            decision: {
                id: string;
                contentHash: string;
                revision: number;
            };
            familyKey: string;
            inputHash: string;
            split: "frozen_eval" | "test" | "train" | "validation";
        }[];
        sealedAt: string;
        sealedBy: string;
        contentHash: string;
    };
    evidence: {
        schemaVersion: "openpond.taskEvidence.v1";
        id: string;
        revision: number;
        source: {
            id: string;
            contentHash: string;
            revision: number;
        };
        submission: {
            schemaVersion: "openpond.taskExample.v1";
            sourceId: string;
            idempotencyKey: string;
            taskDefinition: {
                id: string;
                contentHash: string;
                revision: number;
            };
            exampleId: string;
            attemptId: string;
            occurredAt: string;
            familyKey: string | null;
            split: "frozen_eval" | "test" | "train" | "validation";
            input: Record<string, z.JSONType>;
            observedOutput: Record<string, z.JSONType> | null;
            expected: Record<string, z.JSONType> | null;
            evaluatorContext: Record<string, z.JSONType> | null;
            assets: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            requiredOutputs?: {
                path: string;
                mediaType: string;
                schemaRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                } | null;
                submissionMode?: "structured_json" | undefined;
                maxBytes: number | null;
                metadata: Record<string, unknown>;
            }[] | undefined;
            provenance: {
                sourceRecordRef: string | null;
                mappingHash: string | null;
            };
        };
        supersedes: {
            id: string;
            contentHash: string;
            revision: number;
        } | null;
        correctionFeedbackId: string | null;
        receivedAt: string;
        contentHash: string;
    }[];
    decisions: {
        schemaVersion: "openpond.taskAdmissionDecision.v1";
        id: string;
        revision: number;
        evidence: {
            id: string;
            contentHash: string;
            revision: number;
        };
        supersedes: {
            id: string;
            contentHash: string;
            revision: number;
        } | null;
        actor: {
            kind: "human" | "qualified_policy";
            id: string;
            policy: {
                id: string;
                contentHash: string;
                revision: number;
            } | null;
        };
        evidenceValidity: "invalid" | "pending" | "valid";
        taskAdmissibility: "approved" | "pending" | "rejected";
        observedQuality: "failed" | "passed" | "unavailable" | "unscored";
        targetApproval: "approved" | "not_required" | "pending" | "rejected";
        approvedTarget: Record<string, z.JSONType> | null;
        grade: {
            schemaVersion: "openpond.rewardComposition.v1";
            binding: {
                id: string;
                contentHash: string;
                revision: number;
            };
            taskHash: string;
            taskId?: string | undefined;
            outputHash: string;
            results: {
                graderId: string;
                reward: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                role: "evaluation" | "training";
                status: "failed" | "not_applicable" | "pending" | "scored" | "unavailable";
                rawScore: number | null;
                normalizedScore: number | null;
                passed: boolean | null;
                evidenceHashes: string[];
                graderEvidence?: {
                    schemaVersion: "openpond.graderEvidence.v1";
                    graderId: string;
                    graderVersion: string;
                    status?: "failed" | "pending" | "scored" | "unavailable" | undefined;
                    score: number | null;
                    passed: boolean;
                    rewardEligible: boolean;
                    failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
                    feedback: string[];
                    visibleEvidenceRefs: string[];
                    privilegedEvidenceRefs: string[];
                    modelJudgeReceipt?: {
                        schemaVersion: "openpond.modelJudgeReceipt.v1";
                        providerId: string;
                        modelId: string;
                        modelRevision: string | null;
                        responseId: string | null;
                        requestHash: string;
                        responseHash: string;
                        inputTokens: number | null;
                        outputTokens: number | null;
                        costUsd: number | null;
                        transportPolicy?: {
                            schemaVersion: "openpond.modelJudgeTransportPolicy.v1";
                            responseFormat: "judgment_json_schema";
                            reasoningEffort: "high" | "low" | "max" | "medium" | "off" | "xhigh";
                            maximumOutputTokens: number;
                        } | undefined;
                        effectiveRequestHash?: string | undefined;
                        finishReason?: string | null | undefined;
                        reasoningTokens?: number | null | undefined;
                    } | undefined;
                    contentHash: string;
                } | undefined;
                message: string | null;
            }[];
            training: {
                status: "not_configured" | "pending" | "scored" | "unscorable";
                score: number | null;
                passed: boolean | null;
            };
            evaluation: {
                status: "not_configured" | "pending" | "scored" | "unscorable";
                score: number | null;
                passed: boolean | null;
            };
            contentHash: string;
        } | null;
        targetGrade: {
            schemaVersion: "openpond.rewardComposition.v1";
            binding: {
                id: string;
                contentHash: string;
                revision: number;
            };
            taskHash: string;
            taskId?: string | undefined;
            outputHash: string;
            results: {
                graderId: string;
                reward: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                role: "evaluation" | "training";
                status: "failed" | "not_applicable" | "pending" | "scored" | "unavailable";
                rawScore: number | null;
                normalizedScore: number | null;
                passed: boolean | null;
                evidenceHashes: string[];
                graderEvidence?: {
                    schemaVersion: "openpond.graderEvidence.v1";
                    graderId: string;
                    graderVersion: string;
                    status?: "failed" | "pending" | "scored" | "unavailable" | undefined;
                    score: number | null;
                    passed: boolean;
                    rewardEligible: boolean;
                    failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
                    feedback: string[];
                    visibleEvidenceRefs: string[];
                    privilegedEvidenceRefs: string[];
                    modelJudgeReceipt?: {
                        schemaVersion: "openpond.modelJudgeReceipt.v1";
                        providerId: string;
                        modelId: string;
                        modelRevision: string | null;
                        responseId: string | null;
                        requestHash: string;
                        responseHash: string;
                        inputTokens: number | null;
                        outputTokens: number | null;
                        costUsd: number | null;
                        transportPolicy?: {
                            schemaVersion: "openpond.modelJudgeTransportPolicy.v1";
                            responseFormat: "judgment_json_schema";
                            reasoningEffort: "high" | "low" | "max" | "medium" | "off" | "xhigh";
                            maximumOutputTokens: number;
                        } | undefined;
                        effectiveRequestHash?: string | undefined;
                        finishReason?: string | null | undefined;
                        reasoningTokens?: number | null | undefined;
                    } | undefined;
                    contentHash: string;
                } | undefined;
                message: string | null;
            }[];
            training: {
                status: "not_configured" | "pending" | "scored" | "unscorable";
                score: number | null;
                passed: boolean | null;
            };
            evaluation: {
                status: "not_configured" | "pending" | "scored" | "unscorable";
                score: number | null;
                passed: boolean | null;
            };
            contentHash: string;
        } | null;
        note: string;
        decidedAt: string;
        contentHash: string;
    }[];
    sources: {
        schemaVersion: "openpond.learningSource.v1";
        id: string;
        revision: number;
        name: string;
        kind: "benchmark" | "direct" | "opentelemetry" | "provider" | "work";
        taskDefinition: {
            id: string;
            contentHash: string;
            revision: number;
        };
        enabled: boolean;
        allowedSplits: ("frozen_eval" | "test" | "train" | "validation")[];
        mapping: {
            schemaVersion: "openpond.taskSourceMapping.v1";
            exampleId: string;
            attemptId: string;
            occurredAt: string;
            input: string;
            observedOutput: string | null;
            expected: string | null;
            evaluatorContext: string | null;
            familyKey: string;
            split: "frozen_eval" | "test" | "train" | "validation";
        } | null;
        adapterVersion: string | null;
        reviewOrigin?: {
            modelId: string;
            packageHash: string;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            batch: {
                id: string;
                contentHash: string;
                revision: number;
            };
            rewardBinding: {
                id: string;
                contentHash: string;
                revision: number;
            };
        } | undefined;
        capturedOrigin?: {
            receiptId: string;
            ownerUserId: string;
            modelId: string;
            packageHash: string;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
        } | undefined;
        contentHash: string;
    }[];
    assets: {
        schemaVersion: "openpond.learningTextAsset.v1";
        id: string;
        revision: 1;
        asset: {
            id: string;
            path: string;
            contentHash: string;
            sizeBytes: number;
            mediaType: string;
            visibility: "host_private" | "policy" | "verifier";
        };
        text: string;
        contentHash: string;
    }[];
};
//# sourceMappingURL=taskset-package-learning.d.ts.map