openpond-sdk 0.3.3 → 0.4.0

package/dist/types/packages/sdk/src/taskset-authored-contracts.d.ts

@@ -0,0 +1,1170 @@
+import { z } from "zod";
+import { type TasksetSourceRef, type TrainingSourceRef } from "./taskset-draft-core.js";
+export declare const TASKSET_WORK_TOOL_NAMES: readonly ["work_capabilities", "work_environment", "work_list_files", "work_read_file", "work_read_document", "work_write_file", "work_write_docx", "work_edit_file", "work_delete_file", "work_exec", "work_save_output", "work_stop"];
+export declare const TasksetStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    archived: "archived";
+    ready: "ready";
+    draft: "draft";
+    awaiting_disclosure_approval: "awaiting_disclosure_approval";
+    awaiting_materialization_approval: "awaiting_materialization_approval";
+    materializing: "materializing";
+    validating: "validating";
+    needs_review: "needs_review";
+    baselining: "baselining";
+    blocked: "blocked";
+}>;
+export declare const DatasetBuildIntentSchema: z.ZodEnum<{
+    rubric: "rubric";
+    demonstrations: "demonstrations";
+    preferences: "preferences";
+    verifiable_reward: "verifiable_reward";
+    discovery: "discovery";
+}>;
+export declare const DatasetBuildSpecificationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"demonstrations">;
+    behavior: z.ZodString;
+    examples: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        response: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"preferences">;
+    preference: z.ZodString;
+    pairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        chosen: z.ZodString;
+        rejected: z.ZodString;
+        rationale: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"verifiable_reward">;
+    task: z.ZodString;
+    rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        points: z.ZodNumber;
+        condition: z.ZodString;
+    }, z.core.$strip>>>;
+    otherwisePoints: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"rubric">;
+    task: z.ZodString;
+    criteria: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+    positiveExample: z.ZodString;
+    negativeExample: z.ZodString;
+    boundaryExample: z.ZodString;
+}, z.core.$strip>], "kind">;
+export declare const GeneratedTaskFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    role: z.ZodEnum<{
+        environment: "environment";
+        verifier: "verifier";
+        fixture: "fixture";
+    }>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const TrainingPathRecommendationSchema: z.ZodObject<{
+    primaryMethod: z.ZodEnum<{
+        sft: "sft";
+        dpo: "dpo";
+        grpo: "grpo";
+        ppo: "ppo";
+        sdft: "sdft";
+        opsd: "opsd";
+        sdpo: "sdpo";
+    }>;
+    bootstrap: z.ZodNullable<z.ZodObject<{
+        method: z.ZodLiteral<"sft">;
+        purpose: z.ZodLiteral<"trajectory_bootstrap">;
+        demonstrationRefs: z.ZodArray<z.ZodString>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TrainingMethodReadinessReasonCodeSchema: z.ZodEnum<{
+    taskset_not_ready: "taskset_not_ready";
+    demonstrations_missing: "demonstrations_missing";
+    preference_pairs_missing: "preference_pairs_missing";
+    preference_pairs_invalid: "preference_pairs_invalid";
+    executable_reward_missing: "executable_reward_missing";
+    reward_not_calibrated: "reward_not_calibrated";
+    reward_model_missing: "reward_model_missing";
+    value_model_required: "value_model_required";
+    frozen_eval_missing: "frozen_eval_missing";
+}>;
+export declare const TrainingMethodReadinessSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        sft: "sft";
+        dpo: "dpo";
+        grpo: "grpo";
+        ppo: "ppo";
+    }>;
+    status: z.ZodEnum<{
+        recommended: "recommended";
+        compatible: "compatible";
+        needs_dataset_work: "needs_dataset_work";
+    }>;
+    reasonCodes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        taskset_not_ready: "taskset_not_ready";
+        demonstrations_missing: "demonstrations_missing";
+        preference_pairs_missing: "preference_pairs_missing";
+        preference_pairs_invalid: "preference_pairs_invalid";
+        executable_reward_missing: "executable_reward_missing";
+        reward_not_calibrated: "reward_not_calibrated";
+        reward_model_missing: "reward_model_missing";
+        value_model_required: "value_model_required";
+        frozen_eval_missing: "frozen_eval_missing";
+    }>>>;
+    reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const TasksetReadinessFindingSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const TasksetReadinessReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.tasksetReadiness.v1">;
+    tasksetId: z.ZodString;
+    tasksetHash: z.ZodString;
+    ready: z.ZodBoolean;
+    recommendedMethod: z.ZodEnum<{
+        none: "none";
+        sft: "sft";
+        dpo: "dpo";
+        grpo: "grpo";
+        ppo: "ppo";
+        sdft: "sdft";
+        opd: "opd";
+        opsd: "opsd";
+        sdpo: "sdpo";
+        retrieval: "retrieval";
+    }>;
+    trainingPath: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        primaryMethod: z.ZodEnum<{
+            sft: "sft";
+            dpo: "dpo";
+            grpo: "grpo";
+            ppo: "ppo";
+            sdft: "sdft";
+            opsd: "opsd";
+            sdpo: "sdpo";
+        }>;
+        bootstrap: z.ZodNullable<z.ZodObject<{
+            method: z.ZodLiteral<"sft">;
+            purpose: z.ZodLiteral<"trajectory_bootstrap">;
+            demonstrationRefs: z.ZodArray<z.ZodString>;
+            limitations: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    methodReadiness: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        method: z.ZodEnum<{
+            sft: "sft";
+            dpo: "dpo";
+            grpo: "grpo";
+            ppo: "ppo";
+        }>;
+        status: z.ZodEnum<{
+            recommended: "recommended";
+            compatible: "compatible";
+            needs_dataset_work: "needs_dataset_work";
+        }>;
+        reasonCodes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            taskset_not_ready: "taskset_not_ready";
+            demonstrations_missing: "demonstrations_missing";
+            preference_pairs_missing: "preference_pairs_missing";
+            preference_pairs_invalid: "preference_pairs_invalid";
+            executable_reward_missing: "executable_reward_missing";
+            reward_not_calibrated: "reward_not_calibrated";
+            reward_model_missing: "reward_model_missing";
+            value_model_required: "value_model_required";
+            frozen_eval_missing: "frozen_eval_missing";
+        }>>>;
+        reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    compatibleDestinationClasses: z.ZodArray<z.ZodEnum<{
+        custom: "custom";
+        export: "export";
+        hosted_managed: "hosted_managed";
+    }>>;
+    blockers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    advisories: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    generatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const AuthoringRepairSchema: z.ZodObject<{
+    attempt: z.ZodNumber;
+    summary: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const AuthoringProvenanceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.taskAuthoringProvenance.v1">;
+    model: z.ZodNullable<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>>;
+    modelConfig: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    skillHash: z.ZodString;
+    promptTemplateVersion: z.ZodString;
+    buildIntent: z.ZodDefault<z.ZodEnum<{
+        rubric: "rubric";
+        demonstrations: "demonstrations";
+        preferences: "preferences";
+        verifiable_reward: "verifiable_reward";
+        discovery: "discovery";
+    }>>;
+    buildSpecification: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"demonstrations">;
+        behavior: z.ZodString;
+        examples: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            prompt: z.ZodString;
+            response: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"preferences">;
+        preference: z.ZodString;
+        pairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            prompt: z.ZodString;
+            chosen: z.ZodString;
+            rejected: z.ZodString;
+            rationale: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"verifiable_reward">;
+        task: z.ZodString;
+        rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            points: z.ZodNumber;
+            condition: z.ZodString;
+        }, z.core.$strip>>>;
+        otherwisePoints: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"rubric">;
+        task: z.ZodString;
+        criteria: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>>;
+        positiveExample: z.ZodString;
+        negativeExample: z.ZodString;
+        boundaryExample: z.ZodString;
+    }, z.core.$strip>], "kind">>>;
+    evidenceHashes: z.ZodArray<z.ZodString>;
+    tasksetSdkVersion: z.ZodString;
+    sourceCommit: z.ZodNullable<z.ZodString>;
+    repairHistory: z.ZodArray<z.ZodObject<{
+        attempt: z.ZodNumber;
+        summary: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const TasksetSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.taskset.v1">;
+    id: z.ZodString;
+    revision: z.ZodDefault<z.ZodNumber>;
+    profileId: z.ZodString;
+    profileRelease: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>>;
+    createImproveRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    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<{
+        failed: "failed";
+        archived: "archived";
+        ready: "ready";
+        draft: "draft";
+        awaiting_disclosure_approval: "awaiting_disclosure_approval";
+        awaiting_materialization_approval: "awaiting_materialization_approval";
+        materializing: "materializing";
+        validating: "validating";
+        needs_review: "needs_review";
+        baselining: "baselining";
+        blocked: "blocked";
+    }>;
+    sourceRefs: 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>;
+    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.ZodOptional<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>>;
+    tasks: 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>;
+        sourceRefs: z.ZodArray<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>>;
+    }, z.core.$strip>>;
+    graders: 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.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>;
+    authoringProvenance: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.taskAuthoringProvenance.v1">;
+        model: z.ZodNullable<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>>;
+        modelConfig: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        skillHash: z.ZodString;
+        promptTemplateVersion: z.ZodString;
+        buildIntent: z.ZodDefault<z.ZodEnum<{
+            rubric: "rubric";
+            demonstrations: "demonstrations";
+            preferences: "preferences";
+            verifiable_reward: "verifiable_reward";
+            discovery: "discovery";
+        }>>;
+        buildSpecification: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"demonstrations">;
+            behavior: z.ZodString;
+            examples: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                prompt: z.ZodString;
+                response: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"preferences">;
+            preference: z.ZodString;
+            pairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                prompt: z.ZodString;
+                chosen: z.ZodString;
+                rejected: z.ZodString;
+                rationale: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"verifiable_reward">;
+            task: z.ZodString;
+            rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                points: z.ZodNumber;
+                condition: z.ZodString;
+            }, z.core.$strip>>>;
+            otherwisePoints: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"rubric">;
+            task: z.ZodString;
+            criteria: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strip>>>;
+            positiveExample: z.ZodString;
+            negativeExample: z.ZodString;
+            boundaryExample: z.ZodString;
+        }, z.core.$strip>], "kind">>>;
+        evidenceHashes: z.ZodArray<z.ZodString>;
+        tasksetSdkVersion: z.ZodString;
+        sourceCommit: z.ZodNullable<z.ZodString>;
+        repairHistory: z.ZodArray<z.ZodObject<{
+            attempt: z.ZodNumber;
+            summary: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strip>>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+    readiness: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.tasksetReadiness.v1">;
+        tasksetId: z.ZodString;
+        tasksetHash: z.ZodString;
+        ready: z.ZodBoolean;
+        recommendedMethod: z.ZodEnum<{
+            none: "none";
+            sft: "sft";
+            dpo: "dpo";
+            grpo: "grpo";
+            ppo: "ppo";
+            sdft: "sdft";
+            opd: "opd";
+            opsd: "opsd";
+            sdpo: "sdpo";
+            retrieval: "retrieval";
+        }>;
+        trainingPath: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            primaryMethod: z.ZodEnum<{
+                sft: "sft";
+                dpo: "dpo";
+                grpo: "grpo";
+                ppo: "ppo";
+                sdft: "sdft";
+                opsd: "opsd";
+                sdpo: "sdpo";
+            }>;
+            bootstrap: z.ZodNullable<z.ZodObject<{
+                method: z.ZodLiteral<"sft">;
+                purpose: z.ZodLiteral<"trajectory_bootstrap">;
+                demonstrationRefs: z.ZodArray<z.ZodString>;
+                limitations: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        methodReadiness: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            method: z.ZodEnum<{
+                sft: "sft";
+                dpo: "dpo";
+                grpo: "grpo";
+                ppo: "ppo";
+            }>;
+            status: z.ZodEnum<{
+                recommended: "recommended";
+                compatible: "compatible";
+                needs_dataset_work: "needs_dataset_work";
+            }>;
+            reasonCodes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                taskset_not_ready: "taskset_not_ready";
+                demonstrations_missing: "demonstrations_missing";
+                preference_pairs_missing: "preference_pairs_missing";
+                preference_pairs_invalid: "preference_pairs_invalid";
+                executable_reward_missing: "executable_reward_missing";
+                reward_not_calibrated: "reward_not_calibrated";
+                reward_model_missing: "reward_model_missing";
+                value_model_required: "value_model_required";
+                frozen_eval_missing: "frozen_eval_missing";
+            }>>>;
+            reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        compatibleDestinationClasses: z.ZodArray<z.ZodEnum<{
+            custom: "custom";
+            export: "export";
+            hosted_managed: "hosted_managed";
+        }>>;
+        blockers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            path: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        advisories: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            path: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        generatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    contentHash: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type DatasetBuildIntent = z.infer<typeof DatasetBuildIntentSchema>;
+export type DatasetBuildSpecification = z.infer<typeof DatasetBuildSpecificationSchema>;
+export type GeneratedTaskFile = z.infer<typeof GeneratedTaskFileSchema>;
+export type TrainingPathRecommendation = z.infer<typeof TrainingPathRecommendationSchema>;
+export type TrainingMethodReadinessReasonCode = z.infer<typeof TrainingMethodReadinessReasonCodeSchema>;
+export type TrainingMethodReadiness = z.infer<typeof TrainingMethodReadinessSchema>;
+export type TasksetReadinessReport = z.infer<typeof TasksetReadinessReportSchema>;
+export type AuthoringProvenance = z.infer<typeof AuthoringProvenanceSchema>;
+export type AuthoringRepair = z.infer<typeof AuthoringRepairSchema>;
+export type Taskset = z.infer<typeof TasksetSchema>;
+export declare function isTrainingSourceRef(source: TasksetSourceRef): source is TrainingSourceRef;
+//# sourceMappingURL=taskset-authored-contracts.d.ts.map