import { z } from "zod";
import { type ModelTasksetDraftPreparation } from "./model-taskset-authoring-contracts.js";
import { type TasksetDraft } from "./taskset-draft-document.js";
import { type TasksetPackage } from "./taskset-package-contracts.js";
export declare const TasksetDraftSourceInitializationSchema: z.ZodObject<{
    draft: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.tasksetDraft.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        profileId: z.ZodString;
        modelScope: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            modelId: z.ZodString;
            expectedModelRevision: z.ZodNumber;
            source: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.modelTasksetDraftPreparation.v1">;
                draftId: z.ZodString;
                requestHash: z.ZodString;
                sourcePackageHash: z.ZodString;
                sourceTasksetRef: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                    revision: z.ZodNumber;
                }, z.core.$strict>;
                tasksetId: z.ZodString;
                tasksetRevision: z.ZodNumber;
                lineage: z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.modelTasksetAuthoring.v1">;
                    owner: z.ZodObject<{
                        scopeId: z.ZodString;
                        modelId: z.ZodString;
                    }, z.core.$strict>;
                    root: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                        revision: z.ZodNumber;
                    }, z.core.$strict>;
                    parent: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                        revision: z.ZodNumber;
                    }, z.core.$strict>;
                }, z.core.$strict>;
                authoringGraph: z.ZodOptional<z.ZodLiteral<"bound">>;
            }, z.core.$strict>>;
        }, z.core.$strict>>>;
        name: z.ZodString;
        objective: z.ZodString;
        purpose: z.ZodDefault<z.ZodEnum<{
            benchmark: "benchmark";
            general: "general";
        }>>;
        benchmark: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.tasksetBenchmark.v1">;
            definitionId: z.ZodString;
            releaseId: z.ZodString;
            releaseHash: z.ZodString;
            managedReleasePath: z.ZodString;
            adaptationSplit: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            evaluationSplit: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            primaryMetric: z.ZodEnum<{
                cost_usd: "cost_usd";
                foreground_tokens: "foreground_tokens";
                latency_ms: "latency_ms";
                success_rate: "success_rate";
            }>;
            qualityGate: z.ZodEnum<{
                all_pass: "all_pass";
                non_regression: "non_regression";
                none: "none";
            }>;
            source: z.ZodEnum<{
                builtin: "builtin";
                imported: "imported";
            }>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>>>;
        preferenceComparison: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.tasksetPreferenceComparisonBinding.v1">;
            releaseId: z.ZodString;
            releaseHash: z.ZodString;
            publishedAt: z.ZodString;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>>>;
        status: z.ZodEnum<{
            draft: "draft";
            needs_review: "needs_review";
            published: "published";
            validating: "validating";
        }>;
        sourceRefs: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.trainingSource.v1">;
            id: z.ZodString;
            profileId: z.ZodString;
            sessionId: z.ZodString;
            turnIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
            workspaceId: z.ZodNullable<z.ZodString>;
            sourceHash: z.ZodString;
            clusterKey: z.ZodString;
            title: z.ZodString;
            occurredAt: z.ZodString;
            consent: z.ZodObject<{
                status: z.ZodEnum<{
                    denied: "denied";
                    granted: "granted";
                    pending: "pending";
                    revoked: "revoked";
                }>;
                scope: z.ZodEnum<{
                    full_session: "full_session";
                    metadata_only: "metadata_only";
                    selected_turns: "selected_turns";
                }>;
                grantedBy: z.ZodNullable<z.ZodString>;
                grantedAt: z.ZodNullable<z.ZodString>;
                purpose: z.ZodLiteral<"task_authoring_and_evaluation">;
            }, z.core.$strip>;
            connectedAppIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
            secretScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
            }>;
            piiScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
                review: "review";
            }>;
            licensingStatus: z.ZodEnum<{
                approved: "approved";
                blocked: "blocked";
                pending: "pending";
                review: "review";
            }>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
            id: z.ZodString;
            profileId: z.ZodString;
            title: z.ZodString;
            sourceHash: z.ZodString;
            occurredAt: z.ZodString;
            licensingStatus: z.ZodEnum<{
                approved: "approved";
                blocked: "blocked";
                pending: "pending";
                review: "review";
            }>;
            secretScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
            }>;
            piiScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
                review: "review";
            }>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            schemaVersion: z.ZodLiteral<"openpond.huggingFaceDatasetSource.v1">;
            kind: z.ZodLiteral<"huggingface">;
            repositoryId: z.ZodString;
            repositoryUrl: z.ZodString;
            revision: z.ZodString;
            configuration: z.ZodString;
            upstreamSplits: z.ZodArray<z.ZodString>;
            gated: z.ZodBoolean;
            private: z.ZodBoolean;
            declaredLicense: z.ZodNullable<z.ZodString>;
            sourceFileHashes: z.ZodArray<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            profileId: z.ZodString;
            title: z.ZodString;
            sourceHash: z.ZodString;
            occurredAt: z.ZodString;
            licensingStatus: z.ZodEnum<{
                approved: "approved";
                blocked: "blocked";
                pending: "pending";
                review: "review";
            }>;
            secretScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
            }>;
            piiScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
                review: "review";
            }>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            schemaVersion: z.ZodLiteral<"openpond.uploadedFileDatasetSource.v1">;
            kind: z.ZodLiteral<"uploaded_file">;
            originalFileNames: z.ZodArray<z.ZodString>;
            mediaTypes: z.ZodArray<z.ZodString>;
            sourceFileHashes: z.ZodArray<z.ZodString>;
            totalBytes: z.ZodNumber;
            parserVersion: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            profileId: z.ZodString;
            title: z.ZodString;
            sourceHash: z.ZodString;
            occurredAt: z.ZodString;
            licensingStatus: z.ZodEnum<{
                approved: "approved";
                blocked: "blocked";
                pending: "pending";
                review: "review";
            }>;
            secretScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
            }>;
            piiScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
                review: "review";
            }>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            schemaVersion: z.ZodLiteral<"openpond.generatedDatasetSource.v1">;
            kind: z.ZodLiteral<"generated">;
            generatorId: z.ZodString;
            generatorVersion: z.ZodString;
            seed: z.ZodNumber;
            generatorHash: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            profileId: z.ZodString;
            title: z.ZodString;
            sourceHash: z.ZodString;
            occurredAt: z.ZodString;
            licensingStatus: z.ZodEnum<{
                approved: "approved";
                blocked: "blocked";
                pending: "pending";
                review: "review";
            }>;
            secretScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
            }>;
            piiScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
                review: "review";
            }>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            schemaVersion: z.ZodLiteral<"openpond.learningBatchDatasetSource.v1">;
            kind: z.ZodLiteral<"learning_batch">;
            batch: z.ZodObject<{
                id: z.ZodString;
                revision: z.ZodNumber;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            taskDefinition: z.ZodObject<{
                id: z.ZodString;
                revision: z.ZodNumber;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            admittedBy: z.ZodString;
        }, z.core.$strip>], "kind">, z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.connectedDatasetSource.v1">;
            kind: z.ZodLiteral<"connected_activity">;
            id: z.ZodString;
            profileId: z.ZodString;
            title: z.ZodString;
            sourceHash: z.ZodString;
            occurredAt: z.ZodString;
            licensingStatus: z.ZodEnum<{
                approved: "approved";
                blocked: "blocked";
                pending: "pending";
                review: "review";
            }>;
            secretScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
            }>;
            piiScanStatus: z.ZodEnum<{
                blocked: "blocked";
                passed: "passed";
                pending: "pending";
                review: "review";
            }>;
            origin: z.ZodEnum<{
                claude_code: "claude_code";
                codex: "codex";
                grok_build: "grok_build";
                hermes: "hermes";
                native_chat: "native_chat";
                native_work: "native_work";
                oh_my_pi: "oh_my_pi";
                openclaw: "openclaw";
                opencode: "opencode";
                pi: "pi";
            }>;
            sourceId: z.ZodString;
            sessionId: z.ZodString;
            normalizerVersion: z.ZodString;
            projection: z.ZodEnum<{
                conversation: "conversation";
                turn: "turn";
            }>;
            ownerUserId: z.ZodString;
            purpose: z.ZodLiteral<"recorded_evaluation">;
            sourceFileHashes: z.ZodOptional<z.ZodArray<z.ZodString>>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>]>>>;
        datasetArtifact: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.datasetArtifact.v1">;
            id: z.ZodString;
            tasksetId: z.ZodString;
            tasksetRevision: z.ZodNumber;
            contentHash: z.ZodString;
            format: z.ZodLiteral<"parquet">;
            schema: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.datasetSemanticSchema.v1">;
                fields: z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    semanticRole: z.ZodEnum<{
                        chosen: "chosen";
                        cluster_id: "cluster_id";
                        demonstration: "demonstration";
                        expected_output: "expected_output";
                        feedback: "feedback";
                        messages: "messages";
                        metadata: "metadata";
                        privileged_context: "privileged_context";
                        prompt: "prompt";
                        rejected: "rejected";
                        reward: "reward";
                        row_id: "row_id";
                        tag: "tag";
                    }>;
                    logicalType: z.ZodEnum<{
                        boolean: "boolean";
                        float: "float";
                        integer: "integer";
                        json: "json";
                        messages: "messages";
                        string: "string";
                    }>;
                    nullable: z.ZodBoolean;
                    policy: z.ZodEnum<{
                        metadata: "metadata";
                        privileged: "privileged";
                        visible: "visible";
                    }>;
                }, z.core.$strip>>;
                schemaHash: z.ZodString;
            }, z.core.$strip>;
            shards: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                split: z.ZodEnum<{
                    frozen_eval: "frozen_eval";
                    test: "test";
                    train: "train";
                    validation: "validation";
                }>;
                path: z.ZodString;
                contentHash: z.ZodString;
                schemaHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                rowCount: z.ZodNumber;
                rowGroupCount: z.ZodNumber;
            }, z.core.$strip>>;
            rowCount: z.ZodNumber;
            splitCounts: z.ZodRecord<z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>, z.ZodNumber>;
            sourceReceiptRefs: z.ZodArray<z.ZodString>;
            mappingHash: z.ZodString;
            qualityReportHash: z.ZodString;
            createdAt: z.ZodString;
        }, z.core.$strip>>>;
        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.$strip>;
        environment: z.ZodObject<{
            protocolVersion: z.ZodLiteral<"openpond.taskEnvironment.v1">;
            kind: z.ZodEnum<{
                agent: "agent";
                chat: "chat";
                program: "program";
                stateful_harness: "stateful_harness";
                work: "work";
            }>;
            entrypoint: z.ZodString;
            stateful: z.ZodBoolean;
            deterministicSeeds: z.ZodBoolean;
            toolNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
            actionBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.harnessActionBinding.v1">;
                actionId: z.ZodString;
                modelToolName: z.ZodString;
                description: z.ZodString;
                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                actionSchemaHash: z.ZodString;
                agentRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                implementationHash: z.ZodString;
                runtimeBindingId: z.ZodString;
                capabilityReceiptHash: z.ZodString;
                sideEffect: z.ZodEnum<{
                    read: "read";
                    write: "write";
                }>;
                studentVisible: z.ZodBoolean;
                timeoutMs: z.ZodNumber;
                episodeArgumentBindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
                    argument: z.ZodString;
                    source: z.ZodLiteral<"case_id">;
                }, z.core.$strict>>>;
            }, z.core.$strict>>>;
            lifecycle: z.ZodArray<z.ZodEnum<{
                cleanup: "cleanup";
                create: "create";
                grade: "grade";
                reset: "reset";
                step: "step";
            }>>;
            defaultTimeoutMs: z.ZodNumber;
            networkPolicy: z.ZodEnum<{
                declared_read_only: "declared_read_only";
                declared_scoped: "declared_scoped";
                none: "none";
            }>;
            resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                kind: z.ZodEnum<{
                    catalog: "catalog";
                    code_module: "code_module";
                    configuration: "configuration";
                    file: "file";
                }>;
                path: z.ZodString;
                mediaType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                visibility: z.ZodEnum<{
                    policy_hidden: "policy_hidden";
                    policy_visible: "policy_visible";
                    privileged: "privileged";
                }>;
                required: z.ZodBoolean;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strip>>>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>;
        output: z.ZodDefault<z.ZodObject<{
            mode: z.ZodEnum<{
                artifacts: "artifacts";
                structured_json: "structured_json";
                text: "text";
            }>;
            jsonSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            requiredOutputSource: z.ZodOptional<z.ZodLiteral<"task.requiredOutputs">>;
            responsePath: z.ZodOptional<z.ZodString>;
            renderer: z.ZodNullable<z.ZodObject<{
                module: z.ZodString;
                exportName: z.ZodString;
                configRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            }, z.core.$strip>>;
        }, z.core.$strip>>;
        capabilities: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.tasksetCapabilities.v1">;
            taskKind: z.ZodEnum<{
                chat: "chat";
                custom_program: "custom_program";
                multi_agent: "multi_agent";
                single_agent: "single_agent";
            }>;
            supportedSignals: z.ZodArray<z.ZodEnum<{
                correction: "correction";
                demonstration: "demonstration";
                feedback: "feedback";
                label: "label";
                preference: "preference";
                reward: "reward";
            }>>;
            compatibleMethods: z.ZodArray<z.ZodEnum<{
                dpo: "dpo";
                grpo: "grpo";
                none: "none";
                opd: "opd";
                opsd: "opsd";
                ppo: "ppo";
                retrieval: "retrieval";
                sdft: "sdft";
                sdpo: "sdpo";
                sft: "sft";
            }>>;
            rewardKinds: z.ZodArray<z.ZodEnum<{
                deterministic: "deterministic";
                exact: "exact";
                human: "human";
                model_judge: "model_judge";
                none: "none";
            }>>;
            requiresTools: z.ZodBoolean;
            requiresState: z.ZodBoolean;
            requiresPrivilegedGrading: z.ZodBoolean;
            environmentPlacements: z.ZodArray<z.ZodEnum<{
                colocated: "colocated";
                local: "local";
                provider_native: "provider_native";
                remote: "remote";
            }>>;
            exportable: z.ZodBoolean;
            portabilityBlockers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>;
        metrics: 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>;
        review: z.ZodObject<{
            enabled: z.ZodBoolean;
            candidateCount: z.ZodNumber;
            minimumSamples: z.ZodDefault<z.ZodNumber>;
            allowTies: z.ZodBoolean;
            allowRejectAll: z.ZodBoolean;
            rubric: z.ZodString;
            criteria: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                label: z.ZodString;
                description: z.ZodString;
                weight: z.ZodNumber;
            }, z.core.$strip>>;
        }, z.core.$strip>;
        tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.taskData.v1">;
            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>;
            assets: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                sourceRefId: z.ZodString;
                artifactRef: z.ZodString;
                fileName: z.ZodString;
                stagingPath: z.ZodOptional<z.ZodString>;
                mediaType: z.ZodString;
                sha256: z.ZodString;
                sizeBytes: z.ZodNumber;
                split: z.ZodEnum<{
                    frozen_eval: "frozen_eval";
                    test: "test";
                    train: "train";
                    validation: "validation";
                }>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strip>>>;
            resourceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                path: z.ZodString;
                mediaType: z.ZodString;
                schemaRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
                maxBytes: z.ZodOptional<z.ZodNumber>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strip>>>;
            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            sourceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>>;
        graders: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            label: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            kind: z.ZodEnum<{
                content: "content";
                diff: "diff";
                file: "file";
                runtime_event: "runtime_event";
                schema: "schema";
                state: "state";
                test: "test";
            }>;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            label: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            kind: z.ZodLiteral<"model_judge">;
            rubric: z.ZodString;
            judge: z.ZodObject<{
                providerId: z.ZodUnion<readonly [z.ZodEnum<{
                    anthropic: "anthropic";
                    "claude-code": "claude-code";
                    codex: "codex";
                    "custom-openai-compatible": "custom-openai-compatible";
                    deepseek: "deepseek";
                    google: "google";
                    "grok-build": "grok-build";
                    groq: "groq";
                    moonshot: "moonshot";
                    openai: "openai";
                    opencode: "opencode";
                    openpond: "openpond";
                    openrouter: "openrouter";
                    together: "together";
                    xai: "xai";
                    zai: "zai";
                }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
                modelId: z.ZodString;
            }, z.core.$strip>;
            calibrationFixtureRefs: z.ZodArray<z.ZodString>;
            calibrationStatus: z.ZodEnum<{
                failed: "failed";
                passed: "passed";
                pending: "pending";
            }>;
            temperature: z.ZodDefault<z.ZodNumber>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            label: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            kind: z.ZodLiteral<"human">;
            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>>;
            rubric: z.ZodString;
            reviewerRole: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            label: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            kind: z.ZodLiteral<"custom_verifier">;
            runtime: z.ZodOptional<z.ZodEnum<{
                isolated_javascript: "isolated_javascript";
                sandbox_process: "sandbox_process";
            }>>;
            module: z.ZodString;
            exportName: z.ZodString;
            timeoutMs: z.ZodNumber;
            networkPolicy: z.ZodLiteral<"none">;
        }, z.core.$strip>]>>>;
        graderFixtures: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            taskId: z.ZodString;
            label: z.ZodEnum<{
                adversarial: "adversarial";
                boundary: "boundary";
                infrastructure_failure: "infrastructure_failure";
                negative: "negative";
                positive: "positive";
                prompt_injection: "prompt_injection";
            }>;
            output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            infrastructureError: z.ZodNullable<z.ZodString>;
            expectedPassed: z.ZodBoolean;
            expectedRewardEligible: z.ZodBoolean;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>>>;
        learningSignals: z.ZodObject<{
            demonstrations: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                taskId: z.ZodNullable<z.ZodString>;
                sourceRefs: z.ZodArray<z.ZodString>;
                artifactRef: z.ZodString;
                approved: z.ZodBoolean;
                confidence: z.ZodNumber;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                kind: z.ZodLiteral<"demonstration">;
                prompt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                response: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            }, z.core.$strip>>>;
            preferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                taskId: z.ZodNullable<z.ZodString>;
                sourceRefs: z.ZodArray<z.ZodString>;
                artifactRef: z.ZodString;
                approved: z.ZodBoolean;
                confidence: z.ZodNumber;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                kind: z.ZodLiteral<"preference">;
                prompt: z.ZodString;
                chosen: z.ZodString;
                rejected: z.ZodString;
                rationale: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            }, z.core.$strip>>>;
            corrections: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                taskId: z.ZodNullable<z.ZodString>;
                sourceRefs: z.ZodArray<z.ZodString>;
                artifactRef: z.ZodString;
                approved: z.ZodBoolean;
                confidence: z.ZodNumber;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                kind: z.ZodLiteral<"correction">;
                original: z.ZodString;
                corrected: z.ZodString;
                rationale: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            }, z.core.$strip>>>;
            feedback: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                taskId: z.ZodNullable<z.ZodString>;
                sourceRefs: z.ZodArray<z.ZodString>;
                artifactRef: z.ZodString;
                approved: z.ZodBoolean;
                confidence: z.ZodNumber;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                kind: z.ZodLiteral<"feedback">;
                feedback: z.ZodString;
                polarity: z.ZodEnum<{
                    mixed: "mixed";
                    negative: "negative";
                    neutral: "neutral";
                    positive: "positive";
                }>;
            }, z.core.$strip>>>;
            rewards: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                taskId: z.ZodNullable<z.ZodString>;
                sourceRefs: z.ZodArray<z.ZodString>;
                artifactRef: z.ZodString;
                approved: z.ZodBoolean;
                confidence: z.ZodNumber;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                kind: z.ZodLiteral<"reward">;
                task: z.ZodString;
                rules: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    points: z.ZodNumber;
                    condition: z.ZodString;
                }, z.core.$strip>>;
                otherwisePoints: z.ZodNumber;
                executable: z.ZodBoolean;
            }, z.core.$strip>>>;
            labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                taskId: z.ZodNullable<z.ZodString>;
                sourceRefs: z.ZodArray<z.ZodString>;
                artifactRef: z.ZodString;
                approved: z.ZodBoolean;
                confidence: z.ZodNumber;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                kind: z.ZodLiteral<"label">;
                labelKind: z.ZodLiteral<"rubric">;
                task: z.ZodString;
                criteria: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    description: z.ZodString;
                }, z.core.$strip>>;
                calibrationExamples: z.ZodObject<{
                    positive: z.ZodString;
                    negative: z.ZodString;
                    boundary: z.ZodString;
                }, z.core.$strip>;
            }, z.core.$strip>>>;
        }, z.core.$strip>;
        publishedTasksetRef: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            revision: z.ZodNumber;
            contentHash: z.ZodString;
        }, z.core.$strip>>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>;
    filePaths: z.ZodArray<z.ZodObject<{
        assetId: z.ZodString;
        paths: z.ZodArray<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type TasksetDraftSourceInitialization = z.infer<typeof TasksetDraftSourceInitializationSchema>;
/** Hosts authorize the source projection and retain this result before writes.
 * Ownership comes from preparation, never from editable projection metadata. */
export declare function prepareTasksetDraftSource(input: {
    sourceDraft: TasksetDraft;
    source: TasksetPackage;
    preparation: ModelTasksetDraftPreparation;
    expectedModelRevision: number;
}): TasksetDraftSourceInitialization;
/** Materialize the retained source into an immutable draft snapshot. Callers
 * must never replace a newer saved snapshot with this initial population. */
export declare function materializeTasksetDraftWorkspace(input: {
    initialized: TasksetDraftSourceInitialization;
    source: TasksetPackage;
}): {
    schemaVersion: "openpond.tasksetDraftWorkspace.v1";
    draft: {
        schemaVersion: "openpond.tasksetDraft.v1";
        id: string;
        revision: number;
        profileId: string;
        modelScope: {
            modelId: string;
            expectedModelRevision: number;
            source?: {
                schemaVersion: "openpond.modelTasksetDraftPreparation.v1";
                draftId: string;
                requestHash: string;
                sourcePackageHash: string;
                sourceTasksetRef: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                tasksetId: string;
                tasksetRevision: number;
                lineage: {
                    schemaVersion: "openpond.modelTasksetAuthoring.v1";
                    owner: {
                        scopeId: string;
                        modelId: string;
                    };
                    root: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    parent: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                };
                authoringGraph?: "bound" | undefined;
            } | undefined;
        } | null;
        name: string;
        objective: string;
        purpose: "benchmark" | "general";
        benchmark: {
            schemaVersion: "openpond.tasksetBenchmark.v1";
            definitionId: string;
            releaseId: string;
            releaseHash: string;
            managedReleasePath: string;
            adaptationSplit: "frozen_eval" | "test" | "train" | "validation";
            evaluationSplit: "frozen_eval" | "test" | "train" | "validation";
            primaryMetric: "cost_usd" | "foreground_tokens" | "latency_ms" | "success_rate";
            qualityGate: "all_pass" | "non_regression" | "none";
            source: "builtin" | "imported";
            metadata: Record<string, unknown>;
        } | null;
        preferenceComparison: {
            schemaVersion: "openpond.tasksetPreferenceComparisonBinding.v1";
            releaseId: string;
            releaseHash: string;
            publishedAt: string;
            metadata: Record<string, unknown>;
        } | null;
        status: "draft" | "needs_review" | "published" | "validating";
        sourceRefs: ({
            id: string;
            profileId: string;
            title: string;
            sourceHash: string;
            occurredAt: string;
            licensingStatus: "approved" | "blocked" | "pending" | "review";
            secretScanStatus: "blocked" | "passed" | "pending";
            piiScanStatus: "blocked" | "passed" | "pending" | "review";
            metadata: Record<string, unknown>;
            schemaVersion: "openpond.huggingFaceDatasetSource.v1";
            kind: "huggingface";
            repositoryId: string;
            repositoryUrl: string;
            revision: string;
            configuration: string;
            upstreamSplits: string[];
            gated: boolean;
            private: boolean;
            declaredLicense: string | null;
            sourceFileHashes: string[];
        } | {
            id: string;
            profileId: string;
            title: string;
            sourceHash: string;
            occurredAt: string;
            licensingStatus: "approved" | "blocked" | "pending" | "review";
            secretScanStatus: "blocked" | "passed" | "pending";
            piiScanStatus: "blocked" | "passed" | "pending" | "review";
            metadata: Record<string, unknown>;
            schemaVersion: "openpond.uploadedFileDatasetSource.v1";
            kind: "uploaded_file";
            originalFileNames: string[];
            mediaTypes: string[];
            sourceFileHashes: string[];
            totalBytes: number;
            parserVersion: string;
        } | {
            id: string;
            profileId: string;
            title: string;
            sourceHash: string;
            occurredAt: string;
            licensingStatus: "approved" | "blocked" | "pending" | "review";
            secretScanStatus: "blocked" | "passed" | "pending";
            piiScanStatus: "blocked" | "passed" | "pending" | "review";
            metadata: Record<string, unknown>;
            schemaVersion: "openpond.generatedDatasetSource.v1";
            kind: "generated";
            generatorId: string;
            generatorVersion: string;
            seed: number;
            generatorHash: string;
        } | {
            id: string;
            profileId: string;
            title: string;
            sourceHash: string;
            occurredAt: string;
            licensingStatus: "approved" | "blocked" | "pending" | "review";
            secretScanStatus: "blocked" | "passed" | "pending";
            piiScanStatus: "blocked" | "passed" | "pending" | "review";
            metadata: Record<string, unknown>;
            schemaVersion: "openpond.learningBatchDatasetSource.v1";
            kind: "learning_batch";
            batch: {
                id: string;
                revision: number;
                contentHash: string;
            };
            taskDefinition: {
                id: string;
                revision: number;
                contentHash: string;
            };
            admittedBy: string;
        } | {
            schemaVersion: "openpond.trainingSource.v1";
            id: string;
            profileId: string;
            sessionId: string;
            turnIds: string[];
            workspaceId: string | null;
            sourceHash: string;
            clusterKey: string;
            title: string;
            occurredAt: string;
            consent: {
                status: "denied" | "granted" | "pending" | "revoked";
                scope: "full_session" | "metadata_only" | "selected_turns";
                grantedBy: string | null;
                grantedAt: string | null;
                purpose: "task_authoring_and_evaluation";
            };
            connectedAppIds: string[];
            secretScanStatus: "blocked" | "passed" | "pending";
            piiScanStatus: "blocked" | "passed" | "pending" | "review";
            licensingStatus: "approved" | "blocked" | "pending" | "review";
            metadata: Record<string, unknown>;
        } | {
            schemaVersion: "openpond.connectedDatasetSource.v1";
            kind: "connected_activity";
            id: string;
            profileId: string;
            title: string;
            sourceHash: string;
            occurredAt: string;
            licensingStatus: "approved" | "blocked" | "pending" | "review";
            secretScanStatus: "blocked" | "passed" | "pending";
            piiScanStatus: "blocked" | "passed" | "pending" | "review";
            origin: "claude_code" | "codex" | "grok_build" | "hermes" | "native_chat" | "native_work" | "oh_my_pi" | "openclaw" | "opencode" | "pi";
            sourceId: string;
            sessionId: string;
            normalizerVersion: string;
            projection: "conversation" | "turn";
            ownerUserId: string;
            purpose: "recorded_evaluation";
            sourceFileHashes?: string[] | undefined;
            metadata: Record<string, unknown>;
        })[];
        datasetArtifact?: {
            schemaVersion: "openpond.datasetArtifact.v1";
            id: string;
            tasksetId: string;
            tasksetRevision: number;
            contentHash: string;
            format: "parquet";
            schema: {
                schemaVersion: "openpond.datasetSemanticSchema.v1";
                fields: {
                    name: string;
                    semanticRole: "chosen" | "cluster_id" | "demonstration" | "expected_output" | "feedback" | "messages" | "metadata" | "privileged_context" | "prompt" | "rejected" | "reward" | "row_id" | "tag";
                    logicalType: "boolean" | "float" | "integer" | "json" | "messages" | "string";
                    nullable: boolean;
                    policy: "metadata" | "privileged" | "visible";
                }[];
                schemaHash: string;
            };
            shards: {
                id: string;
                split: "frozen_eval" | "test" | "train" | "validation";
                path: string;
                contentHash: string;
                schemaHash: string;
                sizeBytes: number;
                rowCount: number;
                rowGroupCount: number;
            }[];
            rowCount: number;
            splitCounts: Record<"frozen_eval" | "test" | "train" | "validation", number>;
            sourceReceiptRefs: string[];
            mappingHash: string;
            qualityReportHash: string;
            createdAt: string;
        } | null | undefined;
        policy: {
            policyVisibleFields: string[];
            privilegedFields: string[];
            hiddenGraderRefs: string[];
            connectedAppScopes: string[];
        };
        environment: {
            protocolVersion: "openpond.taskEnvironment.v1";
            kind: "agent" | "chat" | "program" | "stateful_harness" | "work";
            entrypoint: string;
            stateful: boolean;
            deterministicSeeds: boolean;
            toolNames: string[];
            actionBindings?: {
                schemaVersion: "openpond.harnessActionBinding.v1";
                actionId: string;
                modelToolName: string;
                description: string;
                inputSchema: Record<string, unknown>;
                actionSchemaHash: string;
                agentRelease: {
                    id: string;
                    contentHash: string;
                };
                implementationHash: string;
                runtimeBindingId: string;
                capabilityReceiptHash: string;
                sideEffect: "read" | "write";
                studentVisible: boolean;
                timeoutMs: number;
                episodeArgumentBindings: {
                    argument: string;
                    source: "case_id";
                }[];
            }[] | undefined;
            lifecycle: ("cleanup" | "create" | "grade" | "reset" | "step")[];
            defaultTimeoutMs: number;
            networkPolicy: "declared_read_only" | "declared_scoped" | "none";
            resources?: {
                id: string;
                kind: "catalog" | "code_module" | "configuration" | "file";
                path: string;
                mediaType?: string | null | undefined;
                visibility: "policy_hidden" | "policy_visible" | "privileged";
                required: boolean;
                metadata: Record<string, unknown>;
            }[] | undefined;
            metadata: Record<string, unknown>;
        };
        output: {
            mode: "artifacts" | "structured_json" | "text";
            jsonSchema: Record<string, unknown> | null;
            requiredOutputSource?: "task.requiredOutputs" | undefined;
            responsePath?: string | undefined;
            renderer: {
                module: string;
                exportName: string;
                configRef: string | null;
            } | null;
        };
        capabilities: {
            schemaVersion: "openpond.tasksetCapabilities.v1";
            taskKind: "chat" | "custom_program" | "multi_agent" | "single_agent";
            supportedSignals: ("correction" | "demonstration" | "feedback" | "label" | "preference" | "reward")[];
            compatibleMethods: ("dpo" | "grpo" | "none" | "opd" | "opsd" | "ppo" | "retrieval" | "sdft" | "sdpo" | "sft")[];
            rewardKinds: ("deterministic" | "exact" | "human" | "model_judge" | "none")[];
            requiresTools: boolean;
            requiresState: boolean;
            requiresPrivilegedGrading: boolean;
            environmentPlacements: ("colocated" | "local" | "provider_native" | "remote")[];
            exportable: boolean;
            portabilityBlockers: string[];
        };
        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;
        };
        review: {
            enabled: boolean;
            candidateCount: number;
            minimumSamples: number;
            allowTies: boolean;
            allowRejectAll: boolean;
            rubric: string;
            criteria: {
                id: string;
                label: string;
                description: string;
                weight: number;
            }[];
        };
        tasks: {
            schemaVersion: "openpond.taskData.v1";
            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;
            assets?: {
                id: string;
                sourceRefId: string;
                artifactRef: string;
                fileName: string;
                stagingPath?: string | undefined;
                mediaType: string;
                sha256: string;
                sizeBytes: number;
                split: "frozen_eval" | "test" | "train" | "validation";
                metadata: Record<string, unknown>;
            }[] | undefined;
            resourceRefs?: string[] | undefined;
            requiredOutputs?: {
                path: string;
                mediaType: string;
                schemaRef?: string | null | undefined;
                submissionMode?: "structured_json" | undefined;
                maxBytes?: number | undefined;
                metadata: Record<string, unknown>;
            }[] | undefined;
            tags: string[];
            metadata: Record<string, unknown>;
            sourceRefs: string[];
        }[];
        graders: ({
            id: string;
            taskIds?: string[] | undefined;
            version: string;
            label: string;
            weight: number;
            hardGate: boolean;
            rewardEligible: boolean;
            privileged: boolean;
            metadata: Record<string, unknown>;
            kind: "content" | "diff" | "file" | "runtime_event" | "schema" | "state" | "test";
            config: Record<string, unknown>;
        } | {
            id: string;
            taskIds?: string[] | undefined;
            version: string;
            label: string;
            weight: number;
            hardGate: boolean;
            rewardEligible: boolean;
            privileged: boolean;
            metadata: Record<string, unknown>;
            kind: "model_judge";
            rubric: string;
            judge: {
                providerId: "anthropic" | "claude-code" | "codex" | "custom-openai-compatible" | "deepseek" | "google" | "grok-build" | "groq" | "moonshot" | "openai" | "opencode" | "openpond" | "openrouter" | "together" | "xai" | "zai" | `acp:${string}`;
                modelId: string;
            };
            calibrationFixtureRefs: string[];
            calibrationStatus: "failed" | "passed" | "pending";
            temperature: number;
        } | {
            id: string;
            taskIds?: string[] | undefined;
            version: string;
            label: string;
            weight: number;
            hardGate: boolean;
            rewardEligible: boolean;
            privileged: boolean;
            metadata: Record<string, unknown>;
            kind: "human";
            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;
            rubric: string;
            reviewerRole: string;
        } | {
            id: string;
            taskIds?: string[] | undefined;
            version: string;
            label: string;
            weight: number;
            hardGate: boolean;
            rewardEligible: boolean;
            privileged: boolean;
            metadata: Record<string, unknown>;
            kind: "custom_verifier";
            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
            module: string;
            exportName: string;
            timeoutMs: number;
            networkPolicy: "none";
        })[];
        graderFixtures: {
            id: string;
            taskId: string;
            label: "adversarial" | "boundary" | "infrastructure_failure" | "negative" | "positive" | "prompt_injection";
            output: Record<string, unknown>;
            infrastructureError: string | null;
            expectedPassed: boolean;
            expectedRewardEligible: boolean;
            metadata: Record<string, unknown>;
        }[];
        learningSignals: {
            demonstrations: {
                id: string;
                taskId: string | null;
                sourceRefs: string[];
                artifactRef: string;
                approved: boolean;
                confidence: number;
                metadata: Record<string, unknown>;
                kind: "demonstration";
                prompt: string | null;
                response: string | null;
            }[];
            preferences: {
                id: string;
                taskId: string | null;
                sourceRefs: string[];
                artifactRef: string;
                approved: boolean;
                confidence: number;
                metadata: Record<string, unknown>;
                kind: "preference";
                prompt: string;
                chosen: string;
                rejected: string;
                rationale: string | null;
            }[];
            corrections: {
                id: string;
                taskId: string | null;
                sourceRefs: string[];
                artifactRef: string;
                approved: boolean;
                confidence: number;
                metadata: Record<string, unknown>;
                kind: "correction";
                original: string;
                corrected: string;
                rationale: string | null;
            }[];
            feedback: {
                id: string;
                taskId: string | null;
                sourceRefs: string[];
                artifactRef: string;
                approved: boolean;
                confidence: number;
                metadata: Record<string, unknown>;
                kind: "feedback";
                feedback: string;
                polarity: "mixed" | "negative" | "neutral" | "positive";
            }[];
            rewards: {
                id: string;
                taskId: string | null;
                sourceRefs: string[];
                artifactRef: string;
                approved: boolean;
                confidence: number;
                metadata: Record<string, unknown>;
                kind: "reward";
                task: string;
                rules: {
                    id: string;
                    points: number;
                    condition: string;
                }[];
                otherwisePoints: number;
                executable: boolean;
            }[];
            labels: {
                id: string;
                taskId: string | null;
                sourceRefs: string[];
                artifactRef: string;
                approved: boolean;
                confidence: number;
                metadata: Record<string, unknown>;
                kind: "label";
                labelKind: "rubric";
                task: string;
                criteria: {
                    id: string;
                    label: string;
                    description: string;
                }[];
                calibrationExamples: {
                    positive: string;
                    negative: string;
                    boundary: string;
                };
            }[];
        };
        publishedTasksetRef: {
            id: string;
            revision: number;
            contentHash: string;
        } | null;
        createdAt: string;
        updatedAt: string;
        metadata: Record<string, unknown>;
    };
    files: {
        path: string;
        contentHash: string;
        sizeBytes: number;
        base64: string;
    }[];
    contentHash: string;
};
//# sourceMappingURL=taskset-draft-source.d.ts.map