openpond-sdk 0.3.2 → 0.4.0

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

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