import { z } from "zod";
export { ModelStarterExecutionSchema, ModelStarterEnvironmentAttemptSchema, verifyModelStarterEnvironmentAttempt, ModelStarterToolFixtureScriptSchema, createModelStarterExecutionAsset, modelStarterExecutionAssetId, resolveModelStarterExecutionAsset, type ModelStarterExecution, type ModelStarterExecutionContext } from "./model-starter-execution.js";
export { NativeHarnessExperimentAttemptSchema, verifyNativeHarnessExperimentAttempt, type NativeHarnessExperimentAttempt } from "./model-starter-execution.js";
export { ModelTasksetDerivationSchema, ModelTasksetPackageSchema, deriveModelTaskset, validateModelTasksetPackage, type ModelTasksetPackage } from "./model-taskset-derivation.js";
export { ModelTasksetExecutionResourcesSchema, createModelTasksetExecutionResourcesAsset, modelTasksetExecutionResourcesAssetId, resolveModelTasksetExecutionResourcesAsset } from "./model-taskset-resources.js";
export { prepareModelTrainingDefaults, createModelTrainingRecipeDefaults, rebindModelTrainingRecipe } from "./model-training-defaults.js";
/** Catalog records contain references and previews, never the private task rows. */
export declare const ModelStarterContentSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelStarter.v1">;
    id: z.ZodString;
    revision: z.ZodNumber;
    name: z.ZodString;
    description: z.ZodString;
    category: z.ZodEnum<{
        classification: "classification";
        coding: "coding";
        extraction: "extraction";
        knowledge: "knowledge";
        operations: "operations";
        support: "support";
        writing: "writing";
    }>;
    taskset: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    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>;
    rewards: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>;
    assets: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>;
    previewTaskIds: z.ZodArray<z.ZodString>;
    startingModel: 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>;
    supportedMethods: z.ZodArray<z.ZodEnum<{
        dpo: "dpo";
        grpo: "grpo";
        opd: "opd";
        opsd: "opsd";
        ppo: "ppo";
        sdft: "sdft";
        sdpo: "sdpo";
        sft: "sft";
    }>>;
    defaultMethod: z.ZodEnum<{
        dpo: "dpo";
        grpo: "grpo";
        opd: "opd";
        opsd: "opsd";
        ppo: "ppo";
        sdft: "sdft";
        sdpo: "sdpo";
        sft: "sft";
    }>;
    provenance: z.ZodObject<{
        author: z.ZodString;
        license: z.ZodString;
        sourceDescription: z.ZodString;
    }, z.core.$strict>;
    evidence: z.ZodObject<{
        verifierFixtures: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        baseline: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        training: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        evaluation: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
    }, z.core.$strict>;
}, z.core.$strict>;
export declare const ModelStarterSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelStarter.v1">;
    id: z.ZodString;
    revision: z.ZodNumber;
    name: z.ZodString;
    description: z.ZodString;
    category: z.ZodEnum<{
        classification: "classification";
        coding: "coding";
        extraction: "extraction";
        knowledge: "knowledge";
        operations: "operations";
        support: "support";
        writing: "writing";
    }>;
    taskset: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    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>;
    rewards: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>;
    assets: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>;
    previewTaskIds: z.ZodArray<z.ZodString>;
    startingModel: 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>;
    supportedMethods: z.ZodArray<z.ZodEnum<{
        dpo: "dpo";
        grpo: "grpo";
        opd: "opd";
        opsd: "opsd";
        ppo: "ppo";
        sdft: "sdft";
        sdpo: "sdpo";
        sft: "sft";
    }>>;
    defaultMethod: z.ZodEnum<{
        dpo: "dpo";
        grpo: "grpo";
        opd: "opd";
        opsd: "opsd";
        ppo: "ppo";
        sdft: "sdft";
        sdpo: "sdpo";
        sft: "sft";
    }>;
    provenance: z.ZodObject<{
        author: z.ZodString;
        license: z.ZodString;
        sourceDescription: z.ZodString;
    }, z.core.$strict>;
    evidence: z.ZodObject<{
        verifierFixtures: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        baseline: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        training: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        evaluation: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type ModelStarter = z.infer<typeof ModelStarterSchema>;
/** A resolved small package, obtained separately from catalog discovery.
 * Large Tasksets remain manifest/shard resources; they are not list payloads. */
export declare const ResolvedModelStarterSchema: z.ZodObject<{
    starter: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.modelStarter.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        name: z.ZodString;
        description: z.ZodString;
        category: z.ZodEnum<{
            classification: "classification";
            coding: "coding";
            extraction: "extraction";
            knowledge: "knowledge";
            operations: "operations";
            support: "support";
            writing: "writing";
        }>;
        taskset: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        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>;
        rewards: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        assets: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        previewTaskIds: z.ZodArray<z.ZodString>;
        startingModel: 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>;
        supportedMethods: z.ZodArray<z.ZodEnum<{
            dpo: "dpo";
            grpo: "grpo";
            opd: "opd";
            opsd: "opsd";
            ppo: "ppo";
            sdft: "sdft";
            sdpo: "sdpo";
            sft: "sft";
        }>>;
        defaultMethod: z.ZodEnum<{
            dpo: "dpo";
            grpo: "grpo";
            opd: "opd";
            opsd: "opsd";
            ppo: "ppo";
            sdft: "sdft";
            sdpo: "sdpo";
            sft: "sft";
        }>;
        provenance: z.ZodObject<{
            author: z.ZodString;
            license: z.ZodString;
            sourceDescription: z.ZodString;
        }, z.core.$strict>;
        evidence: z.ZodObject<{
            verifierFixtures: z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>;
            baseline: z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>;
            training: z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>;
            evaluation: z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>>;
        }, z.core.$strict>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    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>>;
    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>>;
}, z.core.$strict>;
export type ResolvedModelStarter = z.infer<typeof ResolvedModelStarterSchema>;
/** Publisher attestation for original synthetic contact data, never a caller
 * override for arbitrary imports or for a failed secret scan. */
export declare const ModelStarterPrivacyReviewSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.modelStarterPrivacyReview.v1">;
    disposition: z.ZodLiteral<"synthetic_only">;
    reviewedBy: z.ZodString;
    reviewedAt: z.ZodISODateTime;
    reviewedContentHash: z.ZodString;
    note: z.ZodString;
}, z.core.$strict>;
export declare function modelStarterPrivacyContentHash(value: ResolvedModelStarter): string;
/** Final creation intent. The server resolves package bytes from its catalog;
 * callers cannot supply executable resources or qualification receipts here. */
