import { z } from "zod";
export { MAX_TASKSET_PACKAGE_BYTES, TasksetPackageFileSchema, decodeTasksetPackageFile } from "./taskset-package-files.js";
export { resolveTasksetPackageExecution, createTasksetPackageExecutionFile } from "./taskset-package-execution.js";
export declare const TasksetPackageContentSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.tasksetPackage.v1">;
    taskset: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.tasksetRelease.v2">;
        id: z.ZodString;
        revision: z.ZodNumber;
        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>>;
        tasks: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            clusterKey: z.ZodString;
            split: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            policyVisibleContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            privilegedContextRef: z.ZodNullable<z.ZodString>;
            artifactRefs: z.ZodDefault<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>>>;
            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
        graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodEnum<{
                artifact: "artifact";
                content: "content";
                runtime_event: "runtime_event";
                schema: "schema";
                state: "state";
            }>;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"model_judge">;
            rubricRef: 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>;
            calibrationStatus: z.ZodEnum<{
                failed: "failed";
                passed: "passed";
                pending: "pending";
            }>;
            model: z.ZodOptional<z.ZodObject<{
                providerId: z.ZodString;
                modelId: z.ZodString;
                revision: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            temperature: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"custom_verifier">;
            runtime: z.ZodOptional<z.ZodEnum<{
                isolated_javascript: "isolated_javascript";
                sandbox_process: "sandbox_process";
            }>>;
            verifierRef: 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>;
            exportName: z.ZodOptional<z.ZodString>;
            timeoutMs: z.ZodNumber;
            networkPolicy: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"human">;
            rubricRef: 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>;
            reviewerRole: z.ZodString;
            form: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                mode: z.ZodEnum<{
                    individual: "individual";
                    pairwise: "pairwise";
                }>;
                instructions: z.ZodString;
                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"score">;
                    minimum: z.ZodNumber;
                    maximum: z.ZodNumber;
                    step: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"category">;
                    options: z.ZodArray<z.ZodString>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"boolean">;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"text">;
                    minimumLength: z.ZodOptional<z.ZodNumber>;
                    maximumLength: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"preference">;
                    requireStrength: z.ZodOptional<z.ZodBoolean>;
                    allowTie: z.ZodBoolean;
                }, z.core.$strict>], "kind">>;
            }, z.core.$strict>>;
        }, z.core.$strict>]>>;
        verifierSetRelease: z.ZodOptional<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        metrics: z.ZodOptional<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
            primaryMetric: z.ZodString;
            aggregation: z.ZodEnum<{
                custom: "custom";
                mean_score: "mean_score";
                pass_rate: "pass_rate";
                weighted_mean: "weighted_mean";
            }>;
            missingReward: z.ZodEnum<{
                exclude: "exclude";
                zero: "zero";
            }>;
            taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
            customAggregator: z.ZodNullable<z.ZodObject<{
                module: z.ZodString;
                exportName: z.ZodString;
                contentHash: z.ZodString;
                timeoutMs: z.ZodNumber;
                networkPolicy: z.ZodLiteral<"none">;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    environment: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.environmentRelease.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        contract: 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>;
        actionSchemaRef: 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>>;
        observationSchemaRef: 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>>;
        stateSchemaRef: 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>>;
        artifactCollection: z.ZodObject<{
            maxArtifacts: z.ZodNumber;
            maxTotalBytes: z.ZodNumber;
        }, z.core.$strict>;
        adapterConformanceHashes: z.ZodRecord<z.ZodString, z.ZodString>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    verifierSet: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.verifierSetRelease.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodEnum<{
                artifact: "artifact";
                content: "content";
                runtime_event: "runtime_event";
                schema: "schema";
                state: "state";
            }>;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"model_judge">;
            rubricRef: 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>;
            calibrationStatus: z.ZodEnum<{
                failed: "failed";
                passed: "passed";
                pending: "pending";
            }>;
            model: z.ZodOptional<z.ZodObject<{
                providerId: z.ZodString;
                modelId: z.ZodString;
                revision: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            temperature: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"custom_verifier">;
            runtime: z.ZodOptional<z.ZodEnum<{
                isolated_javascript: "isolated_javascript";
                sandbox_process: "sandbox_process";
            }>>;
            verifierRef: 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>;
            exportName: z.ZodOptional<z.ZodString>;
            timeoutMs: z.ZodNumber;
            networkPolicy: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"human">;
            rubricRef: 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>;
            reviewerRole: z.ZodString;
            form: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                mode: z.ZodEnum<{
                    individual: "individual";
                    pairwise: "pairwise";
                }>;
                instructions: z.ZodString;
                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"score">;
                    minimum: z.ZodNumber;
                    maximum: z.ZodNumber;
                    step: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"category">;
                    options: z.ZodArray<z.ZodString>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"boolean">;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"text">;
                    minimumLength: z.ZodOptional<z.ZodNumber>;
                    maximumLength: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"preference">;
                    requireStrength: z.ZodOptional<z.ZodBoolean>;
                    allowTie: z.ZodBoolean;
                }, z.core.$strict>], "kind">>;
            }, z.core.$strict>>;
        }, z.core.$strict>]>>;
        isolation: z.ZodObject<{
            processBoundary: z.ZodEnum<{
                container: "container";
                isolated_process: "isolated_process";
                same_process: "same_process";
            }>;
            networkPolicy: z.ZodLiteral<"none">;
            defaultTimeoutMs: z.ZodNumber;
        }, z.core.$strict>;
        calibrationReceiptRefs: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    files: z.ZodArray<z.ZodObject<{
        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>;
        base64: z.ZodString;
    }, z.core.$strict>>;
    modelResources: z.ZodOptional<z.ZodObject<{
        taskDefinition: 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>;
        rewardBinding: 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>;
        rewards: z.ZodArray<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
            id: z.ZodString;
            revision: z.ZodNumber;
            name: z.ZodString;
            description: z.ZodString;
            feedbackKey: z.ZodOptional<z.ZodString>;
            implementation: z.ZodUnion<readonly [z.ZodObject<{
                kind: z.ZodEnum<{
                    artifact: "artifact";
                    content: "content";
                    runtime_event: "runtime_event";
                    schema: "schema";
                    state: "state";
                }>;
                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"model_judge">;
                rubricRef: 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>;
                calibrationStatus: z.ZodEnum<{
                    failed: "failed";
                    passed: "passed";
                    pending: "pending";
                }>;
                model: z.ZodOptional<z.ZodObject<{
                    providerId: z.ZodString;
                    modelId: z.ZodString;
                    revision: z.ZodNullable<z.ZodString>;
                }, z.core.$strict>>;
                temperature: z.ZodOptional<z.ZodNumber>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"custom_verifier">;
                runtime: z.ZodOptional<z.ZodEnum<{
                    isolated_javascript: "isolated_javascript";
                    sandbox_process: "sandbox_process";
                }>>;
                verifierRef: 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>;
                exportName: z.ZodOptional<z.ZodString>;
                timeoutMs: z.ZodNumber;
                networkPolicy: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"human">;
                rubricRef: 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>;
                reviewerRole: z.ZodString;
                form: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                    mode: z.ZodEnum<{
                        individual: "individual";
                        pairwise: "pairwise";
                    }>;
                    instructions: z.ZodString;
                    criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"score">;
                        minimum: z.ZodNumber;
                        maximum: z.ZodNumber;
                        step: z.ZodNumber;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"category">;
                        options: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"boolean">;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"text">;
                        minimumLength: z.ZodOptional<z.ZodNumber>;
                        maximumLength: z.ZodNumber;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"preference">;
                        requireStrength: z.ZodOptional<z.ZodBoolean>;
                        allowTie: z.ZodBoolean;
                    }, z.core.$strict>], "kind">>;
                }, z.core.$strict>>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"learned_model">;
                modelVersion: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                inputContract: 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>;
            }, z.core.$strict>]>;
            rawScore: z.ZodObject<{
                minimum: z.ZodNumber;
                maximum: z.ZodNumber;
            }, z.core.$strict>;
            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>>;
            fixtureSetRef: z.ZodOptional<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>>;
            calibrationCheckRef: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, 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>>;
        execution: z.ZodOptional<z.ZodObject<{
            environment: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.environmentRelease.v1">;
                id: z.ZodString;
                revision: z.ZodNumber;
                contract: 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>;
                actionSchemaRef: 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>>;
                observationSchemaRef: 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>>;
                stateSchemaRef: 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>>;
                artifactCollection: z.ZodObject<{
                    maxArtifacts: z.ZodNumber;
                    maxTotalBytes: z.ZodNumber;
                }, z.core.$strict>;
                adapterConformanceHashes: z.ZodRecord<z.ZodString, z.ZodString>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            verifierSet: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.verifierSetRelease.v1">;
                id: z.ZodString;
                revision: z.ZodNumber;
                graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodEnum<{
                        artifact: "artifact";
                        content: "content";
                        runtime_event: "runtime_event";
                        schema: "schema";
                        state: "state";
                    }>;
                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodLiteral<"model_judge">;
                    rubricRef: 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>;
                    calibrationStatus: z.ZodEnum<{
                        failed: "failed";
                        passed: "passed";
                        pending: "pending";
                    }>;
                    model: z.ZodOptional<z.ZodObject<{
                        providerId: z.ZodString;
                        modelId: z.ZodString;
                        revision: z.ZodNullable<z.ZodString>;
                    }, z.core.$strict>>;
                    temperature: z.ZodOptional<z.ZodNumber>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodLiteral<"custom_verifier">;
                    runtime: z.ZodOptional<z.ZodEnum<{
                        isolated_javascript: "isolated_javascript";
                        sandbox_process: "sandbox_process";
                    }>>;
                    verifierRef: 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>;
                    exportName: z.ZodOptional<z.ZodString>;
                    timeoutMs: z.ZodNumber;
                    networkPolicy: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodLiteral<"human">;
                    rubricRef: 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>;
                    reviewerRole: z.ZodString;
                    form: z.ZodOptional<z.ZodObject<{
                        schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                        mode: z.ZodEnum<{
                            individual: "individual";
                            pairwise: "pairwise";
                        }>;
                        instructions: z.ZodString;
                        criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"score">;
                            minimum: z.ZodNumber;
                            maximum: z.ZodNumber;
                            step: z.ZodNumber;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"category">;
                            options: z.ZodArray<z.ZodString>;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"boolean">;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"text">;
                            minimumLength: z.ZodOptional<z.ZodNumber>;
                            maximumLength: z.ZodNumber;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"preference">;
                            requireStrength: z.ZodOptional<z.ZodBoolean>;
                            allowTie: z.ZodBoolean;
                        }, z.core.$strict>], "kind">>;
                    }, z.core.$strict>>;
                }, z.core.$strict>]>>;
                isolation: z.ZodObject<{
                    processBoundary: z.ZodEnum<{
                        container: "container";
                        isolated_process: "isolated_process";
                        same_process: "same_process";
                    }>;
                    networkPolicy: z.ZodLiteral<"none">;
                    defaultTimeoutMs: z.ZodNumber;
                }, z.core.$strict>;
                calibrationReceiptRefs: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            javascript: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.javascriptEnvironment.v1">;
                id: z.ZodString;
                revision: z.ZodNumber;
                module: 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>;
                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>>;
                maxSteps: z.ZodNumber;
                maxStateBytes: z.ZodNumber;
                maxObservationBytes: z.ZodNumber;
                operationTimeoutMs: z.ZodNumber;
                executionServices: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                    id: z.ZodString;
                    operation: z.ZodEnum<{
                        collect: "collect";
                        step: "step";
                    }>;
                    toolName: z.ZodOptional<z.ZodString>;
                    timeoutMs: z.ZodNumber;
                    kind: z.ZodLiteral<"sqlite.v1">;
                    sql: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    snapshot: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    maxRows: z.ZodNumber;
                    maxResultBytes: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    operation: z.ZodEnum<{
                        collect: "collect";
                        step: "step";
                    }>;
                    toolName: z.ZodOptional<z.ZodString>;
                    timeoutMs: z.ZodNumber;
                    kind: z.ZodLiteral<"javascript.v1">;
                    source: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    cases: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    exportName: z.ZodString;
                    maxCases: z.ZodNumber;
                    maxResultBytes: z.ZodNumber;
                }, z.core.$strict>], "kind">>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>;
        instructionMode: z.ZodOptional<z.ZodLiteral<"per_task">>;
    }, z.core.$strict>>;
    learningResources: z.ZodOptional<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>>;
}, z.core.$strict>;
export declare const TasksetPackageSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.tasksetPackage.v1">;
    taskset: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.tasksetRelease.v2">;
        id: z.ZodString;
        revision: z.ZodNumber;
        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>>;
        tasks: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            clusterKey: z.ZodString;
            split: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            policyVisibleContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            privilegedContextRef: z.ZodNullable<z.ZodString>;
            artifactRefs: z.ZodDefault<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>>>;
            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
        graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodEnum<{
                artifact: "artifact";
                content: "content";
                runtime_event: "runtime_event";
                schema: "schema";
                state: "state";
            }>;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"model_judge">;
            rubricRef: 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>;
            calibrationStatus: z.ZodEnum<{
                failed: "failed";
                passed: "passed";
                pending: "pending";
            }>;
            model: z.ZodOptional<z.ZodObject<{
                providerId: z.ZodString;
                modelId: z.ZodString;
                revision: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            temperature: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"custom_verifier">;
            runtime: z.ZodOptional<z.ZodEnum<{
                isolated_javascript: "isolated_javascript";
                sandbox_process: "sandbox_process";
            }>>;
            verifierRef: 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>;
            exportName: z.ZodOptional<z.ZodString>;
            timeoutMs: z.ZodNumber;
            networkPolicy: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"human">;
            rubricRef: 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>;
            reviewerRole: z.ZodString;
            form: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                mode: z.ZodEnum<{
                    individual: "individual";
                    pairwise: "pairwise";
                }>;
                instructions: z.ZodString;
                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"score">;
                    minimum: z.ZodNumber;
                    maximum: z.ZodNumber;
                    step: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"category">;
                    options: z.ZodArray<z.ZodString>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"boolean">;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"text">;
                    minimumLength: z.ZodOptional<z.ZodNumber>;
                    maximumLength: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"preference">;
                    requireStrength: z.ZodOptional<z.ZodBoolean>;
                    allowTie: z.ZodBoolean;
                }, z.core.$strict>], "kind">>;
            }, z.core.$strict>>;
        }, z.core.$strict>]>>;
        verifierSetRelease: z.ZodOptional<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        metrics: z.ZodOptional<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
            primaryMetric: z.ZodString;
            aggregation: z.ZodEnum<{
                custom: "custom";
                mean_score: "mean_score";
                pass_rate: "pass_rate";
                weighted_mean: "weighted_mean";
            }>;
            missingReward: z.ZodEnum<{
                exclude: "exclude";
                zero: "zero";
            }>;
            taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
            customAggregator: z.ZodNullable<z.ZodObject<{
                module: z.ZodString;
                exportName: z.ZodString;
                contentHash: z.ZodString;
                timeoutMs: z.ZodNumber;
                networkPolicy: z.ZodLiteral<"none">;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    environment: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.environmentRelease.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        contract: 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>;
        actionSchemaRef: 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>>;
        observationSchemaRef: 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>>;
        stateSchemaRef: 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>>;
        artifactCollection: z.ZodObject<{
            maxArtifacts: z.ZodNumber;
            maxTotalBytes: z.ZodNumber;
        }, z.core.$strict>;
        adapterConformanceHashes: z.ZodRecord<z.ZodString, z.ZodString>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    verifierSet: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.verifierSetRelease.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodEnum<{
                artifact: "artifact";
                content: "content";
                runtime_event: "runtime_event";
                schema: "schema";
                state: "state";
            }>;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"model_judge">;
            rubricRef: 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>;
            calibrationStatus: z.ZodEnum<{
                failed: "failed";
                passed: "passed";
                pending: "pending";
            }>;
            model: z.ZodOptional<z.ZodObject<{
                providerId: z.ZodString;
                modelId: z.ZodString;
                revision: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            temperature: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"custom_verifier">;
            runtime: z.ZodOptional<z.ZodEnum<{
                isolated_javascript: "isolated_javascript";
                sandbox_process: "sandbox_process";
            }>>;
            verifierRef: 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>;
            exportName: z.ZodOptional<z.ZodString>;
            timeoutMs: z.ZodNumber;
            networkPolicy: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"human">;
            rubricRef: 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>;
            reviewerRole: z.ZodString;
            form: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                mode: z.ZodEnum<{
                    individual: "individual";
                    pairwise: "pairwise";
                }>;
                instructions: z.ZodString;
                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"score">;
                    minimum: z.ZodNumber;
                    maximum: z.ZodNumber;
                    step: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"category">;
                    options: z.ZodArray<z.ZodString>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"boolean">;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"text">;
                    minimumLength: z.ZodOptional<z.ZodNumber>;
                    maximumLength: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"preference">;
                    requireStrength: z.ZodOptional<z.ZodBoolean>;
                    allowTie: z.ZodBoolean;
                }, z.core.$strict>], "kind">>;
            }, z.core.$strict>>;
        }, z.core.$strict>]>>;
        isolation: z.ZodObject<{
            processBoundary: z.ZodEnum<{
                container: "container";
                isolated_process: "isolated_process";
                same_process: "same_process";
            }>;
            networkPolicy: z.ZodLiteral<"none">;
            defaultTimeoutMs: z.ZodNumber;
        }, z.core.$strict>;
        calibrationReceiptRefs: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    files: z.ZodArray<z.ZodObject<{
        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>;
        base64: z.ZodString;
    }, z.core.$strict>>;
    modelResources: z.ZodOptional<z.ZodObject<{
        taskDefinition: 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>;
        rewardBinding: 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>;
        rewards: z.ZodArray<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
            id: z.ZodString;
            revision: z.ZodNumber;
            name: z.ZodString;
            description: z.ZodString;
            feedbackKey: z.ZodOptional<z.ZodString>;
            implementation: z.ZodUnion<readonly [z.ZodObject<{
                kind: z.ZodEnum<{
                    artifact: "artifact";
                    content: "content";
                    runtime_event: "runtime_event";
                    schema: "schema";
                    state: "state";
                }>;
                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"model_judge">;
                rubricRef: 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>;
                calibrationStatus: z.ZodEnum<{
                    failed: "failed";
                    passed: "passed";
                    pending: "pending";
                }>;
                model: z.ZodOptional<z.ZodObject<{
                    providerId: z.ZodString;
                    modelId: z.ZodString;
                    revision: z.ZodNullable<z.ZodString>;
                }, z.core.$strict>>;
                temperature: z.ZodOptional<z.ZodNumber>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"custom_verifier">;
                runtime: z.ZodOptional<z.ZodEnum<{
                    isolated_javascript: "isolated_javascript";
                    sandbox_process: "sandbox_process";
                }>>;
                verifierRef: 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>;
                exportName: z.ZodOptional<z.ZodString>;
                timeoutMs: z.ZodNumber;
                networkPolicy: z.ZodLiteral<"none">;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"human">;
                rubricRef: 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>;
                reviewerRole: z.ZodString;
                form: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                    mode: z.ZodEnum<{
                        individual: "individual";
                        pairwise: "pairwise";
                    }>;
                    instructions: z.ZodString;
                    criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"score">;
                        minimum: z.ZodNumber;
                        maximum: z.ZodNumber;
                        step: z.ZodNumber;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"category">;
                        options: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"boolean">;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"text">;
                        minimumLength: z.ZodOptional<z.ZodNumber>;
                        maximumLength: z.ZodNumber;
                    }, z.core.$strict>, z.ZodObject<{
                        id: z.ZodString;
                        label: z.ZodString;
                        instructions: z.ZodString;
                        required: z.ZodBoolean;
                        allowAbstain: z.ZodBoolean;
                        requireRationale: z.ZodOptional<z.ZodBoolean>;
                        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                            description: z.ZodString;
                        }, z.core.$strict>>>;
                        kind: z.ZodLiteral<"preference">;
                        requireStrength: z.ZodOptional<z.ZodBoolean>;
                        allowTie: z.ZodBoolean;
                    }, z.core.$strict>], "kind">>;
                }, z.core.$strict>>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"learned_model">;
                modelVersion: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                inputContract: 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>;
            }, z.core.$strict>]>;
            rawScore: z.ZodObject<{
                minimum: z.ZodNumber;
                maximum: z.ZodNumber;
            }, z.core.$strict>;
            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>>;
            fixtureSetRef: z.ZodOptional<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>>;
            calibrationCheckRef: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, 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>>;
        execution: z.ZodOptional<z.ZodObject<{
            environment: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.environmentRelease.v1">;
                id: z.ZodString;
                revision: z.ZodNumber;
                contract: 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>;
                actionSchemaRef: 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>>;
                observationSchemaRef: 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>>;
                stateSchemaRef: 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>>;
                artifactCollection: z.ZodObject<{
                    maxArtifacts: z.ZodNumber;
                    maxTotalBytes: z.ZodNumber;
                }, z.core.$strict>;
                adapterConformanceHashes: z.ZodRecord<z.ZodString, z.ZodString>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            verifierSet: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.verifierSetRelease.v1">;
                id: z.ZodString;
                revision: z.ZodNumber;
                graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodEnum<{
                        artifact: "artifact";
                        content: "content";
                        runtime_event: "runtime_event";
                        schema: "schema";
                        state: "state";
                    }>;
                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodLiteral<"model_judge">;
                    rubricRef: 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>;
                    calibrationStatus: z.ZodEnum<{
                        failed: "failed";
                        passed: "passed";
                        pending: "pending";
                    }>;
                    model: z.ZodOptional<z.ZodObject<{
                        providerId: z.ZodString;
                        modelId: z.ZodString;
                        revision: z.ZodNullable<z.ZodString>;
                    }, z.core.$strict>>;
                    temperature: z.ZodOptional<z.ZodNumber>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodLiteral<"custom_verifier">;
                    runtime: z.ZodOptional<z.ZodEnum<{
                        isolated_javascript: "isolated_javascript";
                        sandbox_process: "sandbox_process";
                    }>>;
                    verifierRef: 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>;
                    exportName: z.ZodOptional<z.ZodString>;
                    timeoutMs: z.ZodNumber;
                    networkPolicy: z.ZodLiteral<"none">;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    version: z.ZodString;
                    weight: z.ZodDefault<z.ZodNumber>;
                    hardGate: z.ZodDefault<z.ZodBoolean>;
                    rewardEligible: z.ZodDefault<z.ZodBoolean>;
                    privileged: z.ZodDefault<z.ZodBoolean>;
                    kind: z.ZodLiteral<"human">;
                    rubricRef: 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>;
                    reviewerRole: z.ZodString;
                    form: z.ZodOptional<z.ZodObject<{
                        schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                        mode: z.ZodEnum<{
                            individual: "individual";
                            pairwise: "pairwise";
                        }>;
                        instructions: z.ZodString;
                        criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"score">;
                            minimum: z.ZodNumber;
                            maximum: z.ZodNumber;
                            step: z.ZodNumber;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"category">;
                            options: z.ZodArray<z.ZodString>;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"boolean">;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"text">;
                            minimumLength: z.ZodOptional<z.ZodNumber>;
                            maximumLength: z.ZodNumber;
                        }, z.core.$strict>, z.ZodObject<{
                            id: z.ZodString;
                            label: z.ZodString;
                            instructions: z.ZodString;
                            required: z.ZodBoolean;
                            allowAbstain: z.ZodBoolean;
                            requireRationale: z.ZodOptional<z.ZodBoolean>;
                            anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                                value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                                description: z.ZodString;
                            }, z.core.$strict>>>;
                            kind: z.ZodLiteral<"preference">;
                            requireStrength: z.ZodOptional<z.ZodBoolean>;
                            allowTie: z.ZodBoolean;
                        }, z.core.$strict>], "kind">>;
                    }, z.core.$strict>>;
                }, z.core.$strict>]>>;
                isolation: z.ZodObject<{
                    processBoundary: z.ZodEnum<{
                        container: "container";
                        isolated_process: "isolated_process";
                        same_process: "same_process";
                    }>;
                    networkPolicy: z.ZodLiteral<"none">;
                    defaultTimeoutMs: z.ZodNumber;
                }, z.core.$strict>;
                calibrationReceiptRefs: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            javascript: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.javascriptEnvironment.v1">;
                id: z.ZodString;
                revision: z.ZodNumber;
                module: 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>;
                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>>;
                maxSteps: z.ZodNumber;
                maxStateBytes: z.ZodNumber;
                maxObservationBytes: z.ZodNumber;
                operationTimeoutMs: z.ZodNumber;
                executionServices: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                    id: z.ZodString;
                    operation: z.ZodEnum<{
                        collect: "collect";
                        step: "step";
                    }>;
                    toolName: z.ZodOptional<z.ZodString>;
                    timeoutMs: z.ZodNumber;
                    kind: z.ZodLiteral<"sqlite.v1">;
                    sql: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    snapshot: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    maxRows: z.ZodNumber;
                    maxResultBytes: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    operation: z.ZodEnum<{
                        collect: "collect";
                        step: "step";
                    }>;
                    toolName: z.ZodOptional<z.ZodString>;
                    timeoutMs: z.ZodNumber;
                    kind: z.ZodLiteral<"javascript.v1">;
                    source: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    cases: z.ZodObject<{
                        scope: z.ZodEnum<{
                            arguments: "arguments";
                            initialState: "initialState";
                            input: "input";
                            state: "state";
                        }>;
                        path: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>;
                    exportName: z.ZodString;
                    maxCases: z.ZodNumber;
                    maxResultBytes: z.ZodNumber;
                }, z.core.$strict>], "kind">>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>;
        instructionMode: z.ZodOptional<z.ZodLiteral<"per_task">>;
    }, z.core.$strict>>;
    learningResources: z.ZodOptional<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>>;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type TasksetPackage = z.infer<typeof TasksetPackageSchema>;
/** The selected binding belongs to the package's declared authoring graph. */
export declare function tasksetPackageRewardBinding(value: TasksetPackage): {
    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;
} | null;
/** Instructions follow the admitted authoring graph. An ordinary package with
 * no instructions declares an empty prompt, never its display name. */
export declare function resolveTasksetPackageInstructions(value: Pick<TasksetPackage, "taskset" | "modelResources" | "learningResources">): string;
/** Admission verifies the complete declared dependency graph, not readiness or
 * permission to execute it. Hosts separately authorize the workspace/project. */
export declare function validateTasksetPackage(value: unknown, maximumBytes?: number): TasksetPackage;
export declare function createTasksetPackage(value: z.input<typeof TasksetPackageContentSchema>, maximumBytes?: number): TasksetPackage;
/** Resolve the same public output contracts consumed by local and hosted Work. */
export declare function resolveTasksetWorkOutputs(input: unknown, taskId: string): {
    path: string;
    mediaType: string;
    maxBytes: number | null;
    submissionMode?: "structured_json" | undefined;
    structuredOutput?: import("@openpond/harness").StructuredOutputContract | undefined;
}[];
//# sourceMappingURL=taskset-package-contracts.d.ts.map