import { type EvaluationCoordinationAccess } from "./evaluation-coordination-http.js";
import { z } from "zod";
export declare const AdvancedRefinerEvaluationPinSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
    operationId: z.ZodString;
    actorId: z.ZodString;
    teamId: z.ZodString;
    projectId: z.ZodNullable<z.ZodString>;
    mode: z.ZodEnum<{
        downstream_adaptation: "downstream_adaptation";
        review_quality: "review_quality";
    }>;
    profileRef: z.ZodObject<{
        source: z.ZodEnum<{
            github: "github";
            local: "local";
            openpond_git: "openpond_git";
        }>;
        repositoryId: z.ZodString;
        profileId: z.ZodString;
    }, z.core.$strict>;
    sourceRevision: z.ZodString;
    baselineRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    refinerRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    evidence: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    externalDatasetBinding: 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>;
    adaptationDatasetBinding: 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>;
    privateClosureHash: z.ZodString;
    adaptationTaskIds: z.ZodArray<z.ZodString>;
    holdoutTaskIds: z.ZodArray<z.ZodString>;
    adaptationSplit: z.ZodEnum<{
        frozen_eval: "frozen_eval";
        test: "test";
        train: "train";
        validation: "validation";
    }>;
    holdoutSplit: z.ZodEnum<{
        frozen_eval: "frozen_eval";
        test: "test";
        train: "train";
        validation: "validation";
    }>;
    environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"resettable">;
        environmentHash: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"frozen_observations">;
        environmentHash: z.ZodString;
    }, z.core.$strict>], "kind">;
    maximumCostUsd: z.ZodNumber;
    maximumDurationMs: z.ZodNumber;
    maximumModelSteps: z.ZodNumber;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type AdvancedRefinerEvaluationPin = z.infer<typeof AdvancedRefinerEvaluationPinSchema>;
