import { z } from "zod";
import { LearningTextAssetSchema } from "@openpond/evals/learning";
import { RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
declare const OwnerSchema: z.ZodObject<{
    scopeId: z.ZodString;
    modelId: z.ZodString;
}, z.core.$strict>;
export declare const ModelTasksetDerivationSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelTasksetDerivation.v1">;
    owner: z.ZodObject<{
        scopeId: z.ZodString;
        modelId: z.ZodString;
    }, z.core.$strict>;
    root: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    parent: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
}, z.core.$strict>;
/** Immutable executable resources, independent of a catalog listing. */
export declare const ModelTasksetPackageSchema: z.ZodObject<{
    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>;
    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>>;
    executionResources: 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>;
    }, 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>;
export type ModelTasksetPackage = z.infer<typeof ModelTasksetPackageSchema>;
/** Hosts authorize the source and owner, upload immutable files, then commit
 * this result together with the model CAS and operation receipt. This pure
 * compiler neither allocates a new identity on retry nor changes a consumer. */
export declare function deriveModelTaskset(input: {
    owner: z.input<typeof OwnerSchema>;
    source: ModelTasksetPackage;
    rewardBinding: z.infer<typeof RewardBindingSchema>;
    rewards: z.infer<typeof RewardReleaseSchema>[];
    assets: z.infer<typeof LearningTextAssetSchema>[];
}): ModelTasksetPackage;
/** Internal compiler shared by validated bound and ordinary source admission.
 * The source Taskset is always the real parent, never a synthetic bound copy. */
export declare function compileModelTasksetReward(input: {
    owner: z.input<typeof OwnerSchema>;
    source: Pick<ModelTasksetPackage, "taskset" | "taskDefinition" | "executionResources" | "execution" | "instructionMode">;
    rewardBinding: z.infer<typeof RewardBindingSchema>;
    rewards: z.infer<typeof RewardReleaseSchema>[];
    assets: z.infer<typeof LearningTextAssetSchema>[];
    edits?: Pick<ModelTasksetPackage, "taskset" | "taskDefinition" | "executionResources" | "execution">;
}): ModelTasksetPackage;
export declare function validateModelTasksetPackage(value: unknown): ModelTasksetPackage;
export {};
//# sourceMappingURL=model-taskset-derivation.d.ts.map