export declare const ModelStarterCreationIntentSchema: z.ZodObject<{
    profileId: z.ZodString;
    modelId: z.ZodString;
    name: z.ZodString;
    starter: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    startingModel: 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.ZodEnum<{
        dpo: "dpo";
        grpo: "grpo";
        opd: "opd";
        opsd: "opsd";
        ppo: "ppo";
        sdft: "sdft";
        sdpo: "sdpo";
        sft: "sft";
    }>;
    rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>>;
    recipe: z.ZodOptional<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>>>>;
    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";
    }>>;
    learning: z.ZodOptional<z.ZodObject<{
        localTime: z.ZodString;
        timeZone: z.ZodString;
        mode: z.ZodEnum<{
            approved_count: "approved_count";
            nightly: "nightly";
        }>;
        minimumTasks: z.ZodNumber;
        maximumSpendUsd: z.ZodNumber;
        maximumDailySpendUsd: z.ZodNumber;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const ModelStarterCreationRequestSchema: z.ZodObject<{
    profileId: z.ZodString;
    modelId: z.ZodString;
    name: z.ZodString;
    starter: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    startingModel: 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.ZodEnum<{
        dpo: "dpo";
        grpo: "grpo";
        opd: "opd";
        opsd: "opsd";
        ppo: "ppo";
        sdft: "sdft";
        sdpo: "sdpo";
        sft: "sft";
    }>;
    rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>>;
    recipe: z.ZodOptional<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>>>>;
    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";
    }>>;
    learning: z.ZodOptional<z.ZodObject<{
        localTime: z.ZodString;
        timeZone: z.ZodString;
        mode: z.ZodEnum<{
            approved_count: "approved_count";
            nightly: "nightly";
        }>;
        minimumTasks: z.ZodNumber;
        maximumSpendUsd: z.ZodNumber;
        maximumDailySpendUsd: z.ZodNumber;
    }, z.core.$strict>>;
    schemaVersion: z.ZodLiteral<"openpond.modelStarterCreation.v1">;
    operationId: z.ZodString;
}, z.core.$strict>;
export type ModelStarterCreationRequest = z.infer<typeof ModelStarterCreationRequestSchema>;
export declare function parseModelStarterCreationRequest(value: unknown): ModelStarterCreationRequest;
/** Prepare once on final confirmation and retain across uncertain transport
 * outcomes. The server must bind operationId to the complete original intent
 * and atomically commit resources, model configuration and the retry receipt. */