export declare function verifyAdvancedRefinerEvaluationPin(raw: unknown): {
    schemaVersion: "openpond.advancedRefinerEvaluation.v1";
    operationId: string;
    actorId: string;
    teamId: string;
    projectId: string | null;
    mode: "downstream_adaptation" | "review_quality";
    profileRef: {
        source: "github" | "local" | "openpond_git";
        repositoryId: string;
        profileId: string;
    };
    sourceRevision: string;
    baselineRelease: {
        id: string;
        contentHash: string;
    };
    refinerRelease: {
        id: string;
        contentHash: string;
    };
    evidence: {
        id: string;
        contentHash: 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;
    };
    adaptationDatasetBinding: {
        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;
    };
    privateClosureHash: string;
    adaptationTaskIds: string[];
    holdoutTaskIds: string[];
    adaptationSplit: "frozen_eval" | "test" | "train" | "validation";
    holdoutSplit: "frozen_eval" | "test" | "train" | "validation";
    environmentPolicy: {
        kind: "resettable";
        environmentHash: string;
    } | {
        kind: "frozen_observations";
        environmentHash: string;
    };
    maximumCostUsd: number;
    maximumDurationMs: number;
    maximumModelSteps: number;
    contentHash: string;
};
export declare function sealAdvancedRefinerEvaluationPin(body: Omit<AdvancedRefinerEvaluationPin, "contentHash">): {
    schemaVersion: "openpond.advancedRefinerEvaluation.v1";
    operationId: string;
    actorId: string;
    teamId: string;
    projectId: string | null;
    mode: "downstream_adaptation" | "review_quality";
    profileRef: {
        source: "github" | "local" | "openpond_git";
        repositoryId: string;
        profileId: string;
    };
    sourceRevision: string;
    baselineRelease: {
        id: string;
        contentHash: string;
    };
    refinerRelease: {
        id: string;
        contentHash: string;
    };
    evidence: {
        id: string;
        contentHash: 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;
    };
    adaptationDatasetBinding: {
        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;
    };
    privateClosureHash: string;
    adaptationTaskIds: string[];
    holdoutTaskIds: string[];
    adaptationSplit: "frozen_eval" | "test" | "train" | "validation";
    holdoutSplit: "frozen_eval" | "test" | "train" | "validation";
    environmentPolicy: {
        kind: "resettable";
        environmentHash: string;
    } | {
        kind: "frozen_observations";
        environmentHash: string;
    };
    maximumCostUsd: number;
    maximumDurationMs: number;
    maximumModelSteps: number;
    contentHash: string;
};
export declare const AdvancedRefinerEvaluationStartSchema: z.ZodObject<{
    pin: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
        operationId: z.ZodString;
        actorId: z.ZodString;
        teamId: z.ZodString;
        projectId: z.ZodNullable<z.ZodString>;
        mode: z.ZodEnum<{
            downstream_adaptation: "downstream_adaptation";
            review_quality: "review_quality";
        }>;
        profileRef: z.ZodObject<{
            source: z.ZodEnum<{
                github: "github";
                local: "local";
                openpond_git: "openpond_git";
            }>;
            repositoryId: z.ZodString;
            profileId: z.ZodString;
        }, z.core.$strict>;
        sourceRevision: z.ZodString;
        baselineRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        refinerRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        evidence: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        externalDatasetBinding: 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>;
        adaptationDatasetBinding: 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>;
        privateClosureHash: z.ZodString;
        adaptationTaskIds: z.ZodArray<z.ZodString>;
        holdoutTaskIds: z.ZodArray<z.ZodString>;
        adaptationSplit: z.ZodEnum<{
            frozen_eval: "frozen_eval";
            test: "test";
            train: "train";
            validation: "validation";
        }>;
        holdoutSplit: z.ZodEnum<{
            frozen_eval: "frozen_eval";
            test: "test";
            train: "train";
            validation: "validation";
        }>;
        environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"resettable">;
            environmentHash: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"frozen_observations">;
            environmentHash: z.ZodString;
        }, z.core.$strict>], "kind">;
        maximumCostUsd: z.ZodNumber;
        maximumDurationMs: z.ZodNumber;
        maximumModelSteps: z.ZodNumber;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    modelId: z.ZodString;
    profileId: z.ZodString;
    model: z.ZodObject<{
        providerId: z.ZodUnion<readonly [z.ZodEnum<{
            anthropic: "anthropic";
            "claude-code": "claude-code";
            codex: "codex";
            "custom-openai-compatible": "custom-openai-compatible";
            deepseek: "deepseek";
            google: "google";
            "grok-build": "grok-build";
            groq: "groq";
            moonshot: "moonshot";
            openai: "openai";
            opencode: "opencode";
            openpond: "openpond";
            openrouter: "openrouter";
            together: "together";
            xai: "xai";
            zai: "zai";
        }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
        modelId: z.ZodString;
    }, z.core.$strip>;
    seed: z.ZodNumber;
    reasoningEffort: z.ZodNullable<z.ZodEnum<{
        high: "high";
        low: "low";
        max: "max";
        medium: "medium";
        none: "none";
        off: "off";
        xhigh: "xhigh";
    }>>;
}, z.core.$strict>;
export declare const AdvancedRefinerEvaluationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    operation: z.ZodLiteral<"start">;
    request: z.ZodObject<{
        pin: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
            operationId: z.ZodString;
            actorId: z.ZodString;
            teamId: z.ZodString;
            projectId: z.ZodNullable<z.ZodString>;
            mode: z.ZodEnum<{
                downstream_adaptation: "downstream_adaptation";
                review_quality: "review_quality";
            }>;
            profileRef: z.ZodObject<{
                source: z.ZodEnum<{
                    github: "github";
                    local: "local";
                    openpond_git: "openpond_git";
                }>;
                repositoryId: z.ZodString;
                profileId: z.ZodString;
            }, z.core.$strict>;
            sourceRevision: z.ZodString;
            baselineRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            refinerRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            evidence: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            externalDatasetBinding: 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>;
            adaptationDatasetBinding: 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>;
            privateClosureHash: z.ZodString;
            adaptationTaskIds: z.ZodArray<z.ZodString>;
            holdoutTaskIds: z.ZodArray<z.ZodString>;
            adaptationSplit: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            holdoutSplit: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"resettable">;
                environmentHash: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"frozen_observations">;
                environmentHash: z.ZodString;
            }, z.core.$strict>], "kind">;
            maximumCostUsd: z.ZodNumber;
            maximumDurationMs: z.ZodNumber;
            maximumModelSteps: z.ZodNumber;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        modelId: z.ZodString;
        profileId: z.ZodString;
        model: z.ZodObject<{
            providerId: z.ZodUnion<readonly [z.ZodEnum<{
                anthropic: "anthropic";
                "claude-code": "claude-code";
                codex: "codex";
                "custom-openai-compatible": "custom-openai-compatible";
                deepseek: "deepseek";
                google: "google";
                "grok-build": "grok-build";
                groq: "groq";
                moonshot: "moonshot";
                openai: "openai";
                opencode: "opencode";
                openpond: "openpond";
                openrouter: "openrouter";
                together: "together";
                xai: "xai";
                zai: "zai";
            }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
            modelId: z.ZodString;
        }, z.core.$strip>;
        seed: z.ZodNumber;
        reasoningEffort: z.ZodNullable<z.ZodEnum<{
            high: "high";
            low: "low";
            max: "max";
            medium: "medium";
            none: "none";
            off: "off";
            xhigh: "xhigh";
        }>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodEnum<{
        cancel: "cancel";
        read: "read";
        resume: "resume";
    }>;
    id: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodLiteral<"list">;
}, z.core.$strict>], "operation">;
export declare const AdvancedRefinerReviewCaseReceiptSchema: z.ZodObject<{
    taskId: z.ZodString;
    sourceCaseHash: z.ZodString;
    reviewSessionId: z.ZodString;
    reviewTurnId: z.ZodString;
    inputHarness: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    trigger: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    decision: z.ZodEnum<{
        no_action: "no_action";
        queue_refiner: "queue_refiner";
        route_deterministically: "route_deterministically";
    }>;
    outcome: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    proposal: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    validations: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    grade: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        score: z.ZodNullable<z.ZodNumber>;
        passed: z.ZodBoolean;
        failureClass: z.ZodNullable<z.ZodString>;
    }, z.core.$strict>;
    resetComplete: z.ZodBoolean;
}, z.core.$strict>;
export declare const AdvancedRefinerReviewReceiptSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.advancedRefinerReviewReceipt.v1">;
    id: z.ZodString;
    runId: z.ZodString;
    pinHash: z.ZodString;
    ownerActorId: z.ZodString;
    teamId: z.ZodString;
    privateClosureHash: z.ZodString;
    refinerRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    cases: z.ZodArray<z.ZodObject<{
        taskId: z.ZodString;
        sourceCaseHash: z.ZodString;
        reviewSessionId: z.ZodString;
        reviewTurnId: z.ZodString;
        inputHarness: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        trigger: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        decision: z.ZodEnum<{
            no_action: "no_action";
            queue_refiner: "queue_refiner";
            route_deterministically: "route_deterministically";
        }>;
        outcome: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        proposal: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        validations: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        grade: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            score: z.ZodNullable<z.ZodNumber>;
            passed: z.ZodBoolean;
            failureClass: z.ZodNullable<z.ZodString>;
        }, z.core.$strict>;
        resetComplete: z.ZodBoolean;
    }, z.core.$strict>>;
    reviewScore: z.ZodNullable<z.ZodNumber>;
    completedCases: z.ZodNumber;
    noActionCases: z.ZodNumber;
    routedCases: z.ZodNumber;
    proposalCases: z.ZodNumber;
    costUsd: z.ZodNullable<z.ZodNumber>;
    cleanupComplete: z.ZodBoolean;
    createdAt: z.ZodString;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type AdvancedRefinerReviewReceipt = z.infer<typeof AdvancedRefinerReviewReceiptSchema>;
