export { SftRecipeSchema, ManagedSftRecipeSchema, type SftRecipe } from "./training-supervised.js";
export { TrainingApiErrorSchema, OpenPondTrainingApiError } from "./training-transport.js";
export { HardwareObservationSchema, HardwareFleetSnapshotSchema, HardwareAvailabilitySchema, HardwareGpuObservationSchema, type HardwareObservation, type HardwareFleetSnapshot, type HardwareObservationQuery } from "./training-hardware.js";
export { TrainingAcceptanceGroupReferenceSchema, TrainingAcceptanceGroupSummarySchema, TrainingAcceptanceGroupPageSchema, TrainingAcceptanceGroupQuerySchema, type TrainingAcceptanceGroupReference, type TrainingAcceptanceGroupSummary, type TrainingAcceptanceGroupPage, type TrainingAcceptanceGroupQuery, type TrainingAcceptanceTarget, } from "./training-acceptance.js";
import { z } from "zod";
import { TrainingCheckpointRecoveryRequestSchema } from "./training-recovery.js";
export { TrainingCheckpointRecoveryRequestSchema, TrainingCheckpointRecoveryResourceApprovalSchema, createTrainingCheckpointRecoveryResourceApproval } from "./training-recovery.js";
export { TrainingPhysicalPlacementSchema, type TrainingPhysicalPlacement } from "./training-physical-placement.js";
export { TrainingGpuCatalogSchema, type TrainingGpuCatalog } from "./training-compute-selection.js";
export { TrainingQueueStatusSchema, type TrainingQueueStatus } from "./training-queue.js";
export { TrainingGpuSelectionSchema, TrainingEstimateSourceSchema, TrainingEstimateRequestSchema, TrainingEstimateComponentSchema, TrainingEstimateReviewSchema, TrainingEstimateSchema, trainingEstimateSourceIdentity, type TrainingGpuSelection, type TrainingEstimateRequest, type TrainingEstimate, type TrainingEstimateReview, } from "./training-estimates.js";
export { TrainingPreparationRequestSchema, TrainingPreparationPlanContentSchema, TrainingPreparationPlanSchema, TrainingPreparationReceiptSchema, TrainingPreparationControlSchema, parseAndVerifyTrainingPreparationReceipt, type TrainingPreparationRequest, type TrainingPreparationPlan, type TrainingPreparationReceipt, type TrainingPreparationControl, } from "./training-preparations.js";
export { TrainingPreparationListQuerySchema, TrainingPreparationPageSchema, type TrainingPreparationListQuery, type TrainingPreparationPage, } from "./training-preparations.js";
export { TrainingHarnessSourcePublicationSchema } from "./training-harness-sources.js";
export { TrainingCandidateDecisionRequestSchema, TrainingCandidateDecisionSchema, trainingCandidateDecisionHash, parseAndVerifyTrainingCandidateDecision, type TrainingCandidateDecisionRequest, type TrainingCandidateDecision, type TrainingCandidateDecisionTarget, } from "./training-candidate-decisions.js";
export { deterministicTrainingRewardSource } from "./training-grading-plan.js";
export { TRAINING_EVALUATION_SOURCE_PATH, TrainingEvaluationSourceSchema, assertTrainingEvaluationIsolation, trainingEvaluationSourceRef, type TrainingEvaluationSource, } from "./training-evaluation-source.js";
export { TrainingEvaluationTaskResultSchema, TrainingEvaluationTaskPageSchema, trainingEvaluationTaskPageHash, parseAndVerifyTrainingEvaluationTaskPage, type TrainingEvaluationTaskResult, type TrainingEvaluationTaskPage, } from "./training-evaluation-results.js";
import { ModelProjectBaseModelSchema } from "./model-projects.js";
export { OPENPOND_TRAINING_MEDIA_TYPE, OPENPOND_TRAINING_PROTOCOL_MAJOR, TRAINING_API_RESPONSE_MAX_BYTES, TRAINING_INPUT_ARTIFACT_MAX_BYTES, TRAINING_JOB_SUBMISSION_MAX_BYTES, OpenPondProtocolError, assertCanonicalPayloadSize, canonicalJson, canonicalJsonByteLength, canonicalSha256, parseBoundedJson, } from "./protocol.js";
/**
 * Stages a content-addressed immutable input before Job admission. The payload
 * is deliberately opaque to the transport contract: its declared kind owns
 * the executable schema, while the envelope provides bounded bytes,
 * idempotency, and a stable manifest lookup key.
 */
export declare const TrainingInputArtifactUploadSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingInputArtifactUpload.v2">;
    kind: z.ZodEnum<{
        portable_training_bundle: "portable_training_bundle";
        reward_model_dataset: "reward_model_dataset";
    }>;
    idempotencyKey: z.ZodString;
    sourceManifest: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    payload: z.ZodUnknown;
    contentHash: z.ZodString;
}, z.core.$strict>;
export declare const TrainingInputArtifactSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingInputArtifact.v2">;
    kind: z.ZodEnum<{
        portable_training_bundle: "portable_training_bundle";
        reward_model_dataset: "reward_model_dataset";
    }>;
    sourceManifest: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    artifactRef: z.ZodString;
    contentHash: z.ZodString;
    sizeBytes: z.ZodNumber;
    createdAt: z.ZodString;
}, z.core.$strict>;
export declare function trainingInputArtifactUploadHash(upload: Omit<TrainingInputArtifactUpload, "contentHash"> | TrainingInputArtifactUpload): Promise<string>;
export declare function parseAndVerifyTrainingInputArtifactUpload(value: unknown): Promise<TrainingInputArtifactUpload>;
export declare const TrainingJobKindSchema: z.ZodEnum<{
    policy_optimize: "policy_optimize";
    reward_model_train: "reward_model_train";
}>;
export declare const TrainingJobStateSchema: z.ZodEnum<{
    admitting: "admitting";
    cancelled: "cancelled";
    cancelling: "cancelling";
    failed: "failed";
    provisioning: "provisioning";
    queued: "queued";
    running: "running";
    stopping: "stopping";
    succeeded: "succeeded";
}>;
export declare const TrainingCapabilityRequirementSchema: z.ZodObject<{
    id: z.ZodString;
    version: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    required: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strict>;
export declare const TrainingJobSourceSchema: z.ZodObject<{
    origin: z.ZodOptional<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.trainingHandoffOrigin.v1">;
        teamId: z.ZodString;
        projectId: z.ZodNullable<z.ZodString>;
        configurationId: z.ZodString;
        source: z.ZodObject<{
            executionId: z.ZodString;
            passId: z.ZodNullable<z.ZodString>;
            manifestHash: z.ZodString;
            resultHash: z.ZodString;
        }, z.core.$strict>;
        dataset: z.ZodObject<{
            id: z.ZodString;
            revision: z.ZodNumber;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"model">;
            modelId: z.ZodString;
            configurationHash: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"harness">;
            source: z.ZodObject<{
                profileId: z.ZodString;
                sourceRevision: z.ZodString;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                catalogHash: z.ZodString;
                definitionId: z.ZodString;
                definitionHash: z.ZodString;
                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"profile">;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"workflow">;
                    workflowId: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"skill">;
                    skillPath: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"agent_action">;
                    actionId: z.ZodString;
                }, z.core.$strict>], "kind">;
                environmentHash: z.ZodString;
                externalDatasetBinding: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
                    dataset: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                        revision: z.ZodNumber;
                    }, z.core.$strict>;
                    packageHash: z.ZodString;
                    profileId: z.ZodString;
                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                        kind: z.ZodLiteral<"profile">;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"workflow">;
                        workflowId: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"skill">;
                        skillPath: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"agent_action">;
                        actionId: z.ZodString;
                    }, z.core.$strict>], "kind">;
                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
                    protectedProfileClosureHash: z.ZodString;
                    recordedOrigin: z.ZodOptional<z.ZodObject<{
                        execution: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        originalEvidence: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        members: z.ZodArray<z.ZodObject<{
                            caseId: z.ZodString;
                            seed: z.ZodString;
                            fixtureId: z.ZodString;
                            sourceId: z.ZodString;
                            snapshotHash: z.ZodString;
                            boundaryRevisionHash: z.ZodString;
                        }, z.core.$strict>>;
                    }, z.core.$strict>>;
                    gradingSource: z.ZodOptional<z.ZodObject<{
                        pass: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        evidence: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                    }, z.core.$strict>>;
                    split: z.ZodEnum<{
                        frozen_eval: "frozen_eval";
                        test: "test";
                        train: "train";
                        validation: "validation";
                    }>;
                    population: z.ZodArray<z.ZodObject<{
                        taskId: z.ZodString;
                        seed: z.ZodString;
                        fixtureId: z.ZodNullable<z.ZodString>;
                    }, z.core.$strict>>;
                    evaluators: z.ZodArray<z.ZodObject<{
                        release: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
                        }, z.core.$strict>;
                        feedbackKey: z.ZodString;
                        configurationHash: z.ZodString;
                        output: z.ZodEnum<{
                            boolean: "boolean";
                            category: "category";
                            score: "score";
                        }>;
                        categories: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>>;
                    fieldMappingsHash: z.ZodString;
                    fieldMappings: z.ZodArray<z.ZodObject<{
                        graderId: z.ZodString;
                        fields: z.ZodArray<z.ZodObject<{
                            destination: z.ZodEnum<{
                                evaluatorContext: "evaluatorContext";
                                expectedOutput: "expectedOutput";
                                input: "input";
                                output: "output";
                            }>;
                            path: z.ZodArray<z.ZodString>;
                            source: z.ZodEnum<{
                                evaluatorContext: "evaluatorContext";
                                expectedOutput: "expectedOutput";
                                input: "input";
                                output: "output";
                            }>;
                            sourcePath: z.ZodArray<z.ZodString>;
                        }, z.core.$strict>>;
                    }, z.core.$strict>>;
                    environmentHash: z.ZodString;
                    privateDatasetClosureHash: z.ZodString;
                    criterion: z.ZodObject<{
                        minimumPassRate: z.ZodNumber;
                        requireComplete: z.ZodBoolean;
                    }, z.core.$strict>;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                sourceCandidate: z.ZodOptional<z.ZodObject<{
                    candidateId: z.ZodString;
                    frozenRevision: z.ZodNumber;
                    frozenHash: z.ZodString;
                    harnessRelease: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    protectedClosureHash: z.ZodString;
                }, z.core.$strict>>;
            }, z.core.$strict>;
            model: z.ZodObject<{
                modelId: z.ZodString;
                configurationHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"agent">;
            source: z.ZodObject<{
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                agentSnapshot: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                sourcePackageHash: z.ZodString;
            }, z.core.$strict>;
            model: z.ZodObject<{
                modelId: z.ZodString;
                configurationHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"fixture">;
            configurationHash: z.ZodString;
        }, z.core.$strict>], "kind">;
        graders: z.ZodArray<z.ZodObject<{
            feedbackKey: z.ZodString;
            evaluator: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            expectedCount: z.ZodNumber;
            scoredCount: z.ZodNumber;
            score: z.ZodNullable<z.ZodNumber>;
        }, z.core.$strict>>;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    modelProject: z.ZodObject<{
        id: z.ZodString;
        portableProjectId: z.ZodString;
        revision: z.ZodNumber;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    harnessRunManifest: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    harnessRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    taskset: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    tasksetRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    evaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        taskset: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        dataset: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>>>;
    dataset: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    evidenceSets: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const RewardModelTrainingRequestSchema: z.ZodObject<{
    kind: z.ZodLiteral<"reward_model_train">;
    baseModel: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
        modelId: z.ZodString;
        revision: z.ZodNullable<z.ZodString>;
        tokenizerRevision: z.ZodNullable<z.ZodString>;
        chatTemplateHash: z.ZodNullable<z.ZodString>;
        modelAssetId: z.ZodNullable<z.ZodString>;
        source: z.ZodEnum<{
            builtin: "builtin";
            local: "local";
            managed: "managed";
        }>;
    }, z.core.$strict>;
    preferenceDatasetRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    processorRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    recipe: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.rewardModelRecipe.v1">;
        method: z.ZodLiteral<"reward_model">;
        parameterization: z.ZodLiteral<"lora_with_scalar_head">;
    }, z.core.$catchall<z.ZodUnknown>>;
}, z.core.$strict>;
export declare const TrainingQualificationBaseModelSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
    modelId: z.ZodString;
    modelAssetId: z.ZodNullable<z.ZodString>;
    source: z.ZodEnum<{
        builtin: "builtin";
        local: "local";
        managed: "managed";
    }>;
    revision: z.ZodString;
    tokenizerRevision: z.ZodString;
    chatTemplateHash: z.ZodString;
}, z.core.$strict>;
export declare const PolicyOptimizationRequestSchema: z.ZodObject<{
    kind: z.ZodLiteral<"policy_optimize">;
    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
    baseModel: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
        modelId: z.ZodString;
        revision: z.ZodNullable<z.ZodString>;
        tokenizerRevision: z.ZodNullable<z.ZodString>;
        chatTemplateHash: z.ZodNullable<z.ZodString>;
        modelAssetId: z.ZodNullable<z.ZodString>;
        source: z.ZodEnum<{
            builtin: "builtin";
            local: "local";
            managed: "managed";
        }>;
    }, z.core.$strict>;
    recipe: z.ZodObject<{
        schemaVersion: z.ZodString;
        method: z.ZodEnum<{
            dpo: "dpo";
            grpo: "grpo";
            opd: "opd";
            opsd: "opsd";
            ppo: "ppo";
            sdft: "sdft";
            sdpo: "sdpo";
            sft: "sft";
        }>;
        parameterization: z.ZodEnum<{
            full: "full";
            lora: "lora";
        }>;
    }, z.core.$catchall<z.ZodUnknown>>;
    rewardSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"deterministic">;
        grader: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        composer: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"learned_reward">;
        rewardModelVersion: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        qualificationReport: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
        evaluationReferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
        scorerArtifact: z.ZodObject<{
            artifactRef: z.ZodString;
            contentHash: z.ZodString;
            executionReceipt: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>;
        processorRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        rewardComposerRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>], "kind">;
    resumeFrom: z.ZodDefault<z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>>;
}, z.core.$strict>;
export declare const TrainingJobRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    kind: z.ZodLiteral<"reward_model_train">;
    baseModel: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
        modelId: z.ZodString;
        revision: z.ZodNullable<z.ZodString>;
        tokenizerRevision: z.ZodNullable<z.ZodString>;
        chatTemplateHash: z.ZodNullable<z.ZodString>;
        modelAssetId: z.ZodNullable<z.ZodString>;
        source: z.ZodEnum<{
            builtin: "builtin";
            local: "local";
            managed: "managed";
        }>;
    }, z.core.$strict>;
    preferenceDatasetRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    processorRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    recipe: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.rewardModelRecipe.v1">;
        method: z.ZodLiteral<"reward_model">;
        parameterization: z.ZodLiteral<"lora_with_scalar_head">;
    }, z.core.$catchall<z.ZodUnknown>>;
}, z.core.$strict>, z.ZodObject<{
    kind: z.ZodLiteral<"policy_optimize">;
    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
    baseModel: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
        modelId: z.ZodString;
        revision: z.ZodNullable<z.ZodString>;
        tokenizerRevision: z.ZodNullable<z.ZodString>;
        chatTemplateHash: z.ZodNullable<z.ZodString>;
        modelAssetId: z.ZodNullable<z.ZodString>;
        source: z.ZodEnum<{
            builtin: "builtin";
            local: "local";
            managed: "managed";
        }>;
    }, z.core.$strict>;
    recipe: z.ZodObject<{
        schemaVersion: z.ZodString;
        method: z.ZodEnum<{
            dpo: "dpo";
            grpo: "grpo";
            opd: "opd";
            opsd: "opsd";
            ppo: "ppo";
            sdft: "sdft";
            sdpo: "sdpo";
            sft: "sft";
        }>;
        parameterization: z.ZodEnum<{
            full: "full";
            lora: "lora";
        }>;
    }, z.core.$catchall<z.ZodUnknown>>;
    rewardSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"deterministic">;
        grader: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        composer: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"learned_reward">;
        rewardModelVersion: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        qualificationReport: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
        evaluationReferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
        scorerArtifact: z.ZodObject<{
            artifactRef: z.ZodString;
            contentHash: z.ZodString;
            executionReceipt: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>;
        processorRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        rewardComposerRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>], "kind">;
    resumeFrom: z.ZodDefault<z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>>;
}, z.core.$strict>], "kind">;
export declare const TrainingJobApprovalSchema: z.ZodObject<{
    approvalHash: z.ZodString;
    approvedAt: z.ZodString;
    exportApproved: z.ZodBoolean;
    maximumSpendUsd: z.ZodNumber;
    retentionDays: z.ZodNullable<z.ZodNumber>;
    region: z.ZodDefault<z.ZodNullable<z.ZodString>>;
}, z.core.$strict>;
export declare const TrainingJobSubmissionSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingJobSubmission.v2">;
    idempotencyKey: z.ZodString;
    name: z.ZodString;
    source: z.ZodObject<{
        origin: z.ZodOptional<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.trainingHandoffOrigin.v1">;
            teamId: z.ZodString;
            projectId: z.ZodNullable<z.ZodString>;
            configurationId: z.ZodString;
            source: z.ZodObject<{
                executionId: z.ZodString;
                passId: z.ZodNullable<z.ZodString>;
                manifestHash: z.ZodString;
                resultHash: z.ZodString;
            }, z.core.$strict>;
            dataset: z.ZodObject<{
                id: z.ZodString;
                revision: z.ZodNumber;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"model">;
                modelId: z.ZodString;
                configurationHash: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"harness">;
                source: z.ZodObject<{
                    profileId: z.ZodString;
                    sourceRevision: z.ZodString;
                    harnessRelease: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    catalogHash: z.ZodString;
                    definitionId: z.ZodString;
                    definitionHash: z.ZodString;
                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                        kind: z.ZodLiteral<"profile">;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"workflow">;
                        workflowId: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"skill">;
                        skillPath: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"agent_action">;
                        actionId: z.ZodString;
                    }, z.core.$strict>], "kind">;
                    environmentHash: z.ZodString;
                    externalDatasetBinding: z.ZodOptional<z.ZodObject<{
                        schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
                        dataset: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                            revision: z.ZodNumber;
                        }, z.core.$strict>;
                        packageHash: z.ZodString;
                        profileId: z.ZodString;
                        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                            kind: z.ZodLiteral<"profile">;
                        }, z.core.$strict>, z.ZodObject<{
                            kind: z.ZodLiteral<"workflow">;
                            workflowId: z.ZodString;
                        }, z.core.$strict>, z.ZodObject<{
                            kind: z.ZodLiteral<"skill">;
                            skillPath: z.ZodString;
                        }, z.core.$strict>, z.ZodObject<{
                            kind: z.ZodLiteral<"agent_action">;
                            actionId: z.ZodString;
                        }, z.core.$strict>], "kind">;
                        declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
                        protectedProfileClosureHash: z.ZodString;
                        recordedOrigin: z.ZodOptional<z.ZodObject<{
                            execution: z.ZodObject<{
                                id: z.ZodString;
                                contentHash: z.ZodString;
                            }, z.core.$strict>;
                            originalEvidence: z.ZodObject<{
                                id: z.ZodString;
                                contentHash: z.ZodString;
                            }, z.core.$strict>;
                            members: z.ZodArray<z.ZodObject<{
                                caseId: z.ZodString;
                                seed: z.ZodString;
                                fixtureId: z.ZodString;
                                sourceId: z.ZodString;
                                snapshotHash: z.ZodString;
                                boundaryRevisionHash: z.ZodString;
                            }, z.core.$strict>>;
                        }, z.core.$strict>>;
                        gradingSource: z.ZodOptional<z.ZodObject<{
                            pass: z.ZodObject<{
                                id: z.ZodString;
                                contentHash: z.ZodString;
                            }, z.core.$strict>;
                            evidence: z.ZodObject<{
                                id: z.ZodString;
                                contentHash: z.ZodString;
                            }, z.core.$strict>;
                        }, z.core.$strict>>;
                        split: z.ZodEnum<{
                            frozen_eval: "frozen_eval";
                            test: "test";
                            train: "train";
                            validation: "validation";
                        }>;
                        population: z.ZodArray<z.ZodObject<{
                            taskId: z.ZodString;
                            seed: z.ZodString;
                            fixtureId: z.ZodNullable<z.ZodString>;
                        }, z.core.$strict>>;
                        evaluators: z.ZodArray<z.ZodObject<{
                            release: z.ZodObject<{
                                id: z.ZodString;
                                contentHash: z.ZodString;
                                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
                            }, z.core.$strict>;
                            feedbackKey: z.ZodString;
                            configurationHash: z.ZodString;
                            output: z.ZodEnum<{
                                boolean: "boolean";
                                category: "category";
                                score: "score";
                            }>;
                            categories: z.ZodArray<z.ZodString>;
                        }, z.core.$strict>>;
                        fieldMappingsHash: z.ZodString;
                        fieldMappings: z.ZodArray<z.ZodObject<{
                            graderId: z.ZodString;
                            fields: z.ZodArray<z.ZodObject<{
                                destination: z.ZodEnum<{
                                    evaluatorContext: "evaluatorContext";
                                    expectedOutput: "expectedOutput";
                                    input: "input";
                                    output: "output";
                                }>;
                                path: z.ZodArray<z.ZodString>;
                                source: z.ZodEnum<{
                                    evaluatorContext: "evaluatorContext";
                                    expectedOutput: "expectedOutput";
                                    input: "input";
                                    output: "output";
                                }>;
                                sourcePath: z.ZodArray<z.ZodString>;
                            }, z.core.$strict>>;
                        }, z.core.$strict>>;
                        environmentHash: z.ZodString;
                        privateDatasetClosureHash: z.ZodString;
                        criterion: z.ZodObject<{
                            minimumPassRate: z.ZodNumber;
                            requireComplete: z.ZodBoolean;
                        }, z.core.$strict>;
                        contentHash: z.ZodString;
                    }, z.core.$strict>>;
                    sourceCandidate: z.ZodOptional<z.ZodObject<{
                        candidateId: z.ZodString;
                        frozenRevision: z.ZodNumber;
                        frozenHash: z.ZodString;
                        harnessRelease: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        protectedClosureHash: z.ZodString;
                    }, z.core.$strict>>;
                }, z.core.$strict>;
                model: z.ZodObject<{
                    modelId: z.ZodString;
                    configurationHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"agent">;
                source: z.ZodObject<{
                    harnessRelease: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    agentSnapshot: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    sourcePackageHash: z.ZodString;
                }, z.core.$strict>;
                model: z.ZodObject<{
                    modelId: z.ZodString;
                    configurationHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fixture">;
                configurationHash: z.ZodString;
            }, z.core.$strict>], "kind">;
            graders: z.ZodArray<z.ZodObject<{
                feedbackKey: z.ZodString;
                evaluator: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                expectedCount: z.ZodNumber;
                scoredCount: z.ZodNumber;
                score: z.ZodNullable<z.ZodNumber>;
            }, z.core.$strict>>;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        modelProject: z.ZodObject<{
            id: z.ZodString;
            portableProjectId: z.ZodString;
            revision: z.ZodNumber;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        harnessRunManifest: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        harnessRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        taskset: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        tasksetRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        evaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            taskset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            dataset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>>;
        dataset: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        evidenceSets: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    job: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"reward_model_train">;
        baseModel: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
            modelId: z.ZodString;
            revision: z.ZodNullable<z.ZodString>;
            tokenizerRevision: z.ZodNullable<z.ZodString>;
            chatTemplateHash: z.ZodNullable<z.ZodString>;
            modelAssetId: z.ZodNullable<z.ZodString>;
            source: z.ZodEnum<{
                builtin: "builtin";
                local: "local";
                managed: "managed";
            }>;
        }, z.core.$strict>;
        preferenceDatasetRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        processorRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        recipe: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.rewardModelRecipe.v1">;
            method: z.ZodLiteral<"reward_model">;
            parameterization: z.ZodLiteral<"lora_with_scalar_head">;
        }, z.core.$catchall<z.ZodUnknown>>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"policy_optimize">;
        executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
        baseModel: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
            modelId: z.ZodString;
            revision: z.ZodNullable<z.ZodString>;
            tokenizerRevision: z.ZodNullable<z.ZodString>;
            chatTemplateHash: z.ZodNullable<z.ZodString>;
            modelAssetId: z.ZodNullable<z.ZodString>;
            source: z.ZodEnum<{
                builtin: "builtin";
                local: "local";
                managed: "managed";
            }>;
        }, z.core.$strict>;
        recipe: z.ZodObject<{
            schemaVersion: z.ZodString;
            method: z.ZodEnum<{
                dpo: "dpo";
                grpo: "grpo";
                opd: "opd";
                opsd: "opsd";
                ppo: "ppo";
                sdft: "sdft";
                sdpo: "sdpo";
                sft: "sft";
            }>;
            parameterization: z.ZodEnum<{
                full: "full";
                lora: "lora";
            }>;
        }, z.core.$catchall<z.ZodUnknown>>;
        rewardSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"deterministic">;
            grader: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            composer: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>>;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"learned_reward">;
            rewardModelVersion: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            qualificationReport: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>>;
            evaluationReferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>>;
            scorerArtifact: z.ZodObject<{
                artifactRef: z.ZodString;
                contentHash: z.ZodString;
                executionReceipt: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>;
            processorRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            rewardComposerRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>], "kind">;
        resumeFrom: z.ZodDefault<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>>;
    }, z.core.$strict>], "kind">;
    requestedCapabilities: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        version: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        required: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strict>>;
    placementObjective: z.ZodEnum<{
        balanced: "balanced";
        economical: "economical";
        fast: "fast";
    }>;
    gpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        mode: z.ZodLiteral<"automatic">;
        objective: z.ZodEnum<{
            balanced: "balanced";
            economical: "economical";
            fast: "fast";
        }>;
        gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
    }, z.core.$strict>, z.ZodObject<{
        mode: z.ZodLiteral<"manual">;
        availabilityId: z.ZodString;
        gpuType: z.ZodString;
        gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
    }, z.core.$strict>], "mode">>;
    physicalPlacement: z.ZodOptional<z.ZodObject<{
        mode: z.ZodLiteral<"reuse_only">;
        physicalWorkerId: z.ZodString;
        providerPodId: z.ZodString;
        workerImageDigest: z.ZodString;
        baseProfileSha256: z.ZodString;
        gpuType: z.ZodString;
        sourceJobId: z.ZodString;
        sourceInputManifestSha256: z.ZodString;
        ownerTeamId: z.ZodString;
        deadlineAt: z.ZodString;
    }, z.core.$strict>>;
    budget: z.ZodObject<{
        maximumSpendUsd: z.ZodNumber;
        maximumWallSeconds: z.ZodNumber;
    }, z.core.$strict>;
    approval: z.ZodObject<{
        approvalHash: z.ZodString;
        approvedAt: z.ZodString;
        exportApproved: z.ZodBoolean;
        maximumSpendUsd: z.ZodNumber;
        retentionDays: z.ZodNullable<z.ZodNumber>;
        region: z.ZodDefault<z.ZodNullable<z.ZodString>>;
    }, z.core.$strict>;
    contentHash: z.ZodString;
}, z.core.$strict>;
export declare function trainingJobSubmissionHash(submission: Omit<TrainingJobSubmission, "contentHash"> | TrainingJobSubmission): Promise<string>;
export declare function parseAndVerifyTrainingJobSubmission(value: unknown): Promise<TrainingJobSubmission>;
export declare const TrainingJobRecoverySchema: z.ZodObject<{
    resourceApproval: z.ZodOptional<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.checkpointRecoveryResourceApproval.v1">;
        ownerUserId: z.ZodString;
        teamId: z.ZodString;
        sourceJobId: z.ZodString;
        sourceJobVersion: z.ZodNumber;
        sourceInputManifestSha256: z.ZodString;
        checkpointId: z.ZodString;
        adapterSha256: z.ZodString;
        resumeSha256: z.ZodString;
        idempotencyKey: z.ZodString;
        approvedAt: z.ZodISODateTime;
        maximumSpendUsd: z.ZodNumber;
        maximumGpuSeconds: z.ZodNumber;
        maximumWallSeconds: z.ZodNumber;
        approvalHash: z.ZodString;
    }, z.core.$strict>>;
    mode: z.ZodOptional<z.ZodLiteral<"evaluation_only">>;
    trainingWorkloadComplete: z.ZodOptional<z.ZodBoolean>;
    sourceJobId: z.ZodString;
    checkpointId: z.ZodString;
    policyVersion: z.ZodNumber;
    completedGroups: z.ZodNumber;
    optimizerMode: z.ZodLiteral<"continue">;
}, z.core.$strict>;
export declare const TrainingJobSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingJob.v2">;
    id: z.ZodString;
    teamId: z.ZodString;
    kind: z.ZodEnum<{
        policy_optimize: "policy_optimize";
        reward_model_train: "reward_model_train";
    }>;
    executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
    recovery: z.ZodOptional<z.ZodObject<{
        resourceApproval: z.ZodOptional<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.checkpointRecoveryResourceApproval.v1">;
            ownerUserId: z.ZodString;
            teamId: z.ZodString;
            sourceJobId: z.ZodString;
            sourceJobVersion: z.ZodNumber;
            sourceInputManifestSha256: z.ZodString;
            checkpointId: z.ZodString;
            adapterSha256: z.ZodString;
            resumeSha256: z.ZodString;
            idempotencyKey: z.ZodString;
            approvedAt: z.ZodISODateTime;
            maximumSpendUsd: z.ZodNumber;
            maximumGpuSeconds: z.ZodNumber;
            maximumWallSeconds: z.ZodNumber;
            approvalHash: z.ZodString;
        }, z.core.$strict>>;
        mode: z.ZodOptional<z.ZodLiteral<"evaluation_only">>;
        trainingWorkloadComplete: z.ZodOptional<z.ZodBoolean>;
        sourceJobId: z.ZodString;
        checkpointId: z.ZodString;
        policyVersion: z.ZodNumber;
        completedGroups: z.ZodNumber;
        optimizerMode: z.ZodLiteral<"continue">;
    }, z.core.$strict>>;
    modelProjectId: z.ZodString;
    portableProjectId: z.ZodString;
    sourceProjectRevision: z.ZodNumber;
    submissionHash: z.ZodString;
    state: z.ZodEnum<{
        admitting: "admitting";
        cancelled: "cancelled";
        cancelling: "cancelling";
        failed: "failed";
        provisioning: "provisioning";
        queued: "queued";
        running: "running";
        stopping: "stopping";
        succeeded: "succeeded";
    }>;
    queue: z.ZodOptional<z.ZodObject<{
        ticketId: z.ZodString;
        ticketNumber: z.ZodNumber;
        label: z.ZodLiteral<"Waiting for resources">;
        position: z.ZodNullable<z.ZodNumber>;
        positionScope: z.ZodLiteral<"compatible_fair_queue">;
        enqueuedAt: z.ZodString;
        asOf: z.ZodString;
        estimate: z.ZodNullable<z.ZodObject<{
            revision: z.ZodNumber;
            estimatedStartAt: z.ZodString;
            expiresAt: z.ZodString;
            evidence: z.ZodEnum<{
                measured_bootstrap: "measured_bootstrap";
                observed_capacity: "observed_capacity";
                scheduled_release: "scheduled_release";
            }>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    phase: z.ZodString;
    version: z.ZodNumber;
    progress: z.ZodNumber;
    rolloutProgress: z.ZodObject<{
        groupsCompleted: z.ZodNumber;
        groupsTarget: z.ZodNumber;
        optimizerUpdatesApplied: z.ZodNumber;
        optimizerUpdatesSkipped: z.ZodNumber;
    }, z.core.$strict>;
    accruedSpendUsd: z.ZodNumber;
    terminalReason: z.ZodNullable<z.ZodString>;
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
    completedAt: z.ZodNullable<z.ZodString>;
}, z.core.$strict>;
export declare const TrainingJobPageSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingJobPage.v2">;
    jobs: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.trainingJob.v2">;
        id: z.ZodString;
        teamId: z.ZodString;
        kind: z.ZodEnum<{
            policy_optimize: "policy_optimize";
            reward_model_train: "reward_model_train";
        }>;
        executionMode: z.ZodOptional<z.ZodLiteral<"qualification">>;
        recovery: z.ZodOptional<z.ZodObject<{
            resourceApproval: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.checkpointRecoveryResourceApproval.v1">;
                ownerUserId: z.ZodString;
                teamId: z.ZodString;
                sourceJobId: z.ZodString;
                sourceJobVersion: z.ZodNumber;
                sourceInputManifestSha256: z.ZodString;
                checkpointId: z.ZodString;
                adapterSha256: z.ZodString;
                resumeSha256: z.ZodString;
                idempotencyKey: z.ZodString;
                approvedAt: z.ZodISODateTime;
                maximumSpendUsd: z.ZodNumber;
                maximumGpuSeconds: z.ZodNumber;
                maximumWallSeconds: z.ZodNumber;
                approvalHash: z.ZodString;
            }, z.core.$strict>>;
            mode: z.ZodOptional<z.ZodLiteral<"evaluation_only">>;
            trainingWorkloadComplete: z.ZodOptional<z.ZodBoolean>;
            sourceJobId: z.ZodString;
            checkpointId: z.ZodString;
            policyVersion: z.ZodNumber;
            completedGroups: z.ZodNumber;
            optimizerMode: z.ZodLiteral<"continue">;
        }, z.core.$strict>>;
        modelProjectId: z.ZodString;
        portableProjectId: z.ZodString;
        sourceProjectRevision: z.ZodNumber;
        submissionHash: z.ZodString;
        state: z.ZodEnum<{
            admitting: "admitting";
            cancelled: "cancelled";
            cancelling: "cancelling";
            failed: "failed";
            provisioning: "provisioning";
            queued: "queued";
            running: "running";
            stopping: "stopping";
            succeeded: "succeeded";
        }>;
        queue: z.ZodOptional<z.ZodObject<{
            ticketId: z.ZodString;
            ticketNumber: z.ZodNumber;
            label: z.ZodLiteral<"Waiting for resources">;
            position: z.ZodNullable<z.ZodNumber>;
            positionScope: z.ZodLiteral<"compatible_fair_queue">;
            enqueuedAt: z.ZodString;
            asOf: z.ZodString;
            estimate: z.ZodNullable<z.ZodObject<{
                revision: z.ZodNumber;
                estimatedStartAt: z.ZodString;
                expiresAt: z.ZodString;
                evidence: z.ZodEnum<{
                    measured_bootstrap: "measured_bootstrap";
                    observed_capacity: "observed_capacity";
                    scheduled_release: "scheduled_release";
                }>;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        phase: z.ZodString;
        version: z.ZodNumber;
        progress: z.ZodNumber;
        rolloutProgress: z.ZodObject<{
            groupsCompleted: z.ZodNumber;
            groupsTarget: z.ZodNumber;
            optimizerUpdatesApplied: z.ZodNumber;
            optimizerUpdatesSkipped: z.ZodNumber;
        }, z.core.$strict>;
        accruedSpendUsd: z.ZodNumber;
        terminalReason: z.ZodNullable<z.ZodString>;
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        completedAt: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
    nextCursor: z.ZodNullable<z.ZodString>;
}, z.core.$strict>;
export declare const TrainingJobEventSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingJobEvent.v2">;
    id: z.ZodString;
    jobId: z.ZodString;
    sequence: z.ZodNumber;
    type: z.ZodString;
    phase: z.ZodString;
    message: z.ZodNullable<z.ZodString>;
    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodString;
}, z.core.$strict>;
export declare const TrainingJobLogSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingJobLog.v2">;
    jobId: z.ZodString;
    sequence: z.ZodNumber;
    level: z.ZodEnum<{
        debug: "debug";
        error: "error";
        info: "info";
        warning: "warning";
    }>;
    message: z.ZodString;
    createdAt: z.ZodString;
}, z.core.$strict>;
export declare const TrainingJobControlRequestSchema: z.ZodObject<{
    expectedVersion: z.ZodNumber;
}, z.core.$strict>;
export declare const TrainingJobOutputSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingJobOutput.v2">;
    id: z.ZodString;
    jobId: z.ZodString;
    kind: z.ZodEnum<{
        adapter: "adapter";
        checkpoint: "checkpoint";
        evaluation: "evaluation";
        metrics: "metrics";
        receipt: "receipt";
        scorer: "scorer";
        trace: "trace";
    }>;
    artifactRef: z.ZodString;
    contentHash: z.ZodString;
    sizeBytes: z.ZodNumber;
    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodString;
}, z.core.$strict>;
/** Evidence that collection used the pinned original learner and never updated it. */
export declare const TrainingQualificationEvidenceSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
    baseModel: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
        modelId: z.ZodString;
        modelAssetId: z.ZodNullable<z.ZodString>;
        source: z.ZodEnum<{
            builtin: "builtin";
            local: "local";
            managed: "managed";
        }>;
        revision: z.ZodString;
        tokenizerRevision: z.ZodString;
        chatTemplateHash: z.ZodString;
    }, z.core.$strict>;
    group: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    rolloutReceipts: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    rewardEvidenceHash: z.ZodString;
    groupsCompleted: z.ZodLiteral<1>;
    optimizerUpdatesApplied: z.ZodLiteral<0>;
    optimizerUpdatesSkipped: z.ZodLiteral<0>;
    trainingStepsCreated: z.ZodLiteral<0>;
    checkpointsCreated: z.ZodLiteral<0>;
    artifactsCreated: z.ZodLiteral<0>;
}, z.core.$strict>;
export declare const TrainingExecutionReceiptSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingExecutionReceipt.v2">;
    id: z.ZodString;
    teamId: z.ZodString;
    jobId: z.ZodString;
    submissionHash: z.ZodString;
    manifestHash: z.ZodString;
    recipeHash: z.ZodString;
    capabilityHash: z.ZodString;
    runtimeRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    inputs: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    outputs: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    spendUsd: z.ZodNumber;
    durationSeconds: z.ZodNumber;
    cleanupComplete: z.ZodBoolean;
    qualification: z.ZodOptional<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
        baseModel: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
            modelId: z.ZodString;
            modelAssetId: z.ZodNullable<z.ZodString>;
            source: z.ZodEnum<{
                builtin: "builtin";
                local: "local";
                managed: "managed";
            }>;
            revision: z.ZodString;
            tokenizerRevision: z.ZodString;
            chatTemplateHash: z.ZodString;
        }, z.core.$strict>;
        group: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        rolloutReceipts: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        rewardEvidenceHash: z.ZodString;
        groupsCompleted: z.ZodLiteral<1>;
        optimizerUpdatesApplied: z.ZodLiteral<0>;
        optimizerUpdatesSkipped: z.ZodLiteral<0>;
        trainingStepsCreated: z.ZodLiteral<0>;
        checkpointsCreated: z.ZodLiteral<0>;
        artifactsCreated: z.ZodLiteral<0>;
    }, z.core.$strict>>;
    issuer: z.ZodString;
    issuedAt: z.ZodString;
    signature: z.ZodNullable<z.ZodString>;
}, z.core.$strict>;
export declare function trainingExecutionReceiptHash(receipt: TrainingExecutionReceipt): Promise<string>;
export declare function parseAndVerifyTrainingExecutionReceipt(value: unknown, expected: {
    id: string;
    contentHash: string;
    teamId?: string;
    jobId?: string;
    requireCleanup?: boolean;
    qualificationSubmission?: TrainingJobSubmission;
    outputs?: TrainingJobOutput[];
}): Promise<TrainingExecutionReceipt>;
export declare function assertTrainingQualificationReceipt(receipt: TrainingExecutionReceipt, expected: {
    submissionHash: string;
    baseModel?: z.infer<typeof ModelProjectBaseModelSchema>;
    outputs?: TrainingJobOutput[];
}): Promise<void>;
export declare const TrainingJobOutputsSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingJobOutputs.v2">;
    outputs: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.trainingJobOutput.v2">;
        id: z.ZodString;
        jobId: z.ZodString;
        kind: z.ZodEnum<{
            adapter: "adapter";
            checkpoint: "checkpoint";
            evaluation: "evaluation";
            metrics: "metrics";
            receipt: "receipt";
            scorer: "scorer";
            trace: "trace";
        }>;
        artifactRef: z.ZodString;
        contentHash: z.ZodString;
        sizeBytes: z.ZodNumber;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        createdAt: z.ZodString;
    }, z.core.$strict>>;
    receipt: z.ZodNullable<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.trainingExecutionReceipt.v2">;
        id: z.ZodString;
        teamId: z.ZodString;
        jobId: z.ZodString;
        submissionHash: z.ZodString;
        manifestHash: z.ZodString;
        recipeHash: z.ZodString;
        capabilityHash: z.ZodString;
        runtimeRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        inputs: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        outputs: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        spendUsd: z.ZodNumber;
        durationSeconds: z.ZodNumber;
        cleanupComplete: z.ZodBoolean;
        qualification: z.ZodOptional<z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.trainingQualificationEvidence.v1">;
            baseModel: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
                modelId: z.ZodString;
                modelAssetId: z.ZodNullable<z.ZodString>;
                source: z.ZodEnum<{
                    builtin: "builtin";
                    local: "local";
                    managed: "managed";
                }>;
                revision: z.ZodString;
                tokenizerRevision: z.ZodString;
                chatTemplateHash: z.ZodString;
            }, z.core.$strict>;
            group: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            rolloutReceipts: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
            rewardEvidenceHash: z.ZodString;
            groupsCompleted: z.ZodLiteral<1>;
            optimizerUpdatesApplied: z.ZodLiteral<0>;
            optimizerUpdatesSkipped: z.ZodLiteral<0>;
            trainingStepsCreated: z.ZodLiteral<0>;
            checkpointsCreated: z.ZodLiteral<0>;
            artifactsCreated: z.ZodLiteral<0>;
        }, z.core.$strict>>;
        issuer: z.ZodString;
        issuedAt: z.ZodString;
        signature: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const TrainingPolicyLoraCapabilitiesSchema: z.ZodObject<{
    workerImageDigest: z.ZodString;
    envelopeRank: z.ZodNumber;
    supportedRanks: z.ZodArray<z.ZodNumber>;
    qualification: z.ZodNullable<z.ZodObject<{
        evidenceRef: z.ZodString;
        evidenceSha256: z.ZodString;
    }, z.core.$strict>>;
    continuation: z.ZodObject<{
        sharedRequiresSameRank: z.ZodLiteral<true>;
        mergedRequiresSameRank: z.ZodLiteral<true>;
        residualAppendRequiresFreeCapacity: z.ZodLiteral<true>;
        stageOptimizer: z.ZodLiteral<"reset">;
        interruptedRecoveryOptimizer: z.ZodLiteral<"restore">;
    }, z.core.$strict>;
}, z.core.$strict>;
export type TrainingPolicyLoraCapabilities = z.infer<typeof TrainingPolicyLoraCapabilitiesSchema>;
export declare function supportsTrainingPolicyLoraRank(capabilities: TrainingPolicyLoraCapabilities, rank: number, continuation?: {
    mode: "shared" | "sequential_merge" | "residual_append";
    parentEnabledRank: number;
}): boolean;
export declare const TrainingCapabilitiesSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.trainingCapabilities.v2">;
    capabilityHash: z.ZodString;
    jobKinds: z.ZodArray<z.ZodEnum<{
        policy_optimize: "policy_optimize";
        reward_model_train: "reward_model_train";
    }>>;
    methods: z.ZodArray<z.ZodString>;
    executionModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        qualification: "qualification";
        training: "training";
    }>>>;
    policyLora: z.ZodOptional<z.ZodObject<{
        workerImageDigest: z.ZodString;
        envelopeRank: z.ZodNumber;
        supportedRanks: z.ZodArray<z.ZodNumber>;
        qualification: z.ZodNullable<z.ZodObject<{
            evidenceRef: z.ZodString;
            evidenceSha256: z.ZodString;
        }, z.core.$strict>>;
        continuation: z.ZodObject<{
            sharedRequiresSameRank: z.ZodLiteral<true>;
            mergedRequiresSameRank: z.ZodLiteral<true>;
            residualAppendRequiresFreeCapacity: z.ZodLiteral<true>;
            stageOptimizer: z.ZodLiteral<"reset">;
            interruptedRecoveryOptimizer: z.ZodLiteral<"restore">;
        }, z.core.$strict>;
    }, z.core.$strict>>;
    policyDataParallel: z.ZodOptional<z.ZodObject<{
        capability: z.ZodLiteral<"managed_rl.policy.data_parallel">;
        version: z.ZodLiteral<"1">;
        gpuCount: z.ZodLiteral<2>;
        worldSize: z.ZodLiteral<2>;
        backend: z.ZodLiteral<"nccl">;
        allocationMode: z.ZodLiteral<"exclusive">;
        workerImageDigest: z.ZodString;
    }, z.core.$strict>>;
    structuredOutputs: z.ZodOptional<z.ZodObject<{
        capability: z.ZodLiteral<"work.structured-output.v1">;
        harnessRuntimeHash: z.ZodString;
        workHarnessHash: z.ZodString;
        schemaHash: z.ZodString;
        artifactHash: z.ZodString;
        invalidDataRejected: z.ZodLiteral<true>;
        invalidBytesRejected: z.ZodLiteral<true>;
    }, z.core.$strict>>;
    placements: z.ZodArray<z.ZodEnum<{
        colocated: "colocated";
        local: "local";
        provider_native: "provider_native";
        remote: "remote";
    }>>;
    controls: z.ZodObject<{
        cancel: z.ZodBoolean;
        stopAfterGroup: z.ZodBoolean;
        resumeFromCheckpoint: z.ZodBoolean;
    }, z.core.$strict>;
    estimates: z.ZodOptional<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.trainingEstimate.v1">;
    }, z.core.$strict>>;
    limits: z.ZodObject<{
        maximumSpendUsd: z.ZodNumber;
        maximumWallSeconds: z.ZodNumber;
        maximumArtifactBytes: z.ZodNumber;
    }, z.core.$strict>;
    checkedAt: z.ZodString;
    expiresAt: z.ZodString;
}, z.core.$strict>;
export type TrainingJobSubmission = z.infer<typeof TrainingJobSubmissionSchema>;
export type TrainingQualificationEvidence = z.infer<typeof TrainingQualificationEvidenceSchema>;
export type TrainingInputArtifactUpload = z.infer<typeof TrainingInputArtifactUploadSchema>;
export type TrainingInputArtifact = z.infer<typeof TrainingInputArtifactSchema>;
export type TrainingJob = z.infer<typeof TrainingJobSchema>;
export type TrainingJobPage = z.infer<typeof TrainingJobPageSchema>;
export type TrainingJobEvent = z.infer<typeof TrainingJobEventSchema>;
export type TrainingJobLog = z.infer<typeof TrainingJobLogSchema>;
export type TrainingJobOutput = z.infer<typeof TrainingJobOutputSchema>;
export type TrainingJobOutputs = z.infer<typeof TrainingJobOutputsSchema>;
export type TrainingExecutionReceipt = z.infer<typeof TrainingExecutionReceiptSchema>;
export type TrainingCapabilities = z.infer<typeof TrainingCapabilitiesSchema>;
export declare function createTrainingClient(input: {
    baseUrl: string;
    fetch?: typeof fetch;
    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
}): {
    acceptanceGroups(target: import("./training-acceptance.js").TrainingAcceptanceTarget, input?: import("./training-acceptance.js").TrainingAcceptanceGroupQuery): Promise<{
        schemaVersion: "openpond.trainingAcceptanceGroupPage.v1";
        teamId: string;
        jobId: string;
        groups: {
            id: string;
            contentHash: string;
            revision: number;
            teamId: string;
            jobId: string;
            plan: {
                id: string;
                contentHash: string;
            };
            baseline: {
                id: string;
                contentHash: string;
            };
            candidate: {
                id: string;
                contentHash: string;
            };
            state: "blocked" | "budget_exhausted" | "cancelled" | "cancelling" | "cleaning" | "completed" | "failed" | "queued" | "running";
            updatedAt: string;
        }[];
        nextCursor: string | null;
    }>;
    acceptanceGroup(target: import("./training-acceptance.js").TrainingAcceptanceTarget, groupId: string, expected?: import("./training-acceptance.js").TrainingAcceptanceGroupReference): Promise<{
        schemaVersion: "openpond.acceptanceGroupSnapshot.v1";
        manifest: {
            schemaVersion: "openpond.acceptanceGroupManifest.v1";
            id: string;
            teamId: string;
            trainingJob: {
                id: string;
                contentHash: string;
            };
            baseline: {
                id: string;
                contentHash: string;
            };
            candidate: {
                id: string;
                contentHash: string;
            };
            plan: {
                schemaVersion: "openpond.acceptancePlan.v1";
                id: string;
                revision: number;
                checks: {
                    id: string;
                    name: string;
                    required: boolean;
                    role?: "diagnostic" | "quality" | "retention" | undefined;
                    unit?: string | undefined;
                    baselineReuse?: {
                        maximumAgeSeconds: number;
                        qualification: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    dataset: {
                        id: string;
                        contentHash: string;
                    };
                    evaluator: {
                        id: string;
                        contentHash: string;
                    };
                    executionHash: string;
                    populationHash: string;
                    metric: string;
                    direction: "higher" | "lower";
                    minimumCoverage: number;
                    threshold: number;
                    maximumRegression: number;
                    maximumSpendUsd: number;
                }[];
                maximumSpendUsd: number;
                contentHash: string;
            };
            maximumParallelAttempts: number;
            createdAt: string;
            contentHash: string;
        };
        revision: number;
        state: "blocked" | "budget_exhausted" | "cancelled" | "cancelling" | "cleaning" | "completed" | "failed" | "queued" | "running";
        attempts: {
            id: string;
            checkId: string;
            subject: "baseline" | "candidate";
            ordinal: number;
            dispatchId: string;
            state: "budget_exhausted" | "cancelled" | "cleaning" | "completed" | "dispatching" | "failed" | "grading" | "queued" | "running";
            artifact: {
                id: string;
                contentHash: string;
            };
            checkHash: string;
            measurement: {
                runId: string;
                artifact: {
                    id: string;
                    contentHash: string;
                };
                checkHash: string;
                populationHash: string;
                scoredPopulationHash: string;
                executionHash: string;
                evaluator: {
                    id: string;
                    contentHash: string;
                };
                metric: string;
                expectedCount: number;
                scoredCount: number;
                score: number | null;
                status: "cancelled" | "completed" | "failed" | "pending" | "running";
                evidenceHash: string;
            } | null;
            executionReceipt: {
                id: string;
                contentHash: string;
            } | null;
            reusedFrom: {
                group: {
                    id: string;
                    contentHash: string;
                };
                attemptId: string;
            } | null;
            spendUsd: number;
            reservedUsd: number;
            cleanupComplete: boolean;
            accountingComplete: boolean;
            failureCode: string | null;
            createdAt: string;
            updatedAt: string;
        }[];
        failureCode: string | null;
        updatedAt: string;
        contentHash: string;
    }>;
    hardwareObservations(query: import("./training-hardware.js").HardwareObservationQuery): Promise<import("./training-hardware.js").HardwareFleetSnapshot>;
    listPreparations(teamId: string, input?: import("./training-preparations.js").TrainingPreparationListQuery): Promise<{
        schemaVersion: "openpond.trainingPreparationPage.v1";
        teamId: string;
        nextCursor: string | null;
        items: {
            schemaVersion: "openpond.trainingPreparationReceipt.v1";
            plan: {
                schemaVersion: "openpond.trainingPreparationPlan.v1";
                id: string;
                creatorUserId: string;
                request: {
                    schemaVersion: "openpond.trainingPreparationRequest.v1";
                    teamId: string;
                    operationId: string;
                    projectId: string | null;
                    configuration: {
                        id: string;
                        expectedRevision: number;
                        expectedEtag: string;
                    };
                    origin?: {
                        schemaVersion: "openpond.trainingHandoffOrigin.v1";
                        teamId: string;
                        projectId: string | null;
                        configurationId: string;
                        source: {
                            executionId: string;
                            passId: string | null;
                            manifestHash: string;
                            resultHash: string;
                        };
                        dataset: {
                            id: string;
                            revision: number;
                            contentHash: string;
                        };
                        target: {
                            kind: "model";
                            modelId: string;
                            configurationHash: string;
                        } | {
                            kind: "harness";
                            source: {
                                profileId: string;
                                sourceRevision: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                catalogHash: string;
                                definitionId: string;
                                definitionHash: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                environmentHash: string;
                                externalDatasetBinding?: {
                                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                    dataset: {
                                        id: string;
                                        contentHash: string;
                                        revision: number;
                                    };
                                    packageHash: string;
                                    profileId: string;
                                    target: {
                                        kind: "profile";
                                    } | {
                                        kind: "workflow";
                                        workflowId: string;
                                    } | {
                                        kind: "skill";
                                        skillPath: string;
                                    } | {
                                        kind: "agent_action";
                                        actionId: string;
                                    };
                                    declaredProfileCatalogHash: string | null;
                                    protectedProfileClosureHash: string;
                                    recordedOrigin?: {
                                        execution: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        originalEvidence: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        members: {
                                            caseId: string;
                                            seed: string;
                                            fixtureId: string;
                                            sourceId: string;
                                            snapshotHash: string;
                                            boundaryRevisionHash: string;
                                        }[];
                                    } | undefined;
                                    gradingSource?: {
                                        pass: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        evidence: {
                                            id: string;
                                            contentHash: string;
                                        };
                                    } | undefined;
                                    split: "frozen_eval" | "test" | "train" | "validation";
                                    population: {
                                        taskId: string;
                                        seed: string;
                                        fixtureId: string | null;
                                    }[];
                                    evaluators: {
                                        release: {
                                            id: string;
                                            contentHash: string;
                                            revision: string | number;
                                        };
                                        feedbackKey: string;
                                        configurationHash: string;
                                        output: "boolean" | "category" | "score";
                                        categories: string[];
                                    }[];
                                    fieldMappingsHash: string;
                                    fieldMappings: {
                                        graderId: string;
                                        fields: {
                                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                            path: string[];
                                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                            sourcePath: string[];
                                        }[];
                                    }[];
                                    environmentHash: string;
                                    privateDatasetClosureHash: string;
                                    criterion: {
                                        minimumPassRate: number;
                                        requireComplete: boolean;
                                    };
                                    contentHash: string;
                                } | undefined;
                                sourceCandidate?: {
                                    candidateId: string;
                                    frozenRevision: number;
                                    frozenHash: string;
                                    harnessRelease: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    protectedClosureHash: string;
                                } | undefined;
                            };
                            model: {
                                modelId: string;
                                configurationHash: string;
                            };
                        } | {
                            kind: "agent";
                            source: {
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                agentSnapshot: {
                                    id: string;
                                    contentHash: string;
                                };
                                sourcePackageHash: string;
                            };
                            model: {
                                modelId: string;
                                configurationHash: string;
                            };
                        } | {
                            kind: "fixture";
                            configurationHash: string;
                        };
                        graders: {
                            feedbackKey: string;
                            evaluator: {
                                id: string;
                                contentHash: string;
                            };
                            expectedCount: number;
                            scoredCount: number;
                            score: number | null;
                        }[];
                        contentHash: string;
                    } | undefined;
                    batch: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    name: string;
                    maximumSpendUsd: number;
                    gpuSelection?: {
                        mode: "automatic";
                        objective: "balanced" | "economical" | "fast";
                        gpuCount?: 1 | 2 | undefined;
                    } | {
                        mode: "manual";
                        availabilityId: string;
                        gpuType: string;
                        gpuCount?: 1 | 2 | undefined;
                    } | undefined;
                    physicalPlacement?: {
                        mode: "reuse_only";
                        physicalWorkerId: string;
                        providerPodId: string;
                        workerImageDigest: string;
                        baseProfileSha256: string;
                        gpuType: string;
                        sourceJobId: string;
                        sourceInputManifestSha256: string;
                        ownerTeamId: string;
                        deadlineAt: string;
                    } | undefined;
                };
                requestHash: string;
                source: {
                    origin?: {
                        schemaVersion: "openpond.trainingHandoffOrigin.v1";
                        teamId: string;
                        projectId: string | null;
                        configurationId: string;
                        source: {
                            executionId: string;
                            passId: string | null;
                            manifestHash: string;
                            resultHash: string;
                        };
                        dataset: {
                            id: string;
                            revision: number;
                            contentHash: string;
                        };
                        target: {
                            kind: "model";
                            modelId: string;
                            configurationHash: string;
                        } | {
                            kind: "harness";
                            source: {
                                profileId: string;
                                sourceRevision: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                catalogHash: string;
                                definitionId: string;
                                definitionHash: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                environmentHash: string;
                                externalDatasetBinding?: {
                                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                    dataset: {
                                        id: string;
                                        contentHash: string;
                                        revision: number;
                                    };
                                    packageHash: string;
                                    profileId: string;
                                    target: {
                                        kind: "profile";
                                    } | {
                                        kind: "workflow";
                                        workflowId: string;
                                    } | {
                                        kind: "skill";
                                        skillPath: string;
                                    } | {
                                        kind: "agent_action";
                                        actionId: string;
                                    };
                                    declaredProfileCatalogHash: string | null;
                                    protectedProfileClosureHash: string;
                                    recordedOrigin?: {
                                        execution: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        originalEvidence: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        members: {
                                            caseId: string;
                                            seed: string;
                                            fixtureId: string;
                                            sourceId: string;
                                            snapshotHash: string;
                                            boundaryRevisionHash: string;
                                        }[];
                                    } | undefined;
                                    gradingSource?: {
                                        pass: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        evidence: {
                                            id: string;
                                            contentHash: string;
                                        };
                                    } | undefined;
                                    split: "frozen_eval" | "test" | "train" | "validation";
                                    population: {
                                        taskId: string;
                                        seed: string;
                                        fixtureId: string | null;
                                    }[];
                                    evaluators: {
                                        release: {
                                            id: string;
                                            contentHash: string;
                                            revision: string | number;
                                        };
                                        feedbackKey: string;
                                        configurationHash: string;
                                        output: "boolean" | "category" | "score";
                                        categories: string[];
                                    }[];
                                    fieldMappingsHash: string;
                                    fieldMappings: {
                                        graderId: string;
                                        fields: {
                                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                            path: string[];
                                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                            sourcePath: string[];
                                        }[];
                                    }[];
                                    environmentHash: string;
                                    privateDatasetClosureHash: string;
                                    criterion: {
                                        minimumPassRate: number;
                                        requireComplete: boolean;
                                    };
                                    contentHash: string;
                                } | undefined;
                                sourceCandidate?: {
                                    candidateId: string;
                                    frozenRevision: number;
                                    frozenHash: string;
                                    harnessRelease: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    protectedClosureHash: string;
                                } | undefined;
                            };
                            model: {
                                modelId: string;
                                configurationHash: string;
                            };
                        } | {
                            kind: "agent";
                            source: {
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                agentSnapshot: {
                                    id: string;
                                    contentHash: string;
                                };
                                sourcePackageHash: string;
                            };
                            model: {
                                modelId: string;
                                configurationHash: string;
                            };
                        } | {
                            kind: "fixture";
                            configurationHash: string;
                        };
                        graders: {
                            feedbackKey: string;
                            evaluator: {
                                id: string;
                                contentHash: string;
                            };
                            expectedCount: number;
                            scoredCount: number;
                            score: number | null;
                        }[];
                        contentHash: string;
                    } | undefined;
                    modelProject: {
                        id: string;
                        portableProjectId: string;
                        revision: number;
                        contentHash: string;
                    };
                    harnessRunManifest: {
                        id: string;
                        contentHash: string;
                    };
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    taskset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    tasksetRelease: {
                        id: string;
                        contentHash: string;
                    };
                    evaluation?: {
                        taskset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        dataset: {
                            id: string;
                            contentHash: string;
                        };
                    } | null | undefined;
                    dataset: {
                        id: string;
                        contentHash: string;
                    };
                    evidenceSets: {
                        id: string;
                        contentHash: string;
                    }[];
                };
                submissionHash: string;
                createdAt: string;
                contentHash: string;
            };
            revision: number;
            state: "cancelled" | "prepared" | "submitted";
            jobId: string | null;
        }[];
    }>;
    prepareRun(input: import("./training-preparations.js").TrainingPreparationRequest): Promise<{
        schemaVersion: "openpond.trainingPreparationReceipt.v1";
        plan: {
            schemaVersion: "openpond.trainingPreparationPlan.v1";
            id: string;
            creatorUserId: string;
            request: {
                schemaVersion: "openpond.trainingPreparationRequest.v1";
                teamId: string;
                operationId: string;
                projectId: string | null;
                configuration: {
                    id: string;
                    expectedRevision: number;
                    expectedEtag: string;
                };
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                batch: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                name: string;
                maximumSpendUsd: number;
                gpuSelection?: {
                    mode: "automatic";
                    objective: "balanced" | "economical" | "fast";
                    gpuCount?: 1 | 2 | undefined;
                } | {
                    mode: "manual";
                    availabilityId: string;
                    gpuType: string;
                    gpuCount?: 1 | 2 | undefined;
                } | undefined;
                physicalPlacement?: {
                    mode: "reuse_only";
                    physicalWorkerId: string;
                    providerPodId: string;
                    workerImageDigest: string;
                    baseProfileSha256: string;
                    gpuType: string;
                    sourceJobId: string;
                    sourceInputManifestSha256: string;
                    ownerTeamId: string;
                    deadlineAt: string;
                } | undefined;
            };
            requestHash: string;
            source: {
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                modelProject: {
                    id: string;
                    portableProjectId: string;
                    revision: number;
                    contentHash: string;
                };
                harnessRunManifest: {
                    id: string;
                    contentHash: string;
                };
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                tasksetRelease: {
                    id: string;
                    contentHash: string;
                };
                evaluation?: {
                    taskset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    dataset: {
                        id: string;
                        contentHash: string;
                    };
                } | null | undefined;
                dataset: {
                    id: string;
                    contentHash: string;
                };
                evidenceSets: {
                    id: string;
                    contentHash: string;
                }[];
            };
            submissionHash: string;
            createdAt: string;
            contentHash: string;
        };
        revision: number;
        state: "cancelled" | "prepared" | "submitted";
        jobId: string | null;
    }>;
    getPreparation(teamId: string, id: string): Promise<{
        schemaVersion: "openpond.trainingPreparationReceipt.v1";
        plan: {
            schemaVersion: "openpond.trainingPreparationPlan.v1";
            id: string;
            creatorUserId: string;
            request: {
                schemaVersion: "openpond.trainingPreparationRequest.v1";
                teamId: string;
                operationId: string;
                projectId: string | null;
                configuration: {
                    id: string;
                    expectedRevision: number;
                    expectedEtag: string;
                };
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                batch: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                name: string;
                maximumSpendUsd: number;
                gpuSelection?: {
                    mode: "automatic";
                    objective: "balanced" | "economical" | "fast";
                    gpuCount?: 1 | 2 | undefined;
                } | {
                    mode: "manual";
                    availabilityId: string;
                    gpuType: string;
                    gpuCount?: 1 | 2 | undefined;
                } | undefined;
                physicalPlacement?: {
                    mode: "reuse_only";
                    physicalWorkerId: string;
                    providerPodId: string;
                    workerImageDigest: string;
                    baseProfileSha256: string;
                    gpuType: string;
                    sourceJobId: string;
                    sourceInputManifestSha256: string;
                    ownerTeamId: string;
                    deadlineAt: string;
                } | undefined;
            };
            requestHash: string;
            source: {
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                modelProject: {
                    id: string;
                    portableProjectId: string;
                    revision: number;
                    contentHash: string;
                };
                harnessRunManifest: {
                    id: string;
                    contentHash: string;
                };
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                tasksetRelease: {
                    id: string;
                    contentHash: string;
                };
                evaluation?: {
                    taskset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    dataset: {
                        id: string;
                        contentHash: string;
                    };
                } | null | undefined;
                dataset: {
                    id: string;
                    contentHash: string;
                };
                evidenceSets: {
                    id: string;
                    contentHash: string;
                }[];
            };
            submissionHash: string;
            createdAt: string;
            contentHash: string;
        };
        revision: number;
        state: "cancelled" | "prepared" | "submitted";
        jobId: string | null;
    }>;
    startPreparation(id: string, input: import("./training-preparations.js").TrainingPreparationControl): Promise<{
        schemaVersion: "openpond.trainingPreparationReceipt.v1";
        plan: {
            schemaVersion: "openpond.trainingPreparationPlan.v1";
            id: string;
            creatorUserId: string;
            request: {
                schemaVersion: "openpond.trainingPreparationRequest.v1";
                teamId: string;
                operationId: string;
                projectId: string | null;
                configuration: {
                    id: string;
                    expectedRevision: number;
                    expectedEtag: string;
                };
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                batch: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                name: string;
                maximumSpendUsd: number;
                gpuSelection?: {
                    mode: "automatic";
                    objective: "balanced" | "economical" | "fast";
                    gpuCount?: 1 | 2 | undefined;
                } | {
                    mode: "manual";
                    availabilityId: string;
                    gpuType: string;
                    gpuCount?: 1 | 2 | undefined;
                } | undefined;
                physicalPlacement?: {
                    mode: "reuse_only";
                    physicalWorkerId: string;
                    providerPodId: string;
                    workerImageDigest: string;
                    baseProfileSha256: string;
                    gpuType: string;
                    sourceJobId: string;
                    sourceInputManifestSha256: string;
                    ownerTeamId: string;
                    deadlineAt: string;
                } | undefined;
            };
            requestHash: string;
            source: {
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                modelProject: {
                    id: string;
                    portableProjectId: string;
                    revision: number;
                    contentHash: string;
                };
                harnessRunManifest: {
                    id: string;
                    contentHash: string;
                };
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                tasksetRelease: {
                    id: string;
                    contentHash: string;
                };
                evaluation?: {
                    taskset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    dataset: {
                        id: string;
                        contentHash: string;
                    };
                } | null | undefined;
                dataset: {
                    id: string;
                    contentHash: string;
                };
                evidenceSets: {
                    id: string;
                    contentHash: string;
                }[];
            };
            submissionHash: string;
            createdAt: string;
            contentHash: string;
        };
        revision: number;
        state: "cancelled" | "prepared" | "submitted";
        jobId: string | null;
    }>;
    cancelPreparation(id: string, input: import("./training-preparations.js").TrainingPreparationControl): Promise<{
        schemaVersion: "openpond.trainingPreparationReceipt.v1";
        plan: {
            schemaVersion: "openpond.trainingPreparationPlan.v1";
            id: string;
            creatorUserId: string;
            request: {
                schemaVersion: "openpond.trainingPreparationRequest.v1";
                teamId: string;
                operationId: string;
                projectId: string | null;
                configuration: {
                    id: string;
                    expectedRevision: number;
                    expectedEtag: string;
                };
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                batch: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                name: string;
                maximumSpendUsd: number;
                gpuSelection?: {
                    mode: "automatic";
                    objective: "balanced" | "economical" | "fast";
                    gpuCount?: 1 | 2 | undefined;
                } | {
                    mode: "manual";
                    availabilityId: string;
                    gpuType: string;
                    gpuCount?: 1 | 2 | undefined;
                } | undefined;
                physicalPlacement?: {
                    mode: "reuse_only";
                    physicalWorkerId: string;
                    providerPodId: string;
                    workerImageDigest: string;
                    baseProfileSha256: string;
                    gpuType: string;
                    sourceJobId: string;
                    sourceInputManifestSha256: string;
                    ownerTeamId: string;
                    deadlineAt: string;
                } | undefined;
            };
            requestHash: string;
            source: {
                origin?: {
                    schemaVersion: "openpond.trainingHandoffOrigin.v1";
                    teamId: string;
                    projectId: string | null;
                    configurationId: string;
                    source: {
                        executionId: string;
                        passId: string | null;
                        manifestHash: string;
                        resultHash: string;
                    };
                    dataset: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    };
                    target: {
                        kind: "model";
                        modelId: string;
                        configurationHash: string;
                    } | {
                        kind: "harness";
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "agent";
                        source: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        };
                        model: {
                            modelId: string;
                            configurationHash: string;
                        };
                    } | {
                        kind: "fixture";
                        configurationHash: string;
                    };
                    graders: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        expectedCount: number;
                        scoredCount: number;
                        score: number | null;
                    }[];
                    contentHash: string;
                } | undefined;
                modelProject: {
                    id: string;
                    portableProjectId: string;
                    revision: number;
                    contentHash: string;
                };
                harnessRunManifest: {
                    id: string;
                    contentHash: string;
                };
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                tasksetRelease: {
                    id: string;
                    contentHash: string;
                };
                evaluation?: {
                    taskset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    dataset: {
                        id: string;
                        contentHash: string;
                    };
                } | null | undefined;
                dataset: {
                    id: string;
                    contentHash: string;
                };
                evidenceSets: {
                    id: string;
                    contentHash: string;
                }[];
            };
            submissionHash: string;
            createdAt: string;
            contentHash: string;
        };
        revision: number;
        state: "cancelled" | "prepared" | "submitted";
        jobId: string | null;
    }>;
    estimate(input: import("./training-estimates.js").TrainingEstimateRequest): Promise<import("./training-estimates.js").TrainingEstimate>;
    publishHarnessSource(value: import("@openpond/harness").HarnessSourcePackage | import("@openpond/harness").HarnessPolicySourcePackage): Promise<{
        schemaVersion: "openpond.trainingHarnessSourcePublication.v1";
        harnessRelease: {
            id: string;
            contentHash: string;
        };
        sourcePackageHash: string;
        sizeBytes: number;
    }>;
    getHarnessSource(reference: import("@openpond/harness").ImmutableReleaseRef): Promise<{
        schemaVersion: "openpond.harnessSourcePackage.v1";
        agentSnapshot: {
            schemaVersion: "openpond.agentSnapshot.v2";
            id: string;
            sourceRelease: {
                id: string;
                contentHash: string;
            } | null;
            instructions: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            skills: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            agents: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            toolDeclarations: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            capabilityRequirements: {
                id: string;
                required: boolean;
                scopes: string[];
                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
            }[];
            dependencyLock: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            };
            portability: {
                portable: boolean;
                blockers: string[];
                localOnlyAssetRefs: string[];
                hostPrivateAssetRefs: string[];
            };
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        harnessRelease: {
            schemaVersion: "openpond.harnessRelease.v2";
            id: string;
            agentSnapshot: {
                id: string;
                contentHash: string;
            };
            program: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            };
            tools: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            lifecycle: {
                create: true;
                reset: true;
                step: true;
                collect: true;
                destroy: true;
                resetScope: "attempt" | "task";
            };
            graderInterface: {
                visibleEvidence: string[];
                privilegedEvidence: string[];
                privateVerifierIsolation: boolean;
            };
            files: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        files: {
            path: string;
            base64: string;
        }[];
        contentHash: string;
    } | {
        agentSnapshot: {
            schemaVersion: "openpond.agentSnapshot.v2";
            id: string;
            sourceRelease: {
                id: string;
                contentHash: string;
            } | null;
            instructions: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            skills: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            agents: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            toolDeclarations: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            capabilityRequirements: {
                id: string;
                required: boolean;
                scopes: string[];
                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
            }[];
            dependencyLock: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            };
            portability: {
                portable: boolean;
                blockers: string[];
                localOnlyAssetRefs: string[];
                hostPrivateAssetRefs: string[];
            };
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        harnessRelease: {
            schemaVersion: "openpond.harnessRelease.v2";
            id: string;
            agentSnapshot: {
                id: string;
                contentHash: string;
            };
            program: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            };
            tools: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            lifecycle: {
                create: true;
                reset: true;
                step: true;
                collect: true;
                destroy: true;
                resetScope: "attempt" | "task";
            };
            graderInterface: {
                visibleEvidence: string[];
                privilegedEvidence: string[];
                privateVerifierIsolation: boolean;
            };
            files: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        files: {
            path: string;
            base64: string;
        }[];
        schemaVersion: "openpond.harnessPolicySourcePackage.v1";
        contentHash: string;
    }>;
    candidateDecision(target: import("./training-candidate-decisions.js").TrainingCandidateDecisionTarget, options?: {
        decision?: {
            id: string;
            contentHash: string;
        };
    }): Promise<import("./training-candidate-decisions.js").TrainingCandidateDecision | null>;
    recordCandidateDecision(input: import("./training-candidate-decisions.js").TrainingCandidateDecisionRequest): Promise<import("./training-candidate-decisions.js").TrainingCandidateDecision>;
    postTraining: {
        attach(teamId: string, raw: z.input<typeof import("./post-training.js").AttachPostTrainingSchema>): Promise<{
            id: string;
            teamId: string;
            ownerUserId: string;
            attachment: {
                schemaVersion: "openpond.postTrainingAttachment.v1";
                binding: {
                    kind: "policy" | "preparation";
                    id: string;
                    revision: number;
                    contentHash: string;
                };
                projectId: string | null;
                automatic: boolean;
                maximumSpendUsd: number;
                experiments: {
                    id: string;
                    configuration: {
                        operationId: string;
                        request: {
                            schemaVersion: "openpond.modelTasksetRunRequest.v1";
                            operationId: string;
                            teamId: string;
                            modelProjectId: string | null;
                            name?: string | undefined;
                            project?: {
                                id: string;
                                revision: number;
                                contentHash: string;
                                targetId: string | null;
                            } | undefined;
                            taskset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            policy: {
                                kind: "hosted_chat";
                                modelId: string;
                                localRuntime?: {
                                    providerId: "custom-openai-compatible";
                                    configurationHash: string;
                                    maximumRequestCostUsd: number;
                                    requestTimeoutMs: number;
                                } | {
                                    providerId: "claude-code";
                                    configurationHash: string;
                                    executableHash: string;
                                    version: string;
                                    capabilityHash: string;
                                    maximumRequestCostUsd: number;
                                    requestTimeoutMs: number;
                                    maximumTurns: number;
                                    holdOpen: boolean;
                                } | {
                                    providerId: "codex";
                                    configurationHash: string;
                                    accountHash: string;
                                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                                    maximumRequestCostUsd: number;
                                    requestTimeoutMs: number;
                                } | undefined;
                                candidate?: {
                                    artifactId: string;
                                    contentHash: string;
                                    preparationId: string;
                                    dispatchId: string;
                                    baseProfileId: string;
                                    workerImageDigest: string;
                                } | undefined;
                                harness?: {
                                    harnessRelease: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    agentSnapshot: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    sourcePackageHash: string;
                                } | undefined;
                                messages?: {
                                    role: "assistant" | "system" | "user";
                                    content: string;
                                }[] | undefined;
                                maxOutputTokens: number;
                                temperature: number;
                                topP: number;
                            } | {
                                kind: "fixture";
                            } | {
                                kind: "hosted_harness";
                                modelId: string;
                                maxOutputTokens?: number | undefined;
                                temperature?: number | undefined;
                                topP?: number | undefined;
                                localRuntime?: {
                                    providerId: "codex";
                                    configurationHash: string;
                                    accountHash: string;
                                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                                    maximumRequestCostUsd: number;
                                    requestTimeoutMs: number;
                                } | undefined;
                                candidate?: {
                                    artifactId: string;
                                    contentHash: string;
                                    preparationId: string;
                                    dispatchId: string;
                                    baseProfileId: string;
                                    workerImageDigest: string;
                                } | undefined;
                                sourceCandidate?: {
                                    candidateId: string;
                                    frozenRevision: number;
                                    frozenHash: string;
                                    harnessRelease: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    protectedClosureHash: string;
                                } | undefined;
                                reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                                profileRepositoryId: string;
                                source: {
                                    profileId: string;
                                    sourceRevision: string;
                                    harnessRelease: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    catalogHash: string;
                                    definitionId: string;
                                    definitionHash: string;
                                    target: {
                                        kind: "profile";
                                    } | {
                                        kind: "workflow";
                                        workflowId: string;
                                    } | {
                                        kind: "skill";
                                        skillPath: string;
                                    } | {
                                        kind: "agent_action";
                                        actionId: string;
                                    };
                                    environmentHash: string;
                                    externalDatasetBinding?: {
                                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                        dataset: {
                                            id: string;
                                            contentHash: string;
                                            revision: number;
                                        };
                                        packageHash: string;
                                        profileId: string;
                                        target: {
                                            kind: "profile";
                                        } | {
                                            kind: "workflow";
                                            workflowId: string;
                                        } | {
                                            kind: "skill";
                                            skillPath: string;
                                        } | {
                                            kind: "agent_action";
                                            actionId: string;
                                        };
                                        declaredProfileCatalogHash: string | null;
                                        protectedProfileClosureHash: string;
                                        recordedOrigin?: {
                                            execution: {
                                                id: string;
                                                contentHash: string;
                                            };
                                            originalEvidence: {
                                                id: string;
                                                contentHash: string;
                                            };
                                            members: {
                                                caseId: string;
                                                seed: string;
                                                fixtureId: string;
                                                sourceId: string;
                                                snapshotHash: string;
                                                boundaryRevisionHash: string;
                                            }[];
                                        } | undefined;
                                        gradingSource?: {
                                            pass: {
                                                id: string;
                                                contentHash: string;
                                            };
                                            evidence: {
                                                id: string;
                                                contentHash: string;
                                            };
                                        } | undefined;
                                        split: "frozen_eval" | "test" | "train" | "validation";
                                        population: {
                                            taskId: string;
                                            seed: string;
                                            fixtureId: string | null;
                                        }[];
                                        evaluators: {
                                            release: {
                                                id: string;
                                                contentHash: string;
                                                revision: string | number;
                                            };
                                            feedbackKey: string;
                                            configurationHash: string;
                                            output: "boolean" | "category" | "score";
                                            categories: string[];
                                        }[];
                                        fieldMappingsHash: string;
                                        fieldMappings: {
                                            graderId: string;
                                            fields: {
                                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                                path: string[];
                                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                                sourcePath: string[];
                                            }[];
                                        }[];
                                        environmentHash: string;
                                        privateDatasetClosureHash: string;
                                        criterion: {
                                            minimumPassRate: number;
                                            requireComplete: boolean;
                                        };
                                        contentHash: string;
                                    } | undefined;
                                    sourceCandidate?: {
                                        candidateId: string;
                                        frozenRevision: number;
                                        frozenHash: string;
                                        harnessRelease: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        protectedClosureHash: string;
                                    } | undefined;
                                };
                                modelConfigurationHash: string;
                                packageHash: string;
                                externalDatasetBinding?: {
                                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                    dataset: {
                                        id: string;
                                        contentHash: string;
                                        revision: number;
                                    };
                                    packageHash: string;
                                    profileId: string;
                                    target: {
                                        kind: "profile";
                                    } | {
                                        kind: "workflow";
                                        workflowId: string;
                                    } | {
                                        kind: "skill";
                                        skillPath: string;
                                    } | {
                                        kind: "agent_action";
                                        actionId: string;
                                    };
                                    declaredProfileCatalogHash: string | null;
                                    protectedProfileClosureHash: string;
                                    recordedOrigin?: {
                                        execution: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        originalEvidence: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        members: {
                                            caseId: string;
                                            seed: string;
                                            fixtureId: string;
                                            sourceId: string;
                                            snapshotHash: string;
                                            boundaryRevisionHash: string;
                                        }[];
                                    } | undefined;
                                    gradingSource?: {
                                        pass: {
                                            id: string;
                                            contentHash: string;
                                        };
                                        evidence: {
                                            id: string;
                                            contentHash: string;
                                        };
                                    } | undefined;
                                    split: "frozen_eval" | "test" | "train" | "validation";
                                    population: {
                                        taskId: string;
                                        seed: string;
                                        fixtureId: string | null;
                                    }[];
                                    evaluators: {
                                        release: {
                                            id: string;
                                            contentHash: string;
                                            revision: string | number;
                                        };
                                        feedbackKey: string;
                                        configurationHash: string;
                                        output: "boolean" | "category" | "score";
                                        categories: string[];
                                    }[];
                                    fieldMappingsHash: string;
                                    fieldMappings: {
                                        graderId: string;
                                        fields: {
                                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                            path: string[];
                                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                            sourcePath: string[];
                                        }[];
                                    }[];
                                    environmentHash: string;
                                    privateDatasetClosureHash: string;
                                    criterion: {
                                        minimumPassRate: number;
                                        requireComplete: boolean;
                                    };
                                    contentHash: string;
                                } | undefined;
                            };
                            population: {
                                receiptId: string;
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                        };
                        maximumCostUsd: number;
                        graders?: {
                            id: string;
                            version: string;
                            contentHash: string;
                            mappings: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[] | undefined;
                        sourceExperimentId?: string | undefined;
                    };
                }[];
                acceptancePlan: {
                    schemaVersion: "openpond.acceptancePlan.v1";
                    id: string;
                    revision: number;
                    checks: {
                        id: string;
                        name: string;
                        required: boolean;
                        role?: "diagnostic" | "quality" | "retention" | undefined;
                        unit?: string | undefined;
                        baselineReuse?: {
                            maximumAgeSeconds: number;
                            qualification: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        dataset: {
                            id: string;
                            contentHash: string;
                        };
                        evaluator: {
                            id: string;
                            contentHash: string;
                        };
                        executionHash: string;
                        populationHash: string;
                        metric: string;
                        direction: "higher" | "lower";
                        minimumCoverage: number;
                        threshold: number;
                        maximumRegression: number;
                        maximumSpendUsd: number;
                    }[];
                    maximumSpendUsd: number;
                    contentHash: string;
                } | null;
            };
            qualification: {
                baseline: {
                    id: string;
                    contentHash: string;
                };
                checks: {
                    id: string;
                    sourceRunId: string;
                    sourceManifestHash: string;
                    targetConfigurationHash: string;
                    executionHash: string;
                    populationHash: string;
                    evaluator: {
                        id: string;
                        contentHash: string;
                    };
                    feedbackKey: string;
                    output: "boolean" | "score";
                    unit: string;
                }[];
            } | null;
            contentHash: string;
            createdAt: string;
        }>;
        get(teamId: string, jobId: string): Promise<{
            schemaVersion: "openpond.postTrainingSummary.v1";
            id: string;
            teamId: string;
            jobId: string;
            revision: number;
            planHash: string;
            automatic: boolean;
            candidate: {
                id: string;
                contentHash: string;
            } | null;
            state: "blocked" | "budget_exhausted" | "cancelled" | "cleaning" | "completed" | "failed" | "preparing" | "queued" | "ready" | "running" | "waiting_for_training";
            total: number;
            completed: number;
            failed: number;
            requiredOutcome: "blocked" | "failed" | "none" | "passed" | "pending";
            reason: string | null;
            groupId: string | null;
            experimentIds: string[];
            updatedAt: string;
        } | null>;
        control(teamId: string, jobId: string, action: "start" | "retry" | "cancel", raw: z.input<typeof import("./post-training.js").PostTrainingControlSchema>): Promise<{
            schemaVersion: "openpond.postTrainingSummary.v1";
            id: string;
            teamId: string;
            jobId: string;
            revision: number;
            planHash: string;
            automatic: boolean;
            candidate: {
                id: string;
                contentHash: string;
            } | null;
            state: "blocked" | "budget_exhausted" | "cancelled" | "cleaning" | "completed" | "failed" | "preparing" | "queued" | "ready" | "running" | "waiting_for_training";
            total: number;
            completed: number;
            failed: number;
            requiredOutcome: "blocked" | "failed" | "none" | "passed" | "pending";
            reason: string | null;
            groupId: string | null;
            experimentIds: string[];
            updatedAt: string;
        }>;
    };
    capabilities(): Promise<{
        schemaVersion: "openpond.trainingCapabilities.v2";
        capabilityHash: string;
        jobKinds: ("policy_optimize" | "reward_model_train")[];
        methods: string[];
        executionModes?: ("qualification" | "training")[] | undefined;
        policyLora?: {
            workerImageDigest: string;
            envelopeRank: number;
            supportedRanks: number[];
            qualification: {
                evidenceRef: string;
                evidenceSha256: string;
            } | null;
            continuation: {
                sharedRequiresSameRank: true;
                mergedRequiresSameRank: true;
                residualAppendRequiresFreeCapacity: true;
                stageOptimizer: "reset";
                interruptedRecoveryOptimizer: "restore";
            };
        } | undefined;
        policyDataParallel?: {
            capability: "managed_rl.policy.data_parallel";
            version: "1";
            gpuCount: 2;
            worldSize: 2;
            backend: "nccl";
            allocationMode: "exclusive";
            workerImageDigest: string;
        } | undefined;
        structuredOutputs?: {
            capability: "work.structured-output.v1";
            harnessRuntimeHash: string;
            workHarnessHash: string;
            schemaHash: string;
            artifactHash: string;
            invalidDataRejected: true;
            invalidBytesRejected: true;
        } | undefined;
        placements: ("colocated" | "local" | "provider_native" | "remote")[];
        controls: {
            cancel: boolean;
            stopAfterGroup: boolean;
            resumeFromCheckpoint: boolean;
        };
        estimates?: {
            schemaVersion: "openpond.trainingEstimate.v1";
        } | undefined;
        limits: {
            maximumSpendUsd: number;
            maximumWallSeconds: number;
            maximumArtifactBytes: number;
        };
        checkedAt: string;
        expiresAt: string;
    }>;
    gpuCatalog(): Promise<{
        schemaVersion: "openpond.trainingGpuCatalog.v1";
        observedAt: string;
        expiresAt: string;
        workerImageDigest: string;
        supportedLoraRanks: number[];
        pricingBasis: "accepted_compute_and_disk_hourly_before_credits";
        offerings: {
            availabilityId: string;
            gpuType: string;
            provider: string;
            region: string;
            dataCenterId: string | null;
            gpuCount: number;
            gpuMemoryGb: number;
            stockStatus: "High" | "Low" | "Medium";
            computeHourlyUsd: number;
            diskHourlyUsd: number;
            totalHourlyUsd: number;
        }[];
    }>;
    stageArtifact(upload: TrainingInputArtifactUpload): Promise<{
        schemaVersion: "openpond.trainingInputArtifact.v2";
        kind: "portable_training_bundle" | "reward_model_dataset";
        sourceManifest: {
            id: string;
            contentHash: string;
        };
        artifactRef: string;
        contentHash: string;
        sizeBytes: number;
        createdAt: string;
    }>;
    createJob(submission: TrainingJobSubmission): Promise<{
        schemaVersion: "openpond.trainingJob.v2";
        id: string;
        teamId: string;
        kind: "policy_optimize" | "reward_model_train";
        executionMode?: "qualification" | undefined;
        recovery?: {
            resourceApproval?: {
                schemaVersion: "openpond.checkpointRecoveryResourceApproval.v1";
                ownerUserId: string;
                teamId: string;
                sourceJobId: string;
                sourceJobVersion: number;
                sourceInputManifestSha256: string;
                checkpointId: string;
                adapterSha256: string;
                resumeSha256: string;
                idempotencyKey: string;
                approvedAt: string;
                maximumSpendUsd: number;
                maximumGpuSeconds: number;
                maximumWallSeconds: number;
                approvalHash: string;
            } | undefined;
            mode?: "evaluation_only" | undefined;
            trainingWorkloadComplete?: boolean | undefined;
            sourceJobId: string;
            checkpointId: string;
            policyVersion: number;
            completedGroups: number;
            optimizerMode: "continue";
        } | undefined;
        modelProjectId: string;
        portableProjectId: string;
        sourceProjectRevision: number;
        submissionHash: string;
        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
        queue?: {
            ticketId: string;
            ticketNumber: number;
            label: "Waiting for resources";
            position: number | null;
            positionScope: "compatible_fair_queue";
            enqueuedAt: string;
            asOf: string;
            estimate: {
                revision: number;
                estimatedStartAt: string;
                expiresAt: string;
                evidence: "measured_bootstrap" | "observed_capacity" | "scheduled_release";
            } | null;
        } | undefined;
        phase: string;
        version: number;
        progress: number;
        rolloutProgress: {
            groupsCompleted: number;
            groupsTarget: number;
            optimizerUpdatesApplied: number;
            optimizerUpdatesSkipped: number;
        };
        accruedSpendUsd: number;
        terminalReason: string | null;
        createdAt: string;
        updatedAt: string;
        completedAt: string | null;
    }>;
    listJobs(options?: {
        modelProjectId?: string;
        cursor?: string;
        limit?: number;
    }): Promise<{
        schemaVersion: "openpond.trainingJobPage.v2";
        jobs: {
            schemaVersion: "openpond.trainingJob.v2";
            id: string;
            teamId: string;
            kind: "policy_optimize" | "reward_model_train";
            executionMode?: "qualification" | undefined;
            recovery?: {
                resourceApproval?: {
                    schemaVersion: "openpond.checkpointRecoveryResourceApproval.v1";
                    ownerUserId: string;
                    teamId: string;
                    sourceJobId: string;
                    sourceJobVersion: number;
                    sourceInputManifestSha256: string;
                    checkpointId: string;
                    adapterSha256: string;
                    resumeSha256: string;
                    idempotencyKey: string;
                    approvedAt: string;
                    maximumSpendUsd: number;
                    maximumGpuSeconds: number;
                    maximumWallSeconds: number;
                    approvalHash: string;
                } | undefined;
                mode?: "evaluation_only" | undefined;
                trainingWorkloadComplete?: boolean | undefined;
                sourceJobId: string;
                checkpointId: string;
                policyVersion: number;
                completedGroups: number;
                optimizerMode: "continue";
            } | undefined;
            modelProjectId: string;
            portableProjectId: string;
            sourceProjectRevision: number;
            submissionHash: string;
            state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
            queue?: {
                ticketId: string;
                ticketNumber: number;
                label: "Waiting for resources";
                position: number | null;
                positionScope: "compatible_fair_queue";
                enqueuedAt: string;
                asOf: string;
                estimate: {
                    revision: number;
                    estimatedStartAt: string;
                    expiresAt: string;
                    evidence: "measured_bootstrap" | "observed_capacity" | "scheduled_release";
                } | null;
            } | undefined;
            phase: string;
            version: number;
            progress: number;
            rolloutProgress: {
                groupsCompleted: number;
                groupsTarget: number;
                optimizerUpdatesApplied: number;
                optimizerUpdatesSkipped: number;
            };
            accruedSpendUsd: number;
            terminalReason: string | null;
            createdAt: string;
            updatedAt: string;
            completedAt: string | null;
        }[];
        nextCursor: string | null;
    }>;
    getJob(jobId: string): Promise<{
        schemaVersion: "openpond.trainingJob.v2";
        id: string;
        teamId: string;
        kind: "policy_optimize" | "reward_model_train";
        executionMode?: "qualification" | undefined;
        recovery?: {
            resourceApproval?: {
                schemaVersion: "openpond.checkpointRecoveryResourceApproval.v1";
                ownerUserId: string;
                teamId: string;
                sourceJobId: string;
                sourceJobVersion: number;
                sourceInputManifestSha256: string;
                checkpointId: string;
                adapterSha256: string;
                resumeSha256: string;
                idempotencyKey: string;
                approvedAt: string;
                maximumSpendUsd: number;
                maximumGpuSeconds: number;
                maximumWallSeconds: number;
                approvalHash: string;
            } | undefined;
            mode?: "evaluation_only" | undefined;
            trainingWorkloadComplete?: boolean | undefined;
            sourceJobId: string;
            checkpointId: string;
            policyVersion: number;
            completedGroups: number;
            optimizerMode: "continue";
        } | undefined;
        modelProjectId: string;
        portableProjectId: string;
        sourceProjectRevision: number;
        submissionHash: string;
        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
        queue?: {
            ticketId: string;
            ticketNumber: number;
            label: "Waiting for resources";
            position: number | null;
            positionScope: "compatible_fair_queue";
            enqueuedAt: string;
            asOf: string;
            estimate: {
                revision: number;
                estimatedStartAt: string;
                expiresAt: string;
                evidence: "measured_bootstrap" | "observed_capacity" | "scheduled_release";
            } | null;
        } | undefined;
        phase: string;
        version: number;
        progress: number;
        rolloutProgress: {
            groupsCompleted: number;
            groupsTarget: number;
            optimizerUpdatesApplied: number;
            optimizerUpdatesSkipped: number;
        };
        accruedSpendUsd: number;
        terminalReason: string | null;
        createdAt: string;
        updatedAt: string;
        completedAt: string | null;
    }>;
    cancelJob(jobId: string, expectedVersion: number): Promise<{
        schemaVersion: "openpond.trainingJob.v2";
        id: string;
        teamId: string;
        kind: "policy_optimize" | "reward_model_train";
        executionMode?: "qualification" | undefined;
        recovery?: {
            resourceApproval?: {
                schemaVersion: "openpond.checkpointRecoveryResourceApproval.v1";
                ownerUserId: string;
                teamId: string;
                sourceJobId: string;
                sourceJobVersion: number;
                sourceInputManifestSha256: string;
                checkpointId: string;
                adapterSha256: string;
                resumeSha256: string;
                idempotencyKey: string;
                approvedAt: string;
                maximumSpendUsd: number;
                maximumGpuSeconds: number;
                maximumWallSeconds: number;
                approvalHash: string;
            } | undefined;
            mode?: "evaluation_only" | undefined;
            trainingWorkloadComplete?: boolean | undefined;
            sourceJobId: string;
            checkpointId: string;
            policyVersion: number;
            completedGroups: number;
            optimizerMode: "continue";
        } | undefined;
        modelProjectId: string;
        portableProjectId: string;
        sourceProjectRevision: number;
        submissionHash: string;
        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
        queue?: {
            ticketId: string;
            ticketNumber: number;
            label: "Waiting for resources";
            position: number | null;
            positionScope: "compatible_fair_queue";
            enqueuedAt: string;
            asOf: string;
            estimate: {
                revision: number;
                estimatedStartAt: string;
                expiresAt: string;
                evidence: "measured_bootstrap" | "observed_capacity" | "scheduled_release";
            } | null;
        } | undefined;
        phase: string;
        version: number;
        progress: number;
        rolloutProgress: {
            groupsCompleted: number;
            groupsTarget: number;
            optimizerUpdatesApplied: number;
            optimizerUpdatesSkipped: number;
        };
        accruedSpendUsd: number;
        terminalReason: string | null;
        createdAt: string;
        updatedAt: string;
        completedAt: string | null;
    }>;
    stopAfterGroup(jobId: string, expectedVersion: number): Promise<{
        schemaVersion: "openpond.trainingJob.v2";
        id: string;
        teamId: string;
        kind: "policy_optimize" | "reward_model_train";
        executionMode?: "qualification" | undefined;
        recovery?: {
            resourceApproval?: {
                schemaVersion: "openpond.checkpointRecoveryResourceApproval.v1";
                ownerUserId: string;
                teamId: string;
                sourceJobId: string;
                sourceJobVersion: number;
                sourceInputManifestSha256: string;
                checkpointId: string;
                adapterSha256: string;
                resumeSha256: string;
                idempotencyKey: string;
                approvedAt: string;
                maximumSpendUsd: number;
                maximumGpuSeconds: number;
                maximumWallSeconds: number;
                approvalHash: string;
            } | undefined;
            mode?: "evaluation_only" | undefined;
            trainingWorkloadComplete?: boolean | undefined;
            sourceJobId: string;
            checkpointId: string;
            policyVersion: number;
            completedGroups: number;
            optimizerMode: "continue";
        } | undefined;
        modelProjectId: string;
        portableProjectId: string;
        sourceProjectRevision: number;
        submissionHash: string;
        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
        queue?: {
            ticketId: string;
            ticketNumber: number;
            label: "Waiting for resources";
            position: number | null;
            positionScope: "compatible_fair_queue";
            enqueuedAt: string;
            asOf: string;
            estimate: {
                revision: number;
                estimatedStartAt: string;
                expiresAt: string;
                evidence: "measured_bootstrap" | "observed_capacity" | "scheduled_release";
            } | null;
        } | undefined;
        phase: string;
        version: number;
        progress: number;
        rolloutProgress: {
            groupsCompleted: number;
            groupsTarget: number;
            optimizerUpdatesApplied: number;
            optimizerUpdatesSkipped: number;
        };
        accruedSpendUsd: number;
        terminalReason: string | null;
        createdAt: string;
        updatedAt: string;
        completedAt: string | null;
    }>;
    recoverCheckpoint(jobId: string, input: z.input<typeof TrainingCheckpointRecoveryRequestSchema>): Promise<{
        schemaVersion: "openpond.trainingJob.v2";
        id: string;
        teamId: string;
        kind: "policy_optimize" | "reward_model_train";
        executionMode?: "qualification" | undefined;
        recovery?: {
            resourceApproval?: {
                schemaVersion: "openpond.checkpointRecoveryResourceApproval.v1";
                ownerUserId: string;
                teamId: string;
                sourceJobId: string;
                sourceJobVersion: number;
                sourceInputManifestSha256: string;
                checkpointId: string;
                adapterSha256: string;
                resumeSha256: string;
                idempotencyKey: string;
                approvedAt: string;
                maximumSpendUsd: number;
                maximumGpuSeconds: number;
                maximumWallSeconds: number;
                approvalHash: string;
            } | undefined;
            mode?: "evaluation_only" | undefined;
            trainingWorkloadComplete?: boolean | undefined;
            sourceJobId: string;
            checkpointId: string;
            policyVersion: number;
            completedGroups: number;
            optimizerMode: "continue";
        } | undefined;
        modelProjectId: string;
        portableProjectId: string;
        sourceProjectRevision: number;
        submissionHash: string;
        state: "admitting" | "cancelled" | "cancelling" | "failed" | "provisioning" | "queued" | "running" | "stopping" | "succeeded";
        queue?: {
            ticketId: string;
            ticketNumber: number;
            label: "Waiting for resources";
            position: number | null;
            positionScope: "compatible_fair_queue";
            enqueuedAt: string;
            asOf: string;
            estimate: {
                revision: number;
                estimatedStartAt: string;
                expiresAt: string;
                evidence: "measured_bootstrap" | "observed_capacity" | "scheduled_release";
            } | null;
        } | undefined;
        phase: string;
        version: number;
        progress: number;
        rolloutProgress: {
            groupsCompleted: number;
            groupsTarget: number;
            optimizerUpdatesApplied: number;
            optimizerUpdatesSkipped: number;
        };
        accruedSpendUsd: number;
        terminalReason: string | null;
        createdAt: string;
        updatedAt: string;
        completedAt: string | null;
    }>;
    events(jobId: string): Promise<{
        schemaVersion: "openpond.trainingJobEvent.v2";
        id: string;
        jobId: string;
        sequence: number;
        type: string;
        phase: string;
        message: string | null;
        data: Record<string, unknown>;
        createdAt: string;
    }[]>;
    outputs(jobId: string): Promise<{
        schemaVersion: "openpond.trainingJobOutputs.v2";
        outputs: {
            schemaVersion: "openpond.trainingJobOutput.v2";
            id: string;
            jobId: string;
            kind: "adapter" | "checkpoint" | "evaluation" | "metrics" | "receipt" | "scorer" | "trace";
            artifactRef: string;
            contentHash: string;
            sizeBytes: number;
            metadata: Record<string, unknown>;
            createdAt: string;
        }[];
        receipt: {
            schemaVersion: "openpond.trainingExecutionReceipt.v2";
            id: string;
            teamId: string;
            jobId: string;
            submissionHash: string;
            manifestHash: string;
            recipeHash: string;
            capabilityHash: string;
            runtimeRelease: {
                id: string;
                contentHash: string;
            };
            inputs: {
                id: string;
                contentHash: string;
            }[];
            outputs: {
                id: string;
                contentHash: string;
            }[];
            spendUsd: number;
            durationSeconds: number;
            cleanupComplete: boolean;
            qualification?: {
                schemaVersion: "openpond.trainingQualificationEvidence.v1";
                baseModel: {
                    schemaVersion: "openpond.baseModelPreference.v1";
                    modelId: string;
                    modelAssetId: string | null;
                    source: "builtin" | "local" | "managed";
                    revision: string;
                    tokenizerRevision: string;
                    chatTemplateHash: string;
                };
                group: {
                    id: string;
                    contentHash: string;
                };
                rolloutReceipts: {
                    id: string;
                    contentHash: string;
                }[];
                rewardEvidenceHash: string;
                groupsCompleted: 1;
                optimizerUpdatesApplied: 0;
                optimizerUpdatesSkipped: 0;
                trainingStepsCreated: 0;
                checkpointsCreated: 0;
                artifactsCreated: 0;
            } | undefined;
            issuer: string;
            issuedAt: string;
            signature: string | null;
        } | null;
    }>;
    evaluationTasks(jobId: string, evaluation: {
        id: string;
        contentHash: string;
    }, options?: {
        cursor?: string;
        limit?: number;
    }): Promise<{
        schemaVersion: "openpond.trainingEvaluationTaskPage.v1";
        jobId: string;
        teamId: string;
        evaluation: {
            id: string;
            contentHash: string;
        };
        kind: "baseline" | "candidate";
        policyVersion: number;
        taskset: {
            id: string;
            contentHash: string;
            revision: number;
        };
        panelSha256: string;
        offset: number;
        total: number;
        tasks: {
            taskId: string;
            taskSha256: string;
            resultSha256: string;
            input: {
                instruction: string;
                context: Record<string, unknown>;
            };
            output: string;
            outputSha256: string;
            score: number;
            evidence: {
                kind: "hosted_trace" | "local_trace" | "worker_command";
                id: string;
            };
        }[];
        nextCursor: string | null;
        contentHash: string;
    }>;
    logs(jobId: string): Promise<{
        schemaVersion: "openpond.trainingJobLog.v2";
        jobId: string;
        sequence: number;
        level: "debug" | "error" | "info" | "warning";
        message: string;
        createdAt: string;
    }[]>;
};
//# sourceMappingURL=training.d.ts.map