export declare function createModelStarterCreationRequest(value: z.input<typeof ModelStarterCreationIntentSchema>): Promise<ModelStarterCreationRequest>;
/** Scope authorization belongs to the API. This validates the final intent
 * against the exact trusted package before any user resources are written. */
export declare function validateModelStarterCreation(value: unknown, packageValue: unknown): {
    request: {
        profileId: string;
        modelId: string;
        name: string;
        starter: {
            id: string;
            contentHash: string;
            revision: number;
        };
        startingModel: {
            schemaVersion: "openpond.baseModelPreference.v1";
            modelId: string;
            revision: string | null;
            tokenizerRevision: string | null;
            chatTemplateHash: string | null;
            modelAssetId: string | null;
            source: "builtin" | "local" | "managed";
        };
        method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
        rewardBindingRef?: {
            id: string;
            contentHash: string;
            revision: number;
        } | null | undefined;
        recipe?: {
            [x: string]: unknown;
            schemaVersion: string;
            method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
            parameterization: "full" | "lora";
        } | null | undefined;
        managedGpuSelection?: {
            mode: "automatic";
            objective: "balanced" | "economical" | "fast";
            gpuCount?: 1 | 2 | undefined;
        } | {
            mode: "manual";
            availabilityId: string;
            gpuType: string;
            gpuCount?: 1 | 2 | undefined;
        } | undefined;
        continuationAdapterMode?: "residual_append" | "sequential_merge" | "shared" | undefined;
        learning?: {
            localTime: string;
            timeZone: string;
            mode: "approved_count" | "nightly";
            minimumTasks: number;
            maximumSpendUsd: number;
            maximumDailySpendUsd: number;
        } | undefined;
        schemaVersion: "openpond.modelStarterCreation.v1";
        operationId: string;
    };
    resolved: {
        starter: {
            schemaVersion: "openpond.modelStarter.v1";
            id: string;
            revision: number;
            name: string;
            description: string;
            category: "classification" | "coding" | "extraction" | "knowledge" | "operations" | "support" | "writing";
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            taskDefinition: {
                id: string;
                contentHash: string;
                revision: number;
            };
            rewardBinding: {
                id: string;
                contentHash: string;
                revision: number;
            };
            rewards: {
                id: string;
                contentHash: string;
                revision: number;
            }[];
            assets: {
                id: string;
                contentHash: string;
                revision: number;
            }[];
            previewTaskIds: string[];
            startingModel: {
                schemaVersion: "openpond.baseModelPreference.v1";
                modelId: string;
                revision: string | null;
                tokenizerRevision: string | null;
                chatTemplateHash: string | null;
                modelAssetId: string | null;
                source: "builtin" | "local" | "managed";
            };
            supportedMethods: ("dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft")[];
            defaultMethod: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
            provenance: {
                author: string;
                license: string;
                sourceDescription: string;
            };
            evidence: {
                verifierFixtures: {
                    id: string;
                    contentHash: string;
                    revision: number;
                } | null;
                baseline: {
                    id: string;
                    contentHash: string;
                    revision: number;
                } | null;
                training: {
                    id: string;
                    contentHash: string;
                    revision: number;
                } | null;
                evaluation: {
                    id: string;
                    contentHash: string;
                    revision: number;
                } | null;
            };
            contentHash: string;
        };
        taskset: {
            schemaVersion: "openpond.tasksetRelease.v2";
            id: string;
            revision: number;
            policy: {
                policyVisibleFields: string[];
                privilegedFields: string[];
                hiddenGraderRefs: string[];
                connectedAppScopes: string[];
            };
            environment: {
                protocolVersion: "openpond.environment.v1";
                kind: "agent" | "custom_program" | "text" | "work";
                entrypoint: string;
                stateful: boolean;
                deterministicSeeds: boolean;
                lifecycle: ("collect" | "create" | "destroy" | "reset" | "step")[];
                networkPolicy: "declared_read_only" | "declared_scoped" | "none";
                defaultTimeoutMs: number;
            };
            environmentRelease?: {
                id: string;
                contentHash: string;
            } | undefined;
            tools: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            capabilities: {
                id: string;
                required: boolean;
                scopes: string[];
                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
            }[];
            tasks: {
                id: string;
                clusterKey: string;
                split: "frozen_eval" | "test" | "train" | "validation";
                input: Record<string, unknown>;
                expectedOutput: Record<string, unknown> | null;
                policyVisibleContext: Record<string, unknown>;
                privilegedContextRef: string | null;
                artifactRefs: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                }[];
                requiredOutputs?: {
                    path: string;
                    mediaType: string;
                    schemaRef: {
                        id: string;
                        path: string;
                        contentHash: string;
                        sizeBytes: number;
                        mediaType: string;
                        visibility: "host_private" | "policy" | "verifier";
                    } | null;
                    submissionMode?: "structured_json" | undefined;
                    maxBytes: number | null;
                    metadata: Record<string, unknown>;
                }[] | undefined;
                tags: string[];
            }[];
            graders: ({
                id: string;
                taskIds?: string[] | undefined;
                version: string;
                weight: number;
                hardGate: boolean;
                rewardEligible: boolean;
                privileged: boolean;
                kind: "artifact" | "content" | "runtime_event" | "schema" | "state";
                config: Record<string, unknown>;
            } | {
                id: string;
                taskIds?: string[] | undefined;
                version: string;
                weight: number;
                hardGate: boolean;
                rewardEligible: boolean;
                privileged: boolean;
                kind: "model_judge";
                rubricRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
                calibrationStatus: "failed" | "passed" | "pending";
                model?: {
                    providerId: string;
                    modelId: string;
                    revision: string | null;
                } | undefined;
                temperature?: number | undefined;
            } | {
                id: string;
                taskIds?: string[] | undefined;
                version: string;
                weight: number;
                hardGate: boolean;
                rewardEligible: boolean;
                privileged: boolean;
                kind: "custom_verifier";
                runtime?: "isolated_javascript" | "sandbox_process" | undefined;
                verifierRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
                exportName?: string | undefined;
                timeoutMs: number;
                networkPolicy: "none";
            } | {
                id: string;
                taskIds?: string[] | undefined;
                version: string;
                weight: number;
                hardGate: boolean;
                rewardEligible: boolean;
                privileged: boolean;
                kind: "human";
                rubricRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
                reviewerRole: string;
                form?: {
                    schemaVersion: "openpond.humanForm.v1";
                    mode: "individual" | "pairwise";
                    instructions: string;
                    criteria: ({
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "score";
                        minimum: number;
                        maximum: number;
                        step: number;
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "category";
                        options: string[];
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "boolean";
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "text";
                        minimumLength?: number | undefined;
                        maximumLength: number;
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "preference";
                        requireStrength?: boolean | undefined;
                        allowTie: boolean;
                    })[];
                } | undefined;
            })[];
            verifierSetRelease?: {
                id: string;
                contentHash: string;
            } | undefined;
            metrics?: {
                schemaVersion: "openpond.tasksetMetricPolicy.v1";
                primaryMetric: string;
                aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                missingReward: "exclude" | "zero";
                taskWeights?: Record<string, number> | undefined;
                customAggregator: {
                    module: string;
                    exportName: string;
                    contentHash: string;
                    timeoutMs: number;
                    networkPolicy: "none";
                } | null;
            } | undefined;
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        taskDefinition: {
            schemaVersion: "openpond.taskDefinition.v1";
            id: string;
            revision: number;
            name: string;
            description: string;
            instructions: string;
            category: "coding" | "custom" | "question_answering" | "structured" | "tool_workflow";
            familyNamespace: string;
            inputSchema: Record<string, unknown>;
            outputSchema: Record<string, unknown>;
            requiredOutputs?: {
                path: string;
                mediaType: string;
                schemaRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                } | null;
                submissionMode?: "structured_json" | undefined;
                maxBytes: number | null;
                metadata: Record<string, unknown>;
            }[] | undefined;
            contextRequirements?: string[] | undefined;
            rewardBinding: {
                id: string;
                contentHash: string;
                revision: number;
            };
            harness: {
                id: string;
                contentHash: string;
            } | null;
            execution: {
                policy: {
                    policyVisibleFields: string[];
                    privilegedFields: string[];
                    hiddenGraderRefs: string[];
                    connectedAppScopes: string[];
                };
                environment: {
                    protocolVersion: "openpond.environment.v1";
                    kind: "agent" | "custom_program" | "text" | "work";
                    entrypoint: string;
                    stateful: boolean;
                    deterministicSeeds: boolean;
                    lifecycle: ("collect" | "create" | "destroy" | "reset" | "step")[];
                    networkPolicy: "declared_read_only" | "declared_scoped" | "none";
                    defaultTimeoutMs: number;
                };
                environmentRelease?: {
                    id: string;
                    contentHash: string;
                } | undefined;
                tools: {
                    name: string;
                    description: string;
                    inputSchema: Record<string, unknown>;
                    inputSchemaHash: string;
                    sideEffect: "read" | "write";
                    timeoutMs: number;
                }[];
                capabilities: {
                    id: string;
                    required: boolean;
                    scopes: string[];
                    portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
                }[];
                verifierSetRelease?: {
                    id: string;
                    contentHash: string;
                } | undefined;
            };
            contentHash: string;
        };
        rewardBinding: {
            schemaVersion: "openpond.rewardBinding.v1";
            id: string;
            revision: number;
            name?: string | undefined;
            description?: string | undefined;
            recipeRef?: {
                id: string;
                contentHash: string;
                revision: number;
            } | undefined;
            sources: {
                graderId: string;
                taskIds?: string[] | undefined;
                reward: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                role: "evaluation" | "training";
                normalization: {
                    kind: "identity";
                } | {
                    kind: "linear";
                    minimum: number;
                    maximum: number;
                    direction: "higher" | "lower";
                };
                weight: number;
                required: boolean;
                hardGate: boolean;
                privileged: boolean;
                fixtureRefs: {
                    id: string;
                    contentHash: string;
                }[];
            }[];
            aggregation: "weighted_mean";
            unscorable: "exclude_optional_require_all_required";
            contentHash: string;
        };
        rewards: {
            schemaVersion: "openpond.rewardRelease.v1";
            id: string;
            revision: number;
            name: string;
            description: string;
            feedbackKey?: string | undefined;
            implementation: {
                kind: "artifact" | "content" | "runtime_event" | "schema" | "state";
                config: Record<string, unknown>;
            } | {
                kind: "model_judge";
                rubricRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
                calibrationStatus: "failed" | "passed" | "pending";
                model?: {
                    providerId: string;
                    modelId: string;
                    revision: string | null;
                } | undefined;
                temperature?: number | undefined;
            } | {
                kind: "custom_verifier";
                runtime?: "isolated_javascript" | "sandbox_process" | undefined;
                verifierRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
                exportName?: string | undefined;
                timeoutMs: number;
                networkPolicy: "none";
            } | {
                kind: "human";
                rubricRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
                reviewerRole: string;
                form?: {
                    schemaVersion: "openpond.humanForm.v1";
                    mode: "individual" | "pairwise";
                    instructions: string;
                    criteria: ({
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "score";
                        minimum: number;
                        maximum: number;
                        step: number;
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "category";
                        options: string[];
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "boolean";
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "text";
                        minimumLength?: number | undefined;
                        maximumLength: number;
                    } | {
                        id: string;
                        label: string;
                        instructions: string;
                        required: boolean;
                        allowAbstain: boolean;
                        requireRationale?: boolean | undefined;
                        anchors?: {
                            value: string | number | boolean;
                            description: string;
                        }[] | undefined;
                        kind: "preference";
                        requireStrength?: boolean | undefined;
                        allowTie: boolean;
                    })[];
                } | undefined;
            } | {
                kind: "learned_model";
                modelVersion: {
                    id: string;
                    contentHash: string;
                };
                inputContract: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
            };
            rawScore: {
                minimum: number;
                maximum: number;
            };
            assets: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            fixtureSetRef?: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            } | undefined;
            calibrationCheckRef?: {
                id: string;
                contentHash: string;
                revision: number;
            } | undefined;
            contentHash: string;
        }[];
        assets: {
            schemaVersion: "openpond.learningTextAsset.v1";
            id: string;
            revision: 1;
            asset: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            };
            text: string;
            contentHash: string;
        }[];
        execution?: {
            environment: {
                schemaVersion: "openpond.environmentRelease.v1";
                id: string;
                revision: number;
                contract: {
                    protocolVersion: "openpond.environment.v1";
                    kind: "agent" | "custom_program" | "text" | "work";
                    entrypoint: string;
                    stateful: boolean;
                    deterministicSeeds: boolean;
                    lifecycle: ("collect" | "create" | "destroy" | "reset" | "step")[];
                    networkPolicy: "declared_read_only" | "declared_scoped" | "none";
                    defaultTimeoutMs: number;
                };
                actionSchemaRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                } | null;
                observationSchemaRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                } | null;
                stateSchemaRef: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                } | null;
                artifactCollection: {
                    maxArtifacts: number;
                    maxTotalBytes: number;
                };
                adapterConformanceHashes: Record<string, string>;
                metadata: Record<string, unknown>;
                contentHash: string;
            };
            verifierSet: {
                schemaVersion: "openpond.verifierSetRelease.v1";
                id: string;
                revision: number;
                graders: ({
                    id: string;
                    taskIds?: string[] | undefined;
                    version: string;
                    weight: number;
                    hardGate: boolean;
                    rewardEligible: boolean;
                    privileged: boolean;
                    kind: "artifact" | "content" | "runtime_event" | "schema" | "state";
                    config: Record<string, unknown>;
                } | {
                    id: string;
                    taskIds?: string[] | undefined;
                    version: string;
                    weight: number;
                    hardGate: boolean;
                    rewardEligible: boolean;
                    privileged: boolean;
                    kind: "model_judge";
                    rubricRef: {
                        id: string;
                        path: string;
                        contentHash: string;
                        sizeBytes: number;
                        mediaType: string;
                        visibility: "host_private" | "policy" | "verifier";
                    };
                    calibrationStatus: "failed" | "passed" | "pending";
                    model?: {
                        providerId: string;
                        modelId: string;
                        revision: string | null;
                    } | undefined;
                    temperature?: number | undefined;
                } | {
                    id: string;
                    taskIds?: string[] | undefined;
                    version: string;
                    weight: number;
                    hardGate: boolean;
                    rewardEligible: boolean;
                    privileged: boolean;
                    kind: "custom_verifier";
                    runtime?: "isolated_javascript" | "sandbox_process" | undefined;
                    verifierRef: {
                        id: string;
                        path: string;
                        contentHash: string;
                        sizeBytes: number;
                        mediaType: string;
                        visibility: "host_private" | "policy" | "verifier";
                    };
                    exportName?: string | undefined;
                    timeoutMs: number;
                    networkPolicy: "none";
                } | {
                    id: string;
                    taskIds?: string[] | undefined;
                    version: string;
                    weight: number;
                    hardGate: boolean;
                    rewardEligible: boolean;
                    privileged: boolean;
                    kind: "human";
                    rubricRef: {
                        id: string;
                        path: string;
                        contentHash: string;
                        sizeBytes: number;
                        mediaType: string;
                        visibility: "host_private" | "policy" | "verifier";
                    };
                    reviewerRole: string;
                    form?: {
                        schemaVersion: "openpond.humanForm.v1";
                        mode: "individual" | "pairwise";
                        instructions: string;
                        criteria: ({
                            id: string;
                            label: string;
                            instructions: string;
                            required: boolean;
                            allowAbstain: boolean;
                            requireRationale?: boolean | undefined;
                            anchors?: {
                                value: string | number | boolean;
                                description: string;
                            }[] | undefined;
                            kind: "score";
                            minimum: number;
                            maximum: number;
                            step: number;
                        } | {
                            id: string;
                            label: string;
                            instructions: string;
                            required: boolean;
                            allowAbstain: boolean;
                            requireRationale?: boolean | undefined;
                            anchors?: {
                                value: string | number | boolean;
                                description: string;
                            }[] | undefined;
                            kind: "category";
                            options: string[];
                        } | {
                            id: string;
                            label: string;
                            instructions: string;
                            required: boolean;
                            allowAbstain: boolean;
                            requireRationale?: boolean | undefined;
                            anchors?: {
                                value: string | number | boolean;
                                description: string;
                            }[] | undefined;
                            kind: "boolean";
                        } | {
                            id: string;
                            label: string;
                            instructions: string;
                            required: boolean;
                            allowAbstain: boolean;
                            requireRationale?: boolean | undefined;
                            anchors?: {
                                value: string | number | boolean;
                                description: string;
                            }[] | undefined;
                            kind: "text";
                            minimumLength?: number | undefined;
                            maximumLength: number;
                        } | {
                            id: string;
                            label: string;
                            instructions: string;
                            required: boolean;
                            allowAbstain: boolean;
                            requireRationale?: boolean | undefined;
                            anchors?: {
                                value: string | number | boolean;
                                description: string;
                            }[] | undefined;
                            kind: "preference";
                            requireStrength?: boolean | undefined;
                            allowTie: boolean;
                        })[];
                    } | undefined;
                })[];
                isolation: {
                    processBoundary: "container" | "isolated_process" | "same_process";
                    networkPolicy: "none";
                    defaultTimeoutMs: number;
                };
                calibrationReceiptRefs: {
                    id: string;
                    contentHash: string;
                }[];
                metadata: Record<string, unknown>;
                contentHash: string;
            };
            javascript: {
                schemaVersion: "openpond.javascriptEnvironment.v1";
                id: string;
                revision: number;
                module: {
                    id: string;
                    path: string;
                    contentHash: string;
                    sizeBytes: number;
                    mediaType: string;
                    visibility: "host_private" | "policy" | "verifier";
                };
                tools: {
                    name: string;
                    description: string;
                    inputSchema: Record<string, unknown>;
                    inputSchemaHash: string;
                    sideEffect: "read" | "write";
                    timeoutMs: number;
                }[];
                maxSteps: number;
                maxStateBytes: number;
                maxObservationBytes: number;
                operationTimeoutMs: number;
                executionServices?: ({
                    id: string;
                    operation: "collect" | "step";
                    toolName?: string | undefined;
                    timeoutMs: number;
                    kind: "sqlite.v1";
                    sql: {
                        scope: "arguments" | "initialState" | "input" | "state";
                        path: string[];
                    };
                    snapshot: {
                        scope: "arguments" | "initialState" | "input" | "state";
                        path: string[];
                    };
                    maxRows: number;
                    maxResultBytes: number;
                } | {
                    id: string;
                    operation: "collect" | "step";
                    toolName?: string | undefined;
                    timeoutMs: number;
                    kind: "javascript.v1";
                    source: {
                        scope: "arguments" | "initialState" | "input" | "state";
                        path: string[];
                    };
                    cases: {
                        scope: "arguments" | "initialState" | "input" | "state";
                        path: string[];
                    };
                    exportName: string;
                    maxCases: number;
                    maxResultBytes: number;
                })[] | undefined;
                contentHash: string;
            };
        } | undefined;
    };
};
/** Explicit projection keeps frozen examples, expected outputs, privileged
 * context and verifier source out of read-only model-facing previews. */