export declare function sealAdvancedRefinerReviewReceipt(body: Omit<AdvancedRefinerReviewReceipt, "contentHash">): {
    schemaVersion: "openpond.advancedRefinerReviewReceipt.v1";
    id: string;
    runId: string;
    pinHash: string;
    ownerActorId: string;
    teamId: string;
    privateClosureHash: string;
    refinerRelease: {
        id: string;
        contentHash: string;
    };
    cases: {
        taskId: string;
        sourceCaseHash: string;
        reviewSessionId: string;
        reviewTurnId: string;
        inputHarness: {
            id: string;
            contentHash: string;
        };
        trigger: {
            id: string;
            contentHash: string;
        };
        decision: "no_action" | "queue_refiner" | "route_deterministically";
        outcome: {
            id: string;
            contentHash: string;
        } | null;
        proposal: {
            id: string;
            contentHash: string;
        } | null;
        validations: {
            id: string;
            contentHash: string;
        }[];
        grade: {
            id: string;
            contentHash: string;
            score: number | null;
            passed: boolean;
            failureClass: string | null;
        };
        resetComplete: boolean;
    }[];
    reviewScore: number | null;
    completedCases: number;
    noActionCases: number;
    routedCases: number;
    proposalCases: number;
    costUsd: number | null;
    cleanupComplete: boolean;
    createdAt: string;
    contentHash: string;
};
export declare const AdvancedRefinerEvaluationOptionsSchema: z.ZodObject<{
    teamId: z.ZodString;
    evidence: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    scoring: z.ZodOptional<z.ZodObject<{
        sourcePass: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        graders: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>>;
        mappings: z.ZodOptional<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>>>;
        maximumCostUsd: z.ZodNumber;
    }, z.core.$strict>>;
    profiles: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        profileRef: z.ZodObject<{
            source: z.ZodEnum<{
                github: "github";
                local: "local";
                openpond_git: "openpond_git";
            }>;
            repositoryId: z.ZodString;
            profileId: z.ZodString;
        }, z.core.$strict>;
        ownerWorkspaceId: z.ZodString;
        ownerRevision: z.ZodNumber;
        baseRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        profileSourceRevision: z.ZodString;
        components: z.ZodArray<z.ZodObject<{
            kind: z.ZodEnum<{
                agent: "agent";
                instruction: "instruction";
                skill: "skill";
                workflow: "workflow";
            }>;
            path: z.ZodString;
            agentId: z.ZodOptional<z.ZodString>;
            workflowId: z.ZodOptional<z.ZodString>;
            label: z.ZodString;
            binding: 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>;
            adaptationSplits: z.ZodArray<z.ZodObject<{
                split: z.ZodEnum<{
                    frozen_eval: "frozen_eval";
                    test: "test";
                    train: "train";
                    validation: "validation";
                }>;
                taskIds: z.ZodArray<z.ZodString>;
            }, z.core.$strip>>;
            environmentHash: z.ZodString;
            resettable: z.ZodBoolean;
            reviewQuality: z.ZodBoolean;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    refinerReleases: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    activeRefiner: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    models: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        profileId: z.ZodString;
        name: z.ZodString;
        location: z.ZodEnum<{
            hosted: "hosted";
            local: "local";
        }>;
    }, z.core.$strip>>;
}, z.core.$strict>;
export declare const AdvancedRefinerEvaluationPrepareSchema: z.ZodObject<{
    operation: z.ZodLiteral<"prepare">;
    evidence: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    profileOptionId: z.ZodString;
    componentLabel: z.ZodString;
    mode: z.ZodEnum<{
        downstream_adaptation: "downstream_adaptation";
        review_quality: "review_quality";
    }>;
    adaptationSplit: z.ZodEnum<{
        frozen_eval: "frozen_eval";
        test: "test";
        train: "train";
        validation: "validation";
    }>;
    operationId: z.ZodString;
    refinerRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    maximumCostUsd: z.ZodNumber;
    maximumDurationMs: z.ZodNumber;
    maximumModelSteps: z.ZodNumber;
}, z.core.$strict>;
export declare const AdvancedRefinerEvaluationSetupCommandSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
    operation: z.ZodLiteral<"start">;
    request: z.ZodObject<{
        pin: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
            operationId: z.ZodString;
            actorId: z.ZodString;
            teamId: z.ZodString;
            projectId: z.ZodNullable<z.ZodString>;
            mode: z.ZodEnum<{
                downstream_adaptation: "downstream_adaptation";
                review_quality: "review_quality";
            }>;
            profileRef: z.ZodObject<{
                source: z.ZodEnum<{
                    github: "github";
                    local: "local";
                    openpond_git: "openpond_git";
                }>;
                repositoryId: z.ZodString;
                profileId: z.ZodString;
            }, z.core.$strict>;
            sourceRevision: z.ZodString;
            baselineRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            refinerRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            evidence: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            externalDatasetBinding: 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>;
            adaptationDatasetBinding: 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>;
            privateClosureHash: z.ZodString;
            adaptationTaskIds: z.ZodArray<z.ZodString>;
            holdoutTaskIds: z.ZodArray<z.ZodString>;
            adaptationSplit: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            holdoutSplit: z.ZodEnum<{
                frozen_eval: "frozen_eval";
                test: "test";
                train: "train";
                validation: "validation";
            }>;
            environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"resettable">;
                environmentHash: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"frozen_observations">;
                environmentHash: z.ZodString;
            }, z.core.$strict>], "kind">;
            maximumCostUsd: z.ZodNumber;
            maximumDurationMs: z.ZodNumber;
            maximumModelSteps: z.ZodNumber;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        modelId: z.ZodString;
        profileId: z.ZodString;
        model: z.ZodObject<{
            providerId: z.ZodUnion<readonly [z.ZodEnum<{
                anthropic: "anthropic";
                "claude-code": "claude-code";
                codex: "codex";
                "custom-openai-compatible": "custom-openai-compatible";
                deepseek: "deepseek";
                google: "google";
                "grok-build": "grok-build";
                groq: "groq";
                moonshot: "moonshot";
                openai: "openai";
                opencode: "opencode";
                openpond: "openpond";
                openrouter: "openrouter";
                together: "together";
                xai: "xai";
                zai: "zai";
            }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
            modelId: z.ZodString;
        }, z.core.$strip>;
        seed: z.ZodNumber;
        reasoningEffort: z.ZodNullable<z.ZodEnum<{
            high: "high";
            low: "low";
            max: "max";
            medium: "medium";
            none: "none";
            off: "off";
            xhigh: "xhigh";
        }>>;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodEnum<{
        cancel: "cancel";
        read: "read";
        resume: "resume";
    }>;
    id: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodLiteral<"list">;
}, z.core.$strict>], "operation">, z.ZodObject<{
    operation: z.ZodLiteral<"prepare">;
    evidence: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    profileOptionId: z.ZodString;
    componentLabel: z.ZodString;
    mode: z.ZodEnum<{
        downstream_adaptation: "downstream_adaptation";
        review_quality: "review_quality";
    }>;
    adaptationSplit: z.ZodEnum<{
        frozen_eval: "frozen_eval";
        test: "test";
        train: "train";
        validation: "validation";
    }>;
    operationId: z.ZodString;
    refinerRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    maximumCostUsd: z.ZodNumber;
    maximumDurationMs: z.ZodNumber;
    maximumModelSteps: z.ZodNumber;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodLiteral<"options">;
    evidence: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>]>;
