import { type EvaluationCoordinationAccess } from "./evaluation-coordination-http.js";
import { z } from "zod";
import { RunExperimentSchema } from "./experiments.js";
export declare const ExperimentEvaluationScheduleInputSchema: z.ZodObject<{
    operationId: z.ZodString;
    id: z.ZodOptional<z.ZodString>;
    expectedRevision: z.ZodNumber;
    teamId: z.ZodString;
    projectId: z.ZodNullable<z.ZodString>;
    enabled: z.ZodBoolean;
    configuration: z.ZodObject<{
        operationId: z.ZodString;
        request: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.modelTasksetRunRequest.v1">;
            operationId: z.ZodString;
            teamId: z.ZodString;
            modelProjectId: z.ZodNullable<z.ZodString>;
            name: z.ZodOptional<z.ZodString>;
            project: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                revision: z.ZodNumber;
                contentHash: z.ZodString;
                targetId: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            taskset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"hosted_chat">;
                modelId: z.ZodString;
                localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                    providerId: z.ZodLiteral<"custom-openai-compatible">;
                    configurationHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"claude-code">;
                    configurationHash: z.ZodString;
                    executableHash: z.ZodString;
                    version: z.ZodString;
                    capabilityHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                    maximumTurns: z.ZodNumber;
                    holdOpen: z.ZodBoolean;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"codex">;
                    configurationHash: z.ZodString;
                    accountHash: z.ZodString;
                    reasoningEffort: z.ZodEnum<{
                        high: "high";
                        low: "low";
                        medium: "medium";
                        xhigh: "xhigh";
                    }>;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>]>>;
                candidate: z.ZodOptional<z.ZodObject<{
                    artifactId: z.ZodString;
                    contentHash: z.ZodString;
                    preparationId: z.ZodString;
                    dispatchId: z.ZodString;
                    baseProfileId: z.ZodString;
                    workerImageDigest: z.ZodString;
                }, z.core.$strict>>;
                harness: z.ZodOptional<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>>;
                messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    role: z.ZodEnum<{
                        assistant: "assistant";
                        system: "system";
                        user: "user";
                    }>;
                    content: z.ZodString;
                }, z.core.$strict>>>;
                maxOutputTokens: z.ZodDefault<z.ZodNumber>;
                temperature: z.ZodDefault<z.ZodNumber>;
                topP: z.ZodDefault<z.ZodNumber>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fixture">;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"hosted_harness">;
                modelId: z.ZodString;
                maxOutputTokens: z.ZodOptional<z.ZodNumber>;
                temperature: z.ZodOptional<z.ZodNumber>;
                topP: z.ZodOptional<z.ZodNumber>;
                localRuntime: z.ZodOptional<z.ZodObject<{
                    providerId: z.ZodLiteral<"codex">;
                    configurationHash: z.ZodString;
                    accountHash: z.ZodString;
                    reasoningEffort: z.ZodEnum<{
                        high: "high";
                        low: "low";
                        medium: "medium";
                        xhigh: "xhigh";
                    }>;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>>;
                candidate: z.ZodOptional<z.ZodObject<{
                    artifactId: z.ZodString;
                    contentHash: z.ZodString;
                    preparationId: z.ZodString;
                    dispatchId: z.ZodString;
                    baseProfileId: z.ZodString;
                    workerImageDigest: 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>>;
                reasoningEffort: z.ZodOptional<z.ZodEnum<{
                    high: "high";
                    low: "low";
                    max: "max";
                    medium: "medium";
                    off: "off";
                    xhigh: "xhigh";
                }>>;
                profileRepositoryId: z.ZodString;
                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>;
                modelConfigurationHash: z.ZodString;
                packageHash: 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>>;
            }, z.core.$strict>], "kind">;
            population: z.ZodArray<z.ZodObject<{
                receiptId: z.ZodString;
                taskId: z.ZodString;
                seed: z.ZodString;
                fixtureId: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
        }, z.core.$strict>;
        maximumCostUsd: z.ZodNumber;
        graders: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            version: z.ZodString;
            contentHash: z.ZodString;
            mappings: 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>>>;
        sourceExperimentId: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"interval">;
        seconds: z.ZodNumber;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"nightly">;
        calendar: z.ZodObject<{
            localTime: z.ZodString;
            timeZone: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>], "kind">;
    maximumTotalSpendUsd: z.ZodNumber;
    maximumAttempts: z.ZodNumber;
}, z.core.$strict>;
export declare const ExperimentEvaluationFireSchema: z.ZodObject<{
    id: z.ZodString;
    scheduledAt: z.ZodString;
    coalescedThroughAt: z.ZodString;
    coalescedCount: z.ZodNumber;
    configurationHash: z.ZodString;
    operationId: z.ZodString;
    state: z.ZodEnum<{
        cancelled: "cancelled";
        cleaning: "cleaning";
        completed: "completed";
        dispatching: "dispatching";
        failed: "failed";
        reserved: "reserved";
        running: "running";
        uncertain: "uncertain";
    }>;
    executionId: z.ZodNullable<z.ZodString>;
    attempt: z.ZodNumber;
    maximumCostUsd: z.ZodNumber;
    actualSpendUsd: z.ZodNullable<z.ZodNumber>;
    cleanupComplete: z.ZodBoolean;
    error: z.ZodNullable<z.ZodString>;
}, z.core.$strict>;
export declare const ExperimentEvaluationScheduleSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.experimentEvaluationSchedule.v1">;
    id: z.ZodString;
    revision: z.ZodNumber;
    actorId: z.ZodString;
    teamId: z.ZodString;
    projectId: z.ZodNullable<z.ZodString>;
    operationId: z.ZodString;
    requestHash: z.ZodString;
    configuration: z.ZodObject<{
        operationId: z.ZodString;
        request: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.modelTasksetRunRequest.v1">;
            operationId: z.ZodString;
            teamId: z.ZodString;
            modelProjectId: z.ZodNullable<z.ZodString>;
            name: z.ZodOptional<z.ZodString>;
            project: z.ZodOptional<z.ZodObject<{
                id: z.ZodString;
                revision: z.ZodNumber;
                contentHash: z.ZodString;
                targetId: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            taskset: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
                revision: z.ZodNumber;
            }, z.core.$strict>;
            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"hosted_chat">;
                modelId: z.ZodString;
                localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                    providerId: z.ZodLiteral<"custom-openai-compatible">;
                    configurationHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"claude-code">;
                    configurationHash: z.ZodString;
                    executableHash: z.ZodString;
                    version: z.ZodString;
                    capabilityHash: z.ZodString;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                    maximumTurns: z.ZodNumber;
                    holdOpen: z.ZodBoolean;
                }, z.core.$strict>, z.ZodObject<{
                    providerId: z.ZodLiteral<"codex">;
                    configurationHash: z.ZodString;
                    accountHash: z.ZodString;
                    reasoningEffort: z.ZodEnum<{
                        high: "high";
                        low: "low";
                        medium: "medium";
                        xhigh: "xhigh";
                    }>;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>]>>;
                candidate: z.ZodOptional<z.ZodObject<{
                    artifactId: z.ZodString;
                    contentHash: z.ZodString;
                    preparationId: z.ZodString;
                    dispatchId: z.ZodString;
                    baseProfileId: z.ZodString;
                    workerImageDigest: z.ZodString;
                }, z.core.$strict>>;
                harness: z.ZodOptional<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>>;
                messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    role: z.ZodEnum<{
                        assistant: "assistant";
                        system: "system";
                        user: "user";
                    }>;
                    content: z.ZodString;
                }, z.core.$strict>>>;
                maxOutputTokens: z.ZodDefault<z.ZodNumber>;
                temperature: z.ZodDefault<z.ZodNumber>;
                topP: z.ZodDefault<z.ZodNumber>;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fixture">;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"hosted_harness">;
                modelId: z.ZodString;
                maxOutputTokens: z.ZodOptional<z.ZodNumber>;
                temperature: z.ZodOptional<z.ZodNumber>;
                topP: z.ZodOptional<z.ZodNumber>;
                localRuntime: z.ZodOptional<z.ZodObject<{
                    providerId: z.ZodLiteral<"codex">;
                    configurationHash: z.ZodString;
                    accountHash: z.ZodString;
                    reasoningEffort: z.ZodEnum<{
                        high: "high";
                        low: "low";
                        medium: "medium";
                        xhigh: "xhigh";
                    }>;
                    maximumRequestCostUsd: z.ZodNumber;
                    requestTimeoutMs: z.ZodNumber;
                }, z.core.$strict>>;
                candidate: z.ZodOptional<z.ZodObject<{
                    artifactId: z.ZodString;
                    contentHash: z.ZodString;
                    preparationId: z.ZodString;
                    dispatchId: z.ZodString;
                    baseProfileId: z.ZodString;
                    workerImageDigest: 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>>;
                reasoningEffort: z.ZodOptional<z.ZodEnum<{
                    high: "high";
                    low: "low";
                    max: "max";
                    medium: "medium";
                    off: "off";
                    xhigh: "xhigh";
                }>>;
                profileRepositoryId: z.ZodString;
                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>;
                modelConfigurationHash: z.ZodString;
                packageHash: 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>>;
            }, z.core.$strict>], "kind">;
            population: z.ZodArray<z.ZodObject<{
                receiptId: z.ZodString;
                taskId: z.ZodString;
                seed: z.ZodString;
                fixtureId: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
        }, z.core.$strict>;
        maximumCostUsd: z.ZodNumber;
        graders: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            version: z.ZodString;
            contentHash: z.ZodString;
            mappings: 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>>>;
        sourceExperimentId: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    configurationHash: z.ZodString;
    cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"interval">;
        seconds: z.ZodNumber;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"nightly">;
        calendar: z.ZodObject<{
            localTime: z.ZodString;
            timeZone: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>], "kind">;
    state: z.ZodEnum<{
        blocked: "blocked";
        disabled: "disabled";
        scheduled: "scheduled";
    }>;
    nextRunAt: z.ZodNullable<z.ZodString>;
    maximumTotalSpendUsd: z.ZodNumber;
    maximumAttempts: z.ZodNumber;
    lastEvaluatedConfigurationHash: z.ZodNullable<z.ZodString>;
    newerUnevaluatedRelease: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    fires: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        scheduledAt: z.ZodString;
        coalescedThroughAt: z.ZodString;
        coalescedCount: z.ZodNumber;
        configurationHash: z.ZodString;
        operationId: z.ZodString;
        state: z.ZodEnum<{
            cancelled: "cancelled";
            cleaning: "cleaning";
            completed: "completed";
            dispatching: "dispatching";
            failed: "failed";
            reserved: "reserved";
            running: "running";
            uncertain: "uncertain";
        }>;
        executionId: z.ZodNullable<z.ZodString>;
        attempt: z.ZodNumber;
        maximumCostUsd: z.ZodNumber;
        actualSpendUsd: z.ZodNullable<z.ZodNumber>;
        cleanupComplete: z.ZodBoolean;
        error: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>>;
    reason: z.ZodNullable<z.ZodString>;
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type ExperimentEvaluationSchedule = z.infer<typeof ExperimentEvaluationScheduleSchema>;
export type ExperimentEvaluationScheduleInput = z.infer<typeof ExperimentEvaluationScheduleInputSchema>;
export type ExperimentEvaluationFire = z.infer<typeof ExperimentEvaluationFireSchema>;
export declare function scheduledExperimentHash(value: z.infer<typeof RunExperimentSchema>): string;
export declare function verifyExperimentEvaluationSchedule(raw: unknown): {
    schemaVersion: "openpond.experimentEvaluationSchedule.v1";
    id: string;
    revision: number;
    actorId: string;
    teamId: string;
    projectId: string | null;
    operationId: string;
    requestHash: 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;
    };
    configurationHash: string;
    cadence: {
        kind: "interval";
        seconds: number;
    } | {
        kind: "nightly";
        calendar: {
            localTime: string;
            timeZone: string;
        };
    };
    state: "blocked" | "disabled" | "scheduled";
    nextRunAt: string | null;
    maximumTotalSpendUsd: number;
    maximumAttempts: number;
    lastEvaluatedConfigurationHash: string | null;
    newerUnevaluatedRelease: {
        id: string;
        contentHash: string;
    } | null;
    fires: {
        id: string;
        scheduledAt: string;
        coalescedThroughAt: string;
        coalescedCount: number;
        configurationHash: string;
        operationId: string;
        state: "cancelled" | "cleaning" | "completed" | "dispatching" | "failed" | "reserved" | "running" | "uncertain";
        executionId: string | null;
        attempt: number;
        maximumCostUsd: number;
        actualSpendUsd: number | null;
        cleanupComplete: boolean;
        error: string | null;
    }[];
    reason: string | null;
    createdAt: string;
    updatedAt: string;
    contentHash: string;
};
export declare function sealExperimentEvaluationSchedule(value: Omit<ExperimentEvaluationSchedule, "contentHash">): {
    schemaVersion: "openpond.experimentEvaluationSchedule.v1";
    id: string;
    revision: number;
    actorId: string;
    teamId: string;
    projectId: string | null;
    operationId: string;
    requestHash: 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;
    };
    configurationHash: string;
    cadence: {
        kind: "interval";
        seconds: number;
    } | {
        kind: "nightly";
        calendar: {
            localTime: string;
            timeZone: string;
        };
    };
    state: "blocked" | "disabled" | "scheduled";
    nextRunAt: string | null;
    maximumTotalSpendUsd: number;
    maximumAttempts: number;
    lastEvaluatedConfigurationHash: string | null;
    newerUnevaluatedRelease: {
        id: string;
        contentHash: string;
    } | null;
    fires: {
        id: string;
        scheduledAt: string;
        coalescedThroughAt: string;
        coalescedCount: number;
        configurationHash: string;
        operationId: string;
        state: "cancelled" | "cleaning" | "completed" | "dispatching" | "failed" | "reserved" | "running" | "uncertain";
        executionId: string | null;
        attempt: number;
        maximumCostUsd: number;
        actualSpendUsd: number | null;
        cleanupComplete: boolean;
        error: string | null;
    }[];
    reason: string | null;
    createdAt: string;
    updatedAt: string;
    contentHash: string;
};
export declare const ExperimentEvaluationScheduleControlSchema: z.ZodObject<{
    teamId: z.ZodString;
    id: z.ZodString;
    operationId: z.ZodString;
    expectedRevision: z.ZodNumber;
    action: z.ZodEnum<{
        cancel_active: "cancel_active";
        pause: "pause";
        retry_active: "retry_active";
    }>;
}, z.core.$strict>;
export declare const ExperimentEvaluationScheduleCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    operation: z.ZodLiteral<"publish">;
    request: z.ZodObject<{
        operationId: z.ZodString;
        id: z.ZodOptional<z.ZodString>;
        expectedRevision: z.ZodNumber;
        teamId: z.ZodString;
        projectId: z.ZodNullable<z.ZodString>;
        enabled: z.ZodBoolean;
        configuration: z.ZodObject<{
            operationId: z.ZodString;
            request: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.modelTasksetRunRequest.v1">;
                operationId: z.ZodString;
                teamId: z.ZodString;
                modelProjectId: z.ZodNullable<z.ZodString>;
                name: z.ZodOptional<z.ZodString>;
                project: z.ZodOptional<z.ZodObject<{
                    id: z.ZodString;
                    revision: z.ZodNumber;
                    contentHash: z.ZodString;
                    targetId: z.ZodNullable<z.ZodString>;
                }, z.core.$strict>>;
                taskset: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                    revision: z.ZodNumber;
                }, z.core.$strict>;
                policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"hosted_chat">;
                    modelId: z.ZodString;
                    localRuntime: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                        providerId: z.ZodLiteral<"custom-openai-compatible">;
                        configurationHash: z.ZodString;
                        maximumRequestCostUsd: z.ZodNumber;
                        requestTimeoutMs: z.ZodNumber;
                    }, z.core.$strict>, z.ZodObject<{
                        providerId: z.ZodLiteral<"claude-code">;
                        configurationHash: z.ZodString;
                        executableHash: z.ZodString;
                        version: z.ZodString;
                        capabilityHash: z.ZodString;
                        maximumRequestCostUsd: z.ZodNumber;
                        requestTimeoutMs: z.ZodNumber;
                        maximumTurns: z.ZodNumber;
                        holdOpen: z.ZodBoolean;
                    }, z.core.$strict>, z.ZodObject<{
                        providerId: z.ZodLiteral<"codex">;
                        configurationHash: z.ZodString;
                        accountHash: z.ZodString;
                        reasoningEffort: z.ZodEnum<{
                            high: "high";
                            low: "low";
                            medium: "medium";
                            xhigh: "xhigh";
                        }>;
                        maximumRequestCostUsd: z.ZodNumber;
                        requestTimeoutMs: z.ZodNumber;
                    }, z.core.$strict>]>>;
                    candidate: z.ZodOptional<z.ZodObject<{
                        artifactId: z.ZodString;
                        contentHash: z.ZodString;
                        preparationId: z.ZodString;
                        dispatchId: z.ZodString;
                        baseProfileId: z.ZodString;
                        workerImageDigest: z.ZodString;
                    }, z.core.$strict>>;
                    harness: z.ZodOptional<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>>;
                    messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        role: z.ZodEnum<{
                            assistant: "assistant";
                            system: "system";
                            user: "user";
                        }>;
                        content: z.ZodString;
                    }, z.core.$strict>>>;
                    maxOutputTokens: z.ZodDefault<z.ZodNumber>;
                    temperature: z.ZodDefault<z.ZodNumber>;
                    topP: z.ZodDefault<z.ZodNumber>;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"fixture">;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"hosted_harness">;
                    modelId: z.ZodString;
                    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
                    temperature: z.ZodOptional<z.ZodNumber>;
                    topP: z.ZodOptional<z.ZodNumber>;
                    localRuntime: z.ZodOptional<z.ZodObject<{
                        providerId: z.ZodLiteral<"codex">;
                        configurationHash: z.ZodString;
                        accountHash: z.ZodString;
                        reasoningEffort: z.ZodEnum<{
                            high: "high";
                            low: "low";
                            medium: "medium";
                            xhigh: "xhigh";
                        }>;
                        maximumRequestCostUsd: z.ZodNumber;
                        requestTimeoutMs: z.ZodNumber;
                    }, z.core.$strict>>;
                    candidate: z.ZodOptional<z.ZodObject<{
                        artifactId: z.ZodString;
                        contentHash: z.ZodString;
                        preparationId: z.ZodString;
                        dispatchId: z.ZodString;
                        baseProfileId: z.ZodString;
                        workerImageDigest: 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>>;
                    reasoningEffort: z.ZodOptional<z.ZodEnum<{
                        high: "high";
                        low: "low";
                        max: "max";
                        medium: "medium";
                        off: "off";
                        xhigh: "xhigh";
                    }>>;
                    profileRepositoryId: z.ZodString;
                    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>;
                    modelConfigurationHash: z.ZodString;
                    packageHash: 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>>;
                }, z.core.$strict>], "kind">;
                population: z.ZodArray<z.ZodObject<{
                    receiptId: z.ZodString;
                    taskId: z.ZodString;
                    seed: z.ZodString;
                    fixtureId: z.ZodNullable<z.ZodString>;
                }, z.core.$strict>>;
            }, z.core.$strict>;
            maximumCostUsd: z.ZodNumber;
            graders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                version: z.ZodString;
                contentHash: z.ZodString;
                mappings: 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>>>;
            sourceExperimentId: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>;
        cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"interval">;
            seconds: z.ZodNumber;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"nightly">;
            calendar: z.ZodObject<{
                localTime: z.ZodString;
                timeZone: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>], "kind">;
        maximumTotalSpendUsd: z.ZodNumber;
        maximumAttempts: z.ZodNumber;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodLiteral<"control">;
    request: z.ZodObject<{
        teamId: z.ZodString;
        id: z.ZodString;
        operationId: z.ZodString;
        expectedRevision: z.ZodNumber;
        action: z.ZodEnum<{
            cancel_active: "cancel_active";
            pause: "pause";
            retry_active: "retry_active";
        }>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodLiteral<"read">;
    id: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodLiteral<"list">;
    cursor: z.ZodOptional<z.ZodString>;
    limit: z.ZodDefault<z.ZodNumber>;
}, z.core.$strict>], "operation">;
export declare class OpenPondExperimentEvaluationScheduleClient {
    private readonly transport;
    constructor(access: EvaluationCoordinationAccess);
    command(raw: z.input<typeof ExperimentEvaluationScheduleCommandSchema>, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.experimentEvaluationSchedule.v1";
        id: string;
        revision: number;
        actorId: string;
        teamId: string;
        projectId: string | null;
        operationId: string;
        requestHash: 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;
        };
        configurationHash: string;
        cadence: {
            kind: "interval";
            seconds: number;
        } | {
            kind: "nightly";
            calendar: {
                localTime: string;
                timeZone: string;
            };
        };
        state: "blocked" | "disabled" | "scheduled";
        nextRunAt: string | null;
        maximumTotalSpendUsd: number;
        maximumAttempts: number;
        lastEvaluatedConfigurationHash: string | null;
        newerUnevaluatedRelease: {
            id: string;
            contentHash: string;
        } | null;
        fires: {
            id: string;
            scheduledAt: string;
            coalescedThroughAt: string;
            coalescedCount: number;
            configurationHash: string;
            operationId: string;
            state: "cancelled" | "cleaning" | "completed" | "dispatching" | "failed" | "reserved" | "running" | "uncertain";
            executionId: string | null;
            attempt: number;
            maximumCostUsd: number;
            actualSpendUsd: number | null;
            cleanupComplete: boolean;
            error: string | null;
        }[];
        reason: string | null;
        createdAt: string;
        updatedAt: string;
        contentHash: string;
    } | {
        items: {
            schemaVersion: "openpond.experimentEvaluationSchedule.v1";
            id: string;
            revision: number;
            actorId: string;
            teamId: string;
            projectId: string | null;
            operationId: string;
            requestHash: 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;
            };
            configurationHash: string;
            cadence: {
                kind: "interval";
                seconds: number;
            } | {
                kind: "nightly";
                calendar: {
                    localTime: string;
                    timeZone: string;
                };
            };
            state: "blocked" | "disabled" | "scheduled";
            nextRunAt: string | null;
            maximumTotalSpendUsd: number;
            maximumAttempts: number;
            lastEvaluatedConfigurationHash: string | null;
            newerUnevaluatedRelease: {
                id: string;
                contentHash: string;
            } | null;
            fires: {
                id: string;
                scheduledAt: string;
                coalescedThroughAt: string;
                coalescedCount: number;
                configurationHash: string;
                operationId: string;
                state: "cancelled" | "cleaning" | "completed" | "dispatching" | "failed" | "reserved" | "running" | "uncertain";
                executionId: string | null;
                attempt: number;
                maximumCostUsd: number;
                actualSpendUsd: number | null;
                cleanupComplete: boolean;
                error: string | null;
            }[];
            reason: string | null;
            createdAt: string;
            updatedAt: string;
            contentHash: string;
        }[];
        nextCursor: string | null;
    }>;
}
//# sourceMappingURL=experiment-evaluation-schedules.d.ts.map