import { type LearningTransaction } from "@openpond/evals/learning";
import { type TasksetPackage } from "./taskset-package-contracts.js";
import { type ModelBatchReviewRequest } from "./model-batch-review-contracts.js";
export * from "./model-batch-review-contracts.js";
export { LearningDomainError as ModelBatchReviewError } from "@openpond/evals/learning";
export declare function inspectModelBatchPackage(raw: unknown): {
    schemaVersion: "openpond.modelBatchReviewInspection.v1";
    packageHash: string;
    definition: {
        schemaVersion: "openpond.taskDefinition.v1";
        id: string;
        revision: number;
        name: string;
        description: string;
        instructions: string;
        category: "coding" | "custom" | "question_answering" | "structured" | "tool_workflow";
        familyNamespace: string;
        inputSchema: Record<string, unknown>;
        outputSchema: Record<string, unknown>;
        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;
        contextRequirements?: string[] | undefined;
        rewardBinding: {
            id: string;
            contentHash: string;
            revision: number;
        };
        harness: {
            id: string;
            contentHash: string;
        } | null;
        execution: {
            policy: {
                policyVisibleFields: string[];
                privilegedFields: string[];
                hiddenGraderRefs: string[];
                connectedAppScopes: string[];
            };
            environment: {
                protocolVersion: "openpond.environment.v1";
                kind: "agent" | "custom_program" | "text" | "work";
                entrypoint: string;
                stateful: boolean;
                deterministicSeeds: boolean;
                lifecycle: ("collect" | "create" | "destroy" | "reset" | "step")[];
                networkPolicy: "declared_read_only" | "declared_scoped" | "none";
                defaultTimeoutMs: number;
            };
            environmentRelease?: {
                id: string;
                contentHash: string;
            } | undefined;
            tools: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            capabilities: {
                id: string;
                required: boolean;
                scopes: string[];
                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
            }[];
            verifierSetRelease?: {
                id: string;
                contentHash: string;
            } | undefined;
        };
        contentHash: string;
    };
    binding: {
        schemaVersion: "openpond.rewardBinding.v1";
        id: string;
        revision: number;
        name?: string | undefined;
        description?: string | undefined;
        recipeRef?: {
            id: string;
            contentHash: string;
            revision: number;
        } | undefined;
        sources: {
            graderId: string;
            taskIds?: string[] | undefined;
            reward: {
                id: string;
                contentHash: string;
                revision: number;
            };
            role: "evaluation" | "training";
            normalization: {
                kind: "identity";
            } | {
                kind: "linear";
                minimum: number;
                maximum: number;
                direction: "higher" | "lower";
            };
            weight: number;
            required: boolean;
            hardGate: boolean;
            privileged: boolean;
            fixtureRefs: {
                id: string;
                contentHash: string;
            }[];
        }[];
        aggregation: "weighted_mean";
        unscorable: "exclude_optional_require_all_required";
        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, import("zod").JSONType>;
            observedOutput: Record<string, import("zod").JSONType> | null;
            expected: Record<string, import("zod").JSONType> | null;
            evaluatorContext: Record<string, import("zod").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, import("zod").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;
    }[];
};
export declare function findModelBatchReview(transaction: LearningTransaction, raw: ModelBatchReviewRequest): Promise<{
    schemaVersion: "openpond.modelBatchReviewReceipt.v1";
    operationId: string;
    modelId: string;
    source: {
        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;
    };
    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, import("zod").JSONType>;
            observedOutput: Record<string, import("zod").JSONType> | null;
            expected: Record<string, import("zod").JSONType> | null;
            evaluatorContext: Record<string, import("zod").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;
    }[];
    proposals: {
        schemaVersion: "openpond.taskFeedbackRecord.v1";
        id: string;
        submission: {
            schemaVersion: "openpond.taskFeedback.v1";
            sourceId: string;
            idempotencyKey: string;
            exampleId: string;
            attemptId: string;
            expectedEvidenceHash: string | null;
            occurredAt: string;
            kind: "family_resolution" | "ground_truth_correction" | "input_correction" | "outcome" | "target_correction";
            value: Record<string, import("zod").JSONType>;
            note: string;
        };
        status: "applied" | "pending_example" | "pending_review" | "rejected" | "superseded";
        evidence: {
            id: string;
            contentHash: string;
            revision: number;
        } | null;
        createdAt: string;
        revision: number;
        submittedBy: {
            id: string;
            role: "editor" | "reviewer" | "source";
            sourceId: string | null;
        } | null;
        review: {
            actorId: string;
            decision: {
                id: string;
                contentHash: string;
                revision: number;
            } | null;
            note: string;
            resolvedAt: string;
        } | null;
    }[];
} | null>;
/** Run inside the host's scope/Model revision transaction after verifying the
 * selected source package. This publishes new editable evidence, never a Model
 * attachment, admission, source credential, grade, or training job. */
export declare function beginModelBatchReview(transaction: LearningTransaction, input: {
    scope: string;
    request: ModelBatchReviewRequest;
    package: TasksetPackage;
    now: string;
}): Promise<{
    schemaVersion: "openpond.modelBatchReviewReceipt.v1";
    operationId: string;
    modelId: string;
    source: {
        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;
    };
    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, import("zod").JSONType>;
            observedOutput: Record<string, import("zod").JSONType> | null;
            expected: Record<string, import("zod").JSONType> | null;
            evaluatorContext: Record<string, import("zod").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;
    }[];
    proposals: {
        schemaVersion: "openpond.taskFeedbackRecord.v1";
        id: string;
        submission: {
            schemaVersion: "openpond.taskFeedback.v1";
            sourceId: string;
            idempotencyKey: string;
            exampleId: string;
            attemptId: string;
            expectedEvidenceHash: string | null;
            occurredAt: string;
            kind: "family_resolution" | "ground_truth_correction" | "input_correction" | "outcome" | "target_correction";
            value: Record<string, import("zod").JSONType>;
            note: string;
        };
        status: "applied" | "pending_example" | "pending_review" | "rejected" | "superseded";
        evidence: {
            id: string;
            contentHash: string;
            revision: number;
        } | null;
        createdAt: string;
        revision: number;
        submittedBy: {
            id: string;
            role: "editor" | "reviewer" | "source";
            sourceId: string | null;
        } | null;
        review: {
            actorId: string;
            decision: {
                id: string;
                contentHash: string;
                revision: number;
            } | null;
            note: string;
            resolvedAt: string;
        } | null;
    }[];
}>;
//# sourceMappingURL=model-batch-review.d.ts.map