import { z } from "zod";
import { TasksetCatalogReleaseRefSchema } from "./taskset-catalog.js";
import { type TasksetPackage } from "./taskset-package-contracts.js";
/** Configuration and package selection share one hosted commit. Package-owned
 * references cannot accidentally contain a Desktop-local content hash. */
export declare const TasksetPackageModelConfigurationSchema: z.ZodObject<{
    portableProjectId: z.ZodString;
    name: z.ZodString;
    objective: z.ZodNullable<z.ZodString>;
    defaultBaseModel: z.ZodNullable<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
        modelId: z.ZodString;
        revision: z.ZodNullable<z.ZodString>;
        tokenizerRevision: z.ZodNullable<z.ZodString>;
        chatTemplateHash: z.ZodNullable<z.ZodString>;
        modelAssetId: z.ZodNullable<z.ZodString>;
        source: z.ZodEnum<{
            builtin: "builtin";
            local: "local";
            managed: "managed";
        }>;
    }, z.core.$strict>>;
    defaultDestinationId: z.ZodNullable<z.ZodString>;
    sourceRevision: z.ZodNumber;
    sourceUpdatedAt: z.ZodString;
    trainingSetup: z.ZodObject<{
        evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>>;
        profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            profileProjectId: z.ZodString;
            sourceRevision: z.ZodString;
            harnessRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
        profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            profileProjectId: z.ZodString;
            sourceRevision: z.ZodString;
            catalogHash: z.ZodString;
            definitionId: z.ZodString;
            harnessRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            tasksetRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
        harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
        baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
            modelId: z.ZodString;
            revision: z.ZodNullable<z.ZodString>;
            tokenizerRevision: z.ZodNullable<z.ZodString>;
            chatTemplateHash: z.ZodNullable<z.ZodString>;
            modelAssetId: z.ZodNullable<z.ZodString>;
            source: z.ZodEnum<{
                builtin: "builtin";
                local: "local";
                managed: "managed";
            }>;
        }, z.core.$strict>>>;
        method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
            dpo: "dpo";
            grpo: "grpo";
            opd: "opd";
            opsd: "opsd";
            ppo: "ppo";
            sdft: "sdft";
            sdpo: "sdpo";
            sft: "sft";
        }>>>;
        destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
            local: "local";
            remote: "remote";
        }>>;
        managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
            balanced: "balanced";
            economical: "economical";
            fast: "fast";
        }>>;
        managedGpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
            mode: z.ZodLiteral<"automatic">;
            objective: z.ZodEnum<{
                balanced: "balanced";
                economical: "economical";
                fast: "fast";
            }>;
            gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodLiteral<"manual">;
            availabilityId: z.ZodString;
            gpuType: z.ZodString;
            gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
        }, z.core.$strict>], "mode">>;
        continuationAdapterMode: z.ZodOptional<z.ZodEnum<{
            residual_append: "residual_append";
            sequential_merge: "sequential_merge";
            shared: "shared";
        }>>;
        managedGpuRequirement: z.ZodDefault<z.ZodEnum<{
            any: "any";
            h100_hbm3: "h100_hbm3";
        }>>;
        runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
            custom: "custom";
            small: "small";
            small_experiment: "small_experiment";
            standard: "standard";
        }>>>;
        recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodString;
            method: z.ZodEnum<{
                dpo: "dpo";
                grpo: "grpo";
                opd: "opd";
                opsd: "opsd";
                ppo: "ppo";
                sdft: "sdft";
                sdpo: "sdpo";
                sft: "sft";
            }>;
            parameterization: z.ZodEnum<{
                full: "full";
                lora: "lora";
            }>;
        }, z.core.$catchall<z.ZodUnknown>>>>;
        preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
    }, z.core.$strict>;
}, z.core.$strict>;
export declare const TasksetPackagePublicationSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.tasksetPackagePublication.v1">;
    operationId: z.ZodString;
    modelProjectId: z.ZodString;
    expectedProjectEtag: z.ZodNullable<z.ZodString>;
    name: z.ZodString;
    description: z.ZodString;
    buildIntent: z.ZodEnum<{
        demonstrations: "demonstrations";
        discovery: "discovery";
        preferences: "preferences";
        rubric: "rubric";
        verifiable_reward: "verifiable_reward";
    }>;
    methodHint: z.ZodNullable<z.ZodEnum<{
        dpo: "dpo";
        grpo: "grpo";
        ppo: "ppo";
        sft: "sft";
    }>>;
    package: 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>;
    modelConfiguration: z.ZodOptional<z.ZodObject<{
        portableProjectId: z.ZodString;
        name: z.ZodString;
        objective: z.ZodNullable<z.ZodString>;
        defaultBaseModel: z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
            modelId: z.ZodString;
            revision: z.ZodNullable<z.ZodString>;
            tokenizerRevision: z.ZodNullable<z.ZodString>;
            chatTemplateHash: z.ZodNullable<z.ZodString>;
            modelAssetId: z.ZodNullable<z.ZodString>;
            source: z.ZodEnum<{
                builtin: "builtin";
                local: "local";
                managed: "managed";
            }>;
        }, z.core.$strict>>;
        defaultDestinationId: z.ZodNullable<z.ZodString>;
        sourceRevision: z.ZodNumber;
        sourceUpdatedAt: z.ZodString;
        trainingSetup: z.ZodObject<{
            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>>;
            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                profileProjectId: z.ZodString;
                sourceRevision: z.ZodString;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>>>;
            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                profileProjectId: z.ZodString;
                sourceRevision: z.ZodString;
                catalogHash: z.ZodString;
                definitionId: z.ZodString;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                tasksetRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>>>;
            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>>;
            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
                modelId: z.ZodString;
                revision: z.ZodNullable<z.ZodString>;
                tokenizerRevision: z.ZodNullable<z.ZodString>;
                chatTemplateHash: z.ZodNullable<z.ZodString>;
                modelAssetId: z.ZodNullable<z.ZodString>;
                source: z.ZodEnum<{
                    builtin: "builtin";
                    local: "local";
                    managed: "managed";
                }>;
            }, z.core.$strict>>>;
            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                dpo: "dpo";
                grpo: "grpo";
                opd: "opd";
                opsd: "opsd";
                ppo: "ppo";
                sdft: "sdft";
                sdpo: "sdpo";
                sft: "sft";
            }>>>;
            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
                local: "local";
                remote: "remote";
            }>>;
            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
                balanced: "balanced";
                economical: "economical";
                fast: "fast";
            }>>;
            managedGpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"automatic">;
                objective: z.ZodEnum<{
                    balanced: "balanced";
                    economical: "economical";
                    fast: "fast";
                }>;
                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"manual">;
                availabilityId: z.ZodString;
                gpuType: z.ZodString;
                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
            }, z.core.$strict>], "mode">>;
            continuationAdapterMode: z.ZodOptional<z.ZodEnum<{
                residual_append: "residual_append";
                sequential_merge: "sequential_merge";
                shared: "shared";
            }>>;
            managedGpuRequirement: z.ZodDefault<z.ZodEnum<{
                any: "any";
                h100_hbm3: "h100_hbm3";
            }>>;
            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                custom: "custom";
                small: "small";
                small_experiment: "small_experiment";
                standard: "standard";
            }>>>;
            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                schemaVersion: z.ZodString;
                method: z.ZodEnum<{
                    dpo: "dpo";
                    grpo: "grpo";
                    opd: "opd";
                    opsd: "opsd";
                    ppo: "ppo";
                    sdft: "sdft";
                    sdpo: "sdpo";
                    sft: "sft";
                }>;
                parameterization: z.ZodEnum<{
                    full: "full";
                    lora: "lora";
                }>;
            }, z.core.$catchall<z.ZodUnknown>>>>;
            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        }, z.core.$strict>;
    }, z.core.$strict>>;
    evaluationPackage: z.ZodOptional<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>>;
    selection: z.ZodOptional<z.ZodEnum<{
        attach: "attach";
        select: "select";
    }>>;
}, z.core.$strict>;
export declare const TasksetPackageReceiptSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.tasksetPackageReceipt.v1">;
    teamId: z.ZodString;
    modelProjectId: z.ZodString;
    operationId: z.ZodString;
    taskset: z.ZodObject<{
        id: z.ZodString;
        revision: z.ZodNumber;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    packageHash: z.ZodString;
    hostedTasksetId: z.ZodString;
    projectEtag: z.ZodString;
    project: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        teamId: z.ZodString;
        portableProjectId: z.ZodString;
        name: z.ZodString;
        objective: z.ZodNullable<z.ZodString>;
        defaultBaseModel: z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
            modelId: z.ZodString;
            revision: z.ZodNullable<z.ZodString>;
            tokenizerRevision: z.ZodNullable<z.ZodString>;
            chatTemplateHash: z.ZodNullable<z.ZodString>;
            modelAssetId: z.ZodNullable<z.ZodString>;
            source: z.ZodEnum<{
                builtin: "builtin";
                local: "local";
                managed: "managed";
            }>;
        }, z.core.$strict>>;
        defaultDestinationId: z.ZodNullable<z.ZodString>;
        trainingSetup: z.ZodObject<{
            tasksetRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>>;
            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>>;
            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                profileProjectId: z.ZodString;
                sourceRevision: z.ZodString;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>>>;
            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                profileProjectId: z.ZodString;
                sourceRevision: z.ZodString;
                catalogHash: z.ZodString;
                definitionId: z.ZodString;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                tasksetRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>>>;
            rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>>;
            tasksetRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>>;
            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>>;
            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
                modelId: z.ZodString;
                revision: z.ZodNullable<z.ZodString>;
                tokenizerRevision: z.ZodNullable<z.ZodString>;
                chatTemplateHash: z.ZodNullable<z.ZodString>;
                modelAssetId: z.ZodNullable<z.ZodString>;
                source: z.ZodEnum<{
                    builtin: "builtin";
                    local: "local";
                    managed: "managed";
                }>;
            }, z.core.$strict>>>;
            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                dpo: "dpo";
                grpo: "grpo";
                opd: "opd";
                opsd: "opsd";
                ppo: "ppo";
                sdft: "sdft";
                sdpo: "sdpo";
                sft: "sft";
            }>>>;
            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
                local: "local";
                remote: "remote";
            }>>;
            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
                balanced: "balanced";
                economical: "economical";
                fast: "fast";
            }>>;
            managedGpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                mode: z.ZodLiteral<"automatic">;
                objective: z.ZodEnum<{
                    balanced: "balanced";
                    economical: "economical";
                    fast: "fast";
                }>;
                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodLiteral<"manual">;
                availabilityId: z.ZodString;
                gpuType: z.ZodString;
                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
            }, z.core.$strict>], "mode">>;
            continuationAdapterMode: z.ZodOptional<z.ZodEnum<{
                residual_append: "residual_append";
                sequential_merge: "sequential_merge";
                shared: "shared";
            }>>;
            managedGpuRequirement: z.ZodDefault<z.ZodEnum<{
                any: "any";
                h100_hbm3: "h100_hbm3";
            }>>;
            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                custom: "custom";
                small: "small";
                small_experiment: "small_experiment";
                standard: "standard";
            }>>>;
            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                schemaVersion: z.ZodString;
                method: z.ZodEnum<{
                    dpo: "dpo";
                    grpo: "grpo";
                    opd: "opd";
                    opsd: "opsd";
                    ppo: "ppo";
                    sdft: "sdft";
                    sdpo: "sdpo";
                    sft: "sft";
                }>;
                parameterization: z.ZodEnum<{
                    full: "full";
                    lora: "lora";
                }>;
            }, z.core.$catchall<z.ZodUnknown>>>>;
            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
        }, z.core.$strict>;
        sourceRevision: z.ZodNumber;
        sourceUpdatedAt: z.ZodString;
        revision: z.ZodNumber;
        etag: z.ZodString;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
    }, z.core.$strict>>;
    selection: z.ZodOptional<z.ZodEnum<{
        attach: "attach";
        select: "select";
    }>>;
    evaluation: z.ZodOptional<z.ZodObject<{
        taskset: z.ZodObject<{
            id: z.ZodString;
            revision: z.ZodNumber;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        packageHash: z.ZodString;
        hostedTasksetId: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const TasksetPackageReadbackSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.tasksetPackageReadback.v1">;
    teamId: z.ZodString;
    modelProjectId: z.ZodString;
    package: 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>;
}, z.core.$strict>;
export declare const TasksetReleasePackageReadbackSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.tasksetReleasePackageReadback.v1">;
    teamId: z.ZodString;
    release: z.ZodObject<{
        id: z.ZodString;
        revision: z.ZodNumber;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    package: 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>;
}, z.core.$strict>;
export type TasksetPackagePublication = z.infer<typeof TasksetPackagePublicationSchema>;
export type TasksetPackageReceipt = z.infer<typeof TasksetPackageReceiptSchema>;
export type TasksetPackageModelConfiguration = z.infer<typeof TasksetPackageModelConfigurationSchema>;
export declare class OpenPondTasksetPackageError extends Error {
    readonly status: number;
    readonly code: string;
    constructor(status: number, code: string, message: string);
}
/** Private package operations are explicitly scoped to an authorized Model.
 * Catalog inventory remains metadata-only and never calls this client itself. */
export declare class OpenPondTasksetPackageClient {
    #private;
    constructor(options: {
        baseUrl: string;
        apiKey: string;
        teamId: string;
        fetch?: typeof globalThis.fetch;
    });
    publish(input: TasksetPackagePublication, options?: {
        signal?: AbortSignal;
    }): Promise<TasksetPackageReceipt>;
    /** Owner-authorized independent Dataset transfer. Callers retain private
     * bytes at the evaluator/server boundary, never in a policy-facing picker. */
    getByRelease(reference: z.infer<typeof TasksetCatalogReleaseRefSchema>, options?: {
        signal?: AbortSignal;
        expectedPackageHash?: string;
    }): Promise<TasksetPackage>;
    get(modelProjectId: string, reference: z.infer<typeof TasksetCatalogReleaseRefSchema>, options?: {
        signal?: AbortSignal;
        expectedPackageHash?: string;
    }): Promise<TasksetPackage>;
}
//# sourceMappingURL=taskset-package-client.d.ts.map