import { type TrainingHandoffOrigin } from "./post-training.js";
import { type TrainingPhysicalPlacement } from "./training-physical-placement.js";
import { type TrainingGpuSelection } from "./training-compute-selection.js";
import type { ModelProject } from "./model-projects.js";
import { type HarnessRunManifest, type ResolvedTrainingBundleManifest } from "./training-bundle-contracts.js";
import { type TrainingEvaluationSource } from "./training-evaluation-source.js";
import { type TrainingJobSubmission } from "./training.js";
type PolicyJob = Extract<TrainingJobSubmission["job"], {
    kind: "policy_optimize";
}>;
export type TrainingPreparationFile = TrainingEvaluationSource["assets"][number];
export interface ManagedTrainingPreparationInput {
    gpuSelection?: TrainingGpuSelection;
    physicalPlacement?: TrainingPhysicalPlacement;
    origin?: TrainingHandoffOrigin;
    executionMode?: "qualification";
    project: ModelProject;
    manifest: HarnessRunManifest;
    recipe: PolicyJob["recipe"];
    taskset: TrainingJobSubmission["source"]["taskset"];
    bundleManifest: ResolvedTrainingBundleManifest;
    files: TrainingPreparationFile[];
    evaluationSource?: TrainingEvaluationSource;
    rewardSource: PolicyJob["rewardSource"];
    resumeFrom: PolicyJob["resumeFrom"];
    approval: Pick<TrainingJobSubmission["approval"], "approvalHash" | "maximumSpendUsd" | "retentionDays" | "region">;
    modelImprovementQualification?: {
        id: string;
        contentHash: string;
    } | null;
    /** A durable hosted iteration supplies its dispatch identity here. */
    idempotencyKey?: string;
}
/** Build the exact staged artifact and public Job without network or compute.
 * Inputs are copied before hashing so an asynchronous caller cannot rewrite the
 * selected bytes while preparation is in progress.
 */
export declare function prepareManagedTrainingSubmission(raw: ManagedTrainingPreparationInput): Promise<{
    artifact: {
        schemaVersion: "openpond.trainingInputArtifactUpload.v2";
        kind: "portable_training_bundle" | "reward_model_dataset";
        idempotencyKey: string;
        sourceManifest: {
            id: string;
            contentHash: string;
        };
        payload: unknown;
        contentHash: string;
    };
    submission: {
        schemaVersion: "openpond.trainingJobSubmission.v2";
        idempotencyKey: string;
        name: 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;
            }[];
        };
        job: {
            kind: "reward_model_train";
            baseModel: {
                schemaVersion: "openpond.baseModelPreference.v1";
                modelId: string;
                revision: string | null;
                tokenizerRevision: string | null;
                chatTemplateHash: string | null;
                modelAssetId: string | null;
                source: "builtin" | "local" | "managed";
            };
            preferenceDatasetRelease: {
                id: string;
                contentHash: string;
            };
            processorRelease: {
                id: string;
                contentHash: string;
            };
            recipe: {
                [x: string]: unknown;
                schemaVersion: "openpond.rewardModelRecipe.v1";
                method: "reward_model";
                parameterization: "lora_with_scalar_head";
            };
        } | {
            kind: "policy_optimize";
            executionMode?: "qualification" | undefined;
            baseModel: {
                schemaVersion: "openpond.baseModelPreference.v1";
                modelId: string;
                revision: string | null;
                tokenizerRevision: string | null;
                chatTemplateHash: string | null;
                modelAssetId: string | null;
                source: "builtin" | "local" | "managed";
            };
            recipe: {
                [x: string]: unknown;
                schemaVersion: string;
                method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
                parameterization: "full" | "lora";
            };
            rewardSource: {
                kind: "deterministic";
                grader: {
                    id: string;
                    contentHash: string;
                };
                composer: {
                    id: string;
                    contentHash: string;
                } | null;
            } | {
                kind: "learned_reward";
                rewardModelVersion: {
                    id: string;
                    contentHash: string;
                };
                qualificationReport: {
                    id: string;
                    contentHash: string;
                } | null;
                evaluationReferences: {
                    id: string;
                    contentHash: string;
                }[];
                scorerArtifact: {
                    artifactRef: string;
                    contentHash: string;
                    executionReceipt: {
                        id: string;
                        contentHash: string;
                    };
                };
                processorRelease: {
                    id: string;
                    contentHash: string;
                };
                rewardComposerRelease: {
                    id: string;
                    contentHash: string;
                };
            };
            resumeFrom: {
                id: string;
                contentHash: string;
            } | null;
        };
        requestedCapabilities: {
            id: string;
            version: string | null;
            required: boolean;
        }[];
        placementObjective: "balanced" | "economical" | "fast";
        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;
        budget: {
            maximumSpendUsd: number;
            maximumWallSeconds: number;
        };
        approval: {
            approvalHash: string;
            approvedAt: string;
            exportApproved: boolean;
            maximumSpendUsd: number;
            retentionDays: number | null;
            region: string | null;
        };
        contentHash: string;
    };
}>;
export {};
//# sourceMappingURL=managed-training-preparation.d.ts.map