openpond-sdk 0.3.3 → 0.5.0

package/dist/types/packages/sdk/src/taskset-draft-document.d.ts

@@ -0,0 +1,846 @@
+import { z } from "zod";
+export declare const TaskDataDraftSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.taskData.v1">;
+    id: z.ZodString;
+    clusterKey: z.ZodString;
+    split: z.ZodEnum<{
+        train: "train";
+        validation: "validation";
+        test: "test";
+        frozen_eval: "frozen_eval";
+    }>;
+    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;
+        mediaType: z.ZodString;
+        sha256: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        split: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        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>>;
+        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>;
+export declare const TasksetDraftStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    validating: "validating";
+    needs_review: "needs_review";
+}>;
+export declare const TasksetDraftReviewPolicySchema: 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>;
+export declare const TasksetDraftOutputContractSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        text: "text";
+        structured_json: "structured_json";
+        artifacts: "artifacts";
+    }>;
+    jsonSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    renderer: z.ZodNullable<z.ZodObject<{
+        module: z.ZodString;
+        exportName: z.ZodString;
+        configRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TasksetDraftSchema: 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>;
+        }, 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<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        evaluationSplit: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        primaryMetric: z.ZodEnum<{
+            foreground_tokens: "foreground_tokens";
+            success_rate: "success_rate";
+            latency_ms: "latency_ms";
+            cost_usd: "cost_usd";
+        }>;
+        qualityGate: z.ZodEnum<{
+            none: "none";
+            non_regression: "non_regression";
+            all_pass: "all_pass";
+        }>;
+        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";
+        published: "published";
+        validating: "validating";
+        needs_review: "needs_review";
+    }>;
+    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<{
+                pending: "pending";
+                granted: "granted";
+                denied: "denied";
+                revoked: "revoked";
+            }>;
+            scope: z.ZodEnum<{
+                metadata_only: "metadata_only";
+                selected_turns: "selected_turns";
+                full_session: "full_session";
+            }>;
+            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<{
+            pending: "pending";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        piiScanStatus: z.ZodEnum<{
+            pending: "pending";
+            review: "review";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        licensingStatus: z.ZodEnum<{
+            pending: "pending";
+            review: "review";
+            approved: "approved";
+            blocked: "blocked";
+        }>;
+        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<{
+            pending: "pending";
+            review: "review";
+            approved: "approved";
+            blocked: "blocked";
+        }>;
+        secretScanStatus: z.ZodEnum<{
+            pending: "pending";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        piiScanStatus: z.ZodEnum<{
+            pending: "pending";
+            review: "review";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        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<{
+            pending: "pending";
+            review: "review";
+            approved: "approved";
+            blocked: "blocked";
+        }>;
+        secretScanStatus: z.ZodEnum<{
+            pending: "pending";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        piiScanStatus: z.ZodEnum<{
+            pending: "pending";
+            review: "review";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        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<{
+            pending: "pending";
+            review: "review";
+            approved: "approved";
+            blocked: "blocked";
+        }>;
+        secretScanStatus: z.ZodEnum<{
+            pending: "pending";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        piiScanStatus: z.ZodEnum<{
+            pending: "pending";
+            review: "review";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        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<{
+            pending: "pending";
+            review: "review";
+            approved: "approved";
+            blocked: "blocked";
+        }>;
+        secretScanStatus: z.ZodEnum<{
+            pending: "pending";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        piiScanStatus: z.ZodEnum<{
+            pending: "pending";
+            review: "review";
+            passed: "passed";
+            blocked: "blocked";
+        }>;
+        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">]>>>;
+    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<{
+                    metadata: "metadata";
+                    prompt: "prompt";
+                    reward: "reward";
+                    feedback: "feedback";
+                    rejected: "rejected";
+                    messages: "messages";
+                    row_id: "row_id";
+                    cluster_id: "cluster_id";
+                    demonstration: "demonstration";
+                    chosen: "chosen";
+                    expected_output: "expected_output";
+                    privileged_context: "privileged_context";
+                    tag: "tag";
+                }>;
+                logicalType: z.ZodEnum<{
+                    string: "string";
+                    boolean: "boolean";
+                    messages: "messages";
+                    integer: "integer";
+                    float: "float";
+                    json: "json";
+                }>;
+                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<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            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<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>, 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<{
+            work: "work";
+            agent: "agent";
+            chat: "chat";
+            program: "program";
+            stateful_harness: "stateful_harness";
+        }>;
+        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<{
+            none: "none";
+            declared_read_only: "declared_read_only";
+            declared_scoped: "declared_scoped";
+        }>;
+        resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                file: "file";
+                catalog: "catalog";
+                configuration: "configuration";
+                code_module: "code_module";
+            }>;
+            path: z.ZodString;
+            mediaType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            visibility: z.ZodEnum<{
+                privileged: "privileged";
+                policy_visible: "policy_visible";
+                policy_hidden: "policy_hidden";
+            }>;
+            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<{
+            text: "text";
+            structured_json: "structured_json";
+            artifacts: "artifacts";
+        }>;
+        jsonSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        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<{
+            custom_program: "custom_program";
+            chat: "chat";
+            single_agent: "single_agent";
+            multi_agent: "multi_agent";
+        }>;
+        supportedSignals: z.ZodArray<z.ZodEnum<{
+            label: "label";
+            reward: "reward";
+            feedback: "feedback";
+            preference: "preference";
+            demonstration: "demonstration";
+            correction: "correction";
+        }>>;
+        compatibleMethods: z.ZodArray<z.ZodEnum<{
+            none: "none";
+            sft: "sft";
+            dpo: "dpo";
+            grpo: "grpo";
+            ppo: "ppo";
+            sdft: "sdft";
+            opd: "opd";
+            opsd: "opsd";
+            sdpo: "sdpo";
+            retrieval: "retrieval";
+        }>>;
+        rewardKinds: z.ZodArray<z.ZodEnum<{
+            none: "none";
+            model_judge: "model_judge";
+            human: "human";
+            deterministic: "deterministic";
+            exact: "exact";
+        }>>;
+        requiresTools: z.ZodBoolean;
+        requiresState: z.ZodBoolean;
+        requiresPrivilegedGrading: z.ZodBoolean;
+        environmentPlacements: z.ZodArray<z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+            colocated: "colocated";
+            provider_native: "provider_native";
+        }>>;
+        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<{
+            mean_score: "mean_score";
+            pass_rate: "pass_rate";
+            weighted_mean: "weighted_mean";
+            custom: "custom";
+        }>;
+        missingReward: z.ZodEnum<{
+            zero: "zero";
+            exclude: "exclude";
+        }>;
+        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<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        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;
+            mediaType: z.ZodString;
+            sha256: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            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>>;
+            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;
+        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<{
+            file: "file";
+            state: "state";
+            test: "test";
+            content: "content";
+            schema: "schema";
+            runtime_event: "runtime_event";
+            diff: "diff";
+        }>;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: 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.ZodEnum<{
+                openpond: "openpond";
+                codex: "codex";
+                anthropic: "anthropic";
+                openai: "openai";
+                xai: "xai";
+                google: "google";
+                openrouter: "openrouter";
+                deepseek: "deepseek";
+                zai: "zai";
+                moonshot: "moonshot";
+                together: "together";
+                groq: "groq";
+                "custom-openai-compatible": "custom-openai-compatible";
+            }>;
+            modelId: z.ZodString;
+        }, z.core.$strip>;
+        calibrationFixtureRefs: z.ZodArray<z.ZodString>;
+        calibrationStatus: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            passed: "passed";
+        }>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: 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">;
+        rubric: z.ZodString;
+        reviewerRole: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: 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">;
+        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<{
+            infrastructure_failure: "infrastructure_failure";
+            positive: "positive";
+            negative: "negative";
+            boundary: "boundary";
+            adversarial: "adversarial";
+            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<{
+                neutral: "neutral";
+                positive: "positive";
+                negative: "negative";
+                mixed: "mixed";
+            }>;
+        }, 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>;
+export type TaskDataDraft = z.infer<typeof TaskDataDraftSchema>;
+export type TasksetDraftStatus = z.infer<typeof TasksetDraftStatusSchema>;
+export type TasksetDraftReviewPolicy = z.infer<typeof TasksetDraftReviewPolicySchema>;
+export type TasksetDraftOutputContract = z.infer<typeof TasksetDraftOutputContractSchema>;
+export type TasksetDraft = z.infer<typeof TasksetDraftSchema>;
+//# sourceMappingURL=taskset-draft-document.d.ts.map