export declare function previewModelStarter(value: unknown): {
    starter: {
        schemaVersion: "openpond.modelStarter.v1";
        id: string;
        revision: number;
        name: string;
        description: string;
        category: "classification" | "coding" | "extraction" | "knowledge" | "operations" | "support" | "writing";
        taskset: {
            id: string;
            contentHash: string;
            revision: number;
        };
        taskDefinition: {
            id: string;
            contentHash: string;
            revision: number;
        };
        rewardBinding: {
            id: string;
            contentHash: string;
            revision: number;
        };
        rewards: {
            id: string;
            contentHash: string;
            revision: number;
        }[];
        assets: {
            id: string;
            contentHash: string;
            revision: number;
        }[];
        previewTaskIds: string[];
        startingModel: {
            schemaVersion: "openpond.baseModelPreference.v1";
            modelId: string;
            revision: string | null;
            tokenizerRevision: string | null;
            chatTemplateHash: string | null;
            modelAssetId: string | null;
            source: "builtin" | "local" | "managed";
        };
        supportedMethods: ("dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft")[];
        defaultMethod: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
        provenance: {
            author: string;
            license: string;
            sourceDescription: string;
        };
        evidence: {
            verifierFixtures: {
                id: string;
                contentHash: string;
                revision: number;
            } | null;
            baseline: {
                id: string;
                contentHash: string;
                revision: number;
            } | null;
            training: {
                id: string;
                contentHash: string;
                revision: number;
            } | null;
            evaluation: {
                id: string;
                contentHash: string;
                revision: number;
            } | null;
        };
        contentHash: string;
    };
    inputSchema: Record<string, unknown>;
    outputSchema: Record<string, unknown>;
    reward: {
        name: string | undefined;
        description: string | undefined;
        checks: {
            name: string;
            description: string;
            kind: "artifact" | "content" | "custom_verifier" | "human" | "learned_model" | "model_judge" | "runtime_event" | "schema" | "state";
            role: "evaluation" | "training";
            weight: number;
            required: boolean;
            hardGate: boolean;
        }[];
    };
    tasks: {
        id: string;
        input: Record<string, unknown>;
        policyVisibleContext: Record<string, unknown>;
    }[];
    counts: {
        train: number;
        validation: number;
        frozenEvaluation: number;
    };
};
/** Verify the dependency graph before creating user-owned configuration.
 * A matching outer hash alone cannot authorize substituted private graders. */
export declare function validateResolvedModelStarter(value: unknown): ResolvedModelStarter;
//# sourceMappingURL=model-starters.d.ts.map