export type AdvancedRefinerEvaluationOptions = z.infer<typeof AdvancedRefinerEvaluationOptionsSchema>;
export declare const AdvancedRefinerEvaluationAccountingSchema: z.ZodObject<{
    modelRequests: z.ZodNumber;
    knownSpendUsd: z.ZodNumber;
    totalSpendUsd: z.ZodNullable<z.ZodNumber>;
    heldUsd: z.ZodNumber;
    uncertainRequests: z.ZodNumber;
}, z.core.$strict>;
/** The owner's canonical ModelRun remains intact in readback. This boundary
 * validates its retained advanced pin rather than manufacturing results. */
export declare class OpenPondAdvancedRefinerEvaluationClient {
    private readonly transport;
    constructor(access: EvaluationCoordinationAccess);
    command(raw: z.input<typeof AdvancedRefinerEvaluationSetupCommandSchema>, signal?: AbortSignal): Promise<{
        teamId: string;
        evidence: {
            id: string;
            contentHash: string;
        };
        scoring?: {
            sourcePass: {
                id: string;
                contentHash: string;
            };
            graders: {
                id: string;
                contentHash: string;
                revision: number;
            }[];
            mappings?: {
                graderId: string;
                fields: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[];
            }[] | undefined;
            maximumCostUsd: number;
        } | undefined;
        profiles: {
            id: string;
            name: string;
            profileRef: {
                source: "github" | "local" | "openpond_git";
                repositoryId: string;
                profileId: string;
            };
            ownerWorkspaceId: string;
            ownerRevision: number;
            baseRelease: {
                id: string;
                contentHash: string;
            };
            profileSourceRevision: string;
            components: {
                kind: "agent" | "instruction" | "skill" | "workflow";
                path: string;
                agentId?: string | undefined;
                workflowId?: string | undefined;
                label: string;
                binding: {
                    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;
                };
                adaptationSplits: {
                    split: "frozen_eval" | "test" | "train" | "validation";
                    taskIds: string[];
                }[];
                environmentHash: string;
                resettable: boolean;
                reviewQuality: boolean;
            }[];
        }[];
        refinerReleases: {
            id: string;
            contentHash: string;
        }[];
        activeRefiner: {
            id: string;
            contentHash: string;
        } | null;
        models: {
            id: string;
            profileId: string;
            name: string;
            location: "hosted" | "local";
        }[];
    } | {
        items: {
            id: string;
            status: "cancelled" | "failed" | "prepared" | "running" | "succeeded";
            mode: "downstream_adaptation" | "review_quality";
            startedAt: string | null;
            completedAt: string | null;
            failure: string | null;
        }[];
    } | {
        id: string;
        status: "cancelled" | "failed" | "prepared" | "running" | "succeeded";
    } | {
        [x: string]: unknown;
        schemaVersion: "openpond.modelRun.v1";
        id: string;
        kind: "evaluation";
        modelId: string;
        profileId: string;
        evaluation: {
            [x: string]: unknown;
            benchmarkId: "harness-refiner";
            advancedEvaluation: {
                schemaVersion: "openpond.advancedRefinerEvaluation.v1";
                operationId: string;
                actorId: string;
                teamId: string;
                projectId: string | null;
                mode: "downstream_adaptation" | "review_quality";
                profileRef: {
                    source: "github" | "local" | "openpond_git";
                    repositoryId: string;
                    profileId: string;
                };
                sourceRevision: string;
                baselineRelease: {
                    id: string;
                    contentHash: string;
                };
                refinerRelease: {
                    id: string;
                    contentHash: string;
                };
                evidence: {
                    id: string;
                    contentHash: 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;
                };
                adaptationDatasetBinding: {
                    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;
                };
                privateClosureHash: string;
                adaptationTaskIds: string[];
                holdoutTaskIds: string[];
                adaptationSplit: "frozen_eval" | "test" | "train" | "validation";
                holdoutSplit: "frozen_eval" | "test" | "train" | "validation";
                environmentPolicy: {
                    kind: "resettable";
                    environmentHash: string;
                } | {
                    kind: "frozen_observations";
                    environmentHash: string;
                };
                maximumCostUsd: number;
                maximumDurationMs: number;
                maximumModelSteps: number;
                contentHash: string;
            };
        };
    } | {
        pin: {
            schemaVersion: "openpond.advancedRefinerEvaluation.v1";
            operationId: string;
            actorId: string;
            teamId: string;
            projectId: string | null;
            mode: "downstream_adaptation" | "review_quality";
            profileRef: {
                source: "github" | "local" | "openpond_git";
                repositoryId: string;
                profileId: string;
            };
            sourceRevision: string;
            baselineRelease: {
                id: string;
                contentHash: string;
            };
            refinerRelease: {
                id: string;
                contentHash: string;
            };
            evidence: {
                id: string;
                contentHash: 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;
            };
            adaptationDatasetBinding: {
                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;
            };
            privateClosureHash: string;
            adaptationTaskIds: string[];
            holdoutTaskIds: string[];
            adaptationSplit: "frozen_eval" | "test" | "train" | "validation";
            holdoutSplit: "frozen_eval" | "test" | "train" | "validation";
            environmentPolicy: {
                kind: "resettable";
                environmentHash: string;
            } | {
                kind: "frozen_observations";
                environmentHash: string;
            };
            maximumCostUsd: number;
            maximumDurationMs: number;
            maximumModelSteps: number;
            contentHash: string;
        };
    }>;
}
//# sourceMappingURL=advanced-refiner-evaluations.d.ts.map