import { z } from "zod";
export declare const TasksetDraftCreateRequestSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftCreate.v1">;
    operationId: z.ZodString;
    modelId: z.ZodString;
    expectedModelRevision: z.ZodNumber;
    name: z.ZodString;
}, z.core.$strict>;
export type TasksetDraftCreateRequest = z.infer<typeof TasksetDraftCreateRequestSchema>;
export declare const TasksetDraftSourceDescriptorSchema: z.ZodObject<{
    teamId: z.ZodString;
    modelId: z.ZodString;
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftSourceDescriptor.v1">;
    expectedModelRevision: z.ZodNumber;
    sourcePackageHash: z.ZodString;
}, z.core.$strict>;
export declare const TasksetDraftReadbackSchema: z.ZodObject<{
    teamId: z.ZodString;
    modelId: z.ZodString;
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftReadback.v1">;
    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>;
    workspaceHash: z.ZodString;
    projectEtag: z.ZodString;
}, z.core.$strict>;
export declare const TasksetDraftSummarySchema: z.ZodObject<{
    id: z.ZodString;
    revision: z.ZodNumber;
    name: z.ZodString;
    status: z.ZodEnum<{
        draft: "draft";
        needs_review: "needs_review";
        published: "published";
        validating: "validating";
    }>;
    updatedAt: z.ZodString;
    sourceTasksetRef: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const TasksetDraftListSchema: z.ZodObject<{
    teamId: z.ZodString;
    modelId: z.ZodString;
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftList.v1">;
    drafts: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        revision: z.ZodNumber;
        name: z.ZodString;
        status: z.ZodEnum<{
            draft: "draft";
            needs_review: "needs_review";
            published: "published";
            validating: "validating";
        }>;
        updatedAt: z.ZodString;
        sourceTasksetRef: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    nextCursor: z.ZodNullable<z.ZodString>;
}, z.core.$strict>;
export declare const TasksetDraftSaveRequestSchema: z.ZodObject<{
    expectedDraftRevision: z.ZodNumber;
    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>;
}, z.core.$strict>;
export declare const TasksetDraftRefreshRequestSchema: z.ZodObject<{
    expectedDraftRevision: z.ZodNumber;
    expectedModelRevision: z.ZodNumber;
}, z.core.$strict>;
export declare const TasksetDraftValidationRequestSchema: z.ZodObject<{
    expectedDraftRevision: z.ZodNumber;
    expectedWorkspaceHash: z.ZodString;
}, z.core.$strict>;
export declare const TasksetDraftValidationSchema: z.ZodObject<{
    teamId: z.ZodString;
    modelId: z.ZodString;
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftValidation.v1">;
    draftId: z.ZodString;
    draftRevision: z.ZodNumber;
    workspaceHash: z.ZodString;
    valid: z.ZodBoolean;
    issues: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        severity: z.ZodEnum<{
            error: "error";
            warning: "warning";
        }>;
        message: z.ZodString;
        path: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
    packageHash: z.ZodNullable<z.ZodString>;
    tasksetRef: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const TasksetDraftPublicationRequestSchema: z.ZodObject<{
    expectedDraftRevision: z.ZodNumber;
    expectedWorkspaceHash: z.ZodString;
    operationId: z.ZodString;
    expectedPackageHash: z.ZodString;
    expectedTasksetRef: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
}, z.core.$strict>;
export declare const TasksetDraftFileListSchema: z.ZodObject<{
    teamId: z.ZodString;
    modelId: z.ZodString;
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftFileList.v1">;
    draftId: z.ZodString;
    draftRevision: z.ZodNumber;
    files: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        sizeBytes: z.ZodNumber;
        writable: z.ZodBoolean;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const TasksetDraftFileReadbackSchema: z.ZodObject<{
    teamId: z.ZodString;
    modelId: z.ZodString;
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftFileReadback.v1">;
    draftId: z.ZodString;
    draftRevision: z.ZodNumber;
    file: z.ZodObject<{
        path: z.ZodString;
        sizeBytes: z.ZodNumber;
        writable: z.ZodBoolean;
        contentHash: z.ZodString;
        content: z.ZodObject<{
            encoding: z.ZodEnum<{
                base64: "base64";
                utf8: "utf8";
            }>;
            data: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>;
}, z.core.$strict>;
export declare const TasksetDraftDeletionSchema: z.ZodObject<{
    teamId: z.ZodString;
    modelId: z.ZodString;
    schemaVersion: z.ZodLiteral<"openpond.tasksetDraftDeletion.v1">;
    draftId: z.ZodString;
    revision: z.ZodNumber;
    deleted: z.ZodLiteral<true>;
}, z.core.$strict>;
export type TasksetDraftSourceDescriptor = z.infer<typeof TasksetDraftSourceDescriptorSchema>;
export type TasksetDraftReadback = z.infer<typeof TasksetDraftReadbackSchema>;
export type TasksetDraftList = z.infer<typeof TasksetDraftListSchema>;
export type TasksetDraftSaveRequest = z.infer<typeof TasksetDraftSaveRequestSchema>;
export type TasksetDraftRefreshRequest = z.infer<typeof TasksetDraftRefreshRequestSchema>;
export type TasksetDraftValidationRequest = z.infer<typeof TasksetDraftValidationRequestSchema>;
export type TasksetDraftValidation = z.infer<typeof TasksetDraftValidationSchema>;
export type TasksetDraftPublicationRequest = z.infer<typeof TasksetDraftPublicationRequestSchema>;
export type TasksetDraftFileList = z.infer<typeof TasksetDraftFileListSchema>;
export type TasksetDraftFileReadback = z.infer<typeof TasksetDraftFileReadbackSchema>;
export type TasksetDraftDeletion = z.infer<typeof TasksetDraftDeletionSchema>;
//# sourceMappingURL=taskset-draft-api-contracts.d.ts.map