import { z } from "zod";
export declare const ProfileEvaluationDiscoverySchema: z.ZodObject<{
    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;
    harnessRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    catalogHash: z.ZodNullable<z.ZodString>;
    definitions: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        description: 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">;
        tasksetRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        split: z.ZodEnum<{
            frozen_eval: "frozen_eval";
            test: "test";
            train: "train";
            validation: "validation";
        }>;
        taskIds: z.ZodArray<z.ZodString>;
        seeds: z.ZodArray<z.ZodString>;
        criterion: z.ZodObject<{
            minimumPassRate: z.ZodNumber;
            requireComplete: z.ZodBoolean;
        }, z.core.$strict>;
    }, z.core.$strict>>;
    suites: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        scope: z.ZodEnum<{
            component: "component";
            profile: "profile";
        }>;
        definitionIds: z.ZodArray<z.ZodString>;
    }, z.core.$strict>>;
    runs: z.ZodArray<z.ZodObject<{
        profileRef: z.ZodObject<{
            source: z.ZodEnum<{
                github: "github";
                local: "local";
                openpond_git: "openpond_git";
            }>;
            repositoryId: z.ZodString;
            profileId: z.ZodString;
        }, z.core.$strict>;
        manifest: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.tasksetRunManifest.v1">;
            id: z.ZodString;
            tasksetRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            packageHash: z.ZodString;
            execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"taskset">;
                environmentRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                verifierSetRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                policyHash: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"harness">;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>], "kind">;
            profileEvaluation: z.ZodOptional<z.ZodObject<{
                profileId: z.ZodString;
                sourceRevision: z.ZodString;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                catalogHash: z.ZodString;
                definitionId: z.ZodString;
                definitionHash: z.ZodString;
                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"profile">;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"workflow">;
                    workflowId: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"skill">;
                    skillPath: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"agent_action">;
                    actionId: z.ZodString;
                }, z.core.$strict>], "kind">;
                environmentHash: z.ZodString;
                externalDatasetBinding: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
                    dataset: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                        revision: z.ZodNumber;
                    }, z.core.$strict>;
                    packageHash: z.ZodString;
                    profileId: z.ZodString;
                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                        kind: z.ZodLiteral<"profile">;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"workflow">;
                        workflowId: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"skill">;
                        skillPath: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"agent_action">;
                        actionId: z.ZodString;
                    }, z.core.$strict>], "kind">;
                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
                    protectedProfileClosureHash: z.ZodString;
                    recordedOrigin: z.ZodOptional<z.ZodObject<{
                        execution: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        originalEvidence: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        members: z.ZodArray<z.ZodObject<{
                            caseId: z.ZodString;
                            seed: z.ZodString;
                            fixtureId: z.ZodString;
                            sourceId: z.ZodString;
                            snapshotHash: z.ZodString;
                            boundaryRevisionHash: z.ZodString;
                        }, z.core.$strict>>;
                    }, z.core.$strict>>;
                    gradingSource: z.ZodOptional<z.ZodObject<{
                        pass: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        evidence: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                    }, z.core.$strict>>;
                    split: z.ZodEnum<{
                        frozen_eval: "frozen_eval";
                        test: "test";
                        train: "train";
                        validation: "validation";
                    }>;
                    population: z.ZodArray<z.ZodObject<{
                        taskId: z.ZodString;
                        seed: z.ZodString;
                        fixtureId: z.ZodNullable<z.ZodString>;
                    }, z.core.$strict>>;
                    evaluators: z.ZodArray<z.ZodObject<{
                        release: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
                        }, z.core.$strict>;
                        feedbackKey: z.ZodString;
                        configurationHash: z.ZodString;
                        output: z.ZodEnum<{
                            boolean: "boolean";
                            category: "category";
                            score: "score";
                        }>;
                        categories: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>>;
                    fieldMappingsHash: z.ZodString;
                    fieldMappings: z.ZodArray<z.ZodObject<{
                        graderId: z.ZodString;
                        fields: z.ZodArray<z.ZodObject<{
                            destination: z.ZodEnum<{
                                evaluatorContext: "evaluatorContext";
                                expectedOutput: "expectedOutput";
                                input: "input";
                                output: "output";
                            }>;
                            path: z.ZodArray<z.ZodString>;
                            source: z.ZodEnum<{
                                evaluatorContext: "evaluatorContext";
                                expectedOutput: "expectedOutput";
                                input: "input";
                                output: "output";
                            }>;
                            sourcePath: z.ZodArray<z.ZodString>;
                        }, z.core.$strict>>;
                    }, z.core.$strict>>;
                    environmentHash: z.ZodString;
                    privateDatasetClosureHash: z.ZodString;
                    criterion: z.ZodObject<{
                        minimumPassRate: z.ZodNumber;
                        requireComplete: z.ZodBoolean;
                    }, z.core.$strict>;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                sourceCandidate: z.ZodOptional<z.ZodObject<{
                    candidateId: z.ZodString;
                    frozenRevision: z.ZodNumber;
                    frozenHash: z.ZodString;
                    harnessRelease: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    protectedClosureHash: z.ZodString;
                }, z.core.$strict>>;
            }, z.core.$strict>>;
            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"model">;
                model: z.ZodObject<{
                    provider: z.ZodString;
                    model: z.ZodString;
                    revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    artifactHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    tokenizerRevision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    chatTemplateHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                }, z.core.$strict>;
                configurationHash: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fixture">;
            }, z.core.$strict>], "kind">;
            gradingRole: z.ZodLiteral<"evaluation">;
            metricPolicy: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
                primaryMetric: z.ZodString;
                aggregation: z.ZodEnum<{
                    custom: "custom";
                    mean_score: "mean_score";
                    pass_rate: "pass_rate";
                    weighted_mean: "weighted_mean";
                }>;
                missingReward: z.ZodEnum<{
                    exclude: "exclude";
                    zero: "zero";
                }>;
                taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                customAggregator: z.ZodNullable<z.ZodObject<{
                    module: z.ZodString;
                    exportName: z.ZodString;
                    contentHash: z.ZodString;
                    timeoutMs: z.ZodNumber;
                    networkPolicy: z.ZodLiteral<"none">;
                }, z.core.$strict>>;
            }, z.core.$strict>;
            population: z.ZodArray<z.ZodObject<{
                receiptId: z.ZodString;
                taskId: z.ZodString;
                seed: z.ZodString;
                fixtureId: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            runtimeTarget: z.ZodObject<{
                adapterId: z.ZodString;
                placement: z.ZodEnum<{
                    colocated: "colocated";
                    local: "local";
                    provider_native: "provider_native";
                    remote: "remote";
                }>;
                runtimeVersion: z.ZodString;
                capabilityReceipt: z.ZodString;
            }, z.core.$strict>;
            limits: z.ZodObject<{
                maxTurns: z.ZodNumber;
                timeoutMs: z.ZodNumber;
                maxOutputBytes: z.ZodNumber;
                maximumSpendUsd: z.ZodNullable<z.ZodNumber>;
            }, z.core.$strict>;
            createdAt: z.ZodString;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        metric: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.tasksetMetricResult.v1">;
            runManifest: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            tasksetRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            policy: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
                primaryMetric: z.ZodString;
                aggregation: z.ZodEnum<{
                    custom: "custom";
                    mean_score: "mean_score";
                    pass_rate: "pass_rate";
                    weighted_mean: "weighted_mean";
                }>;
                missingReward: z.ZodEnum<{
                    exclude: "exclude";
                    zero: "zero";
                }>;
                taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                customAggregator: z.ZodNullable<z.ZodObject<{
                    module: z.ZodString;
                    exportName: z.ZodString;
                    contentHash: z.ZodString;
                    timeoutMs: z.ZodNumber;
                    networkPolicy: z.ZodLiteral<"none">;
                }, z.core.$strict>>;
            }, z.core.$strict>;
            policyHash: z.ZodString;
            receiptRefs: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
            includedCount: z.ZodNumber;
            missingRewardCount: z.ZodNumber;
            excludedCount: z.ZodNumber;
            value: z.ZodNullable<z.ZodNumber>;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        gradeRefs: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        receiptRefs: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        passRate: z.ZodNumber;
        passed: z.ZodBoolean;
        completedAt: z.ZodISODateTime;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    comparisons: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.profileEvaluationComparison.v1">;
        id: z.ZodString;
        tasksetRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        populationHash: z.ZodString;
        environmentHash: z.ZodString;
        metricPolicyHash: z.ZodString;
        limitsHash: z.ZodString;
        members: z.ZodArray<z.ZodObject<{
            runManifest: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            metricResultHash: z.ZodString;
            source: z.ZodObject<{
                profileId: z.ZodString;
                sourceRevision: z.ZodString;
                harnessRelease: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                catalogHash: z.ZodString;
                definitionId: z.ZodString;
                definitionHash: z.ZodString;
                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"profile">;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"workflow">;
                    workflowId: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"skill">;
                    skillPath: z.ZodString;
                }, z.core.$strict>, z.ZodObject<{
                    kind: z.ZodLiteral<"agent_action">;
                    actionId: z.ZodString;
                }, z.core.$strict>], "kind">;
                environmentHash: z.ZodString;
                externalDatasetBinding: z.ZodOptional<z.ZodObject<{
                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
                    dataset: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                        revision: z.ZodNumber;
                    }, z.core.$strict>;
                    packageHash: z.ZodString;
                    profileId: z.ZodString;
                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
                        kind: z.ZodLiteral<"profile">;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"workflow">;
                        workflowId: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"skill">;
                        skillPath: z.ZodString;
                    }, z.core.$strict>, z.ZodObject<{
                        kind: z.ZodLiteral<"agent_action">;
                        actionId: z.ZodString;
                    }, z.core.$strict>], "kind">;
                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
                    protectedProfileClosureHash: z.ZodString;
                    recordedOrigin: z.ZodOptional<z.ZodObject<{
                        execution: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        originalEvidence: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        members: z.ZodArray<z.ZodObject<{
                            caseId: z.ZodString;
                            seed: z.ZodString;
                            fixtureId: z.ZodString;
                            sourceId: z.ZodString;
                            snapshotHash: z.ZodString;
                            boundaryRevisionHash: z.ZodString;
                        }, z.core.$strict>>;
                    }, z.core.$strict>>;
                    gradingSource: z.ZodOptional<z.ZodObject<{
                        pass: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                        evidence: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                        }, z.core.$strict>;
                    }, z.core.$strict>>;
                    split: z.ZodEnum<{
                        frozen_eval: "frozen_eval";
                        test: "test";
                        train: "train";
                        validation: "validation";
                    }>;
                    population: z.ZodArray<z.ZodObject<{
                        taskId: z.ZodString;
                        seed: z.ZodString;
                        fixtureId: z.ZodNullable<z.ZodString>;
                    }, z.core.$strict>>;
                    evaluators: z.ZodArray<z.ZodObject<{
                        release: z.ZodObject<{
                            id: z.ZodString;
                            contentHash: z.ZodString;
                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
                        }, z.core.$strict>;
                        feedbackKey: z.ZodString;
                        configurationHash: z.ZodString;
                        output: z.ZodEnum<{
                            boolean: "boolean";
                            category: "category";
                            score: "score";
                        }>;
                        categories: z.ZodArray<z.ZodString>;
                    }, z.core.$strict>>;
                    fieldMappingsHash: z.ZodString;
                    fieldMappings: z.ZodArray<z.ZodObject<{
                        graderId: z.ZodString;
                        fields: z.ZodArray<z.ZodObject<{
                            destination: z.ZodEnum<{
                                evaluatorContext: "evaluatorContext";
                                expectedOutput: "expectedOutput";
                                input: "input";
                                output: "output";
                            }>;
                            path: z.ZodArray<z.ZodString>;
                            source: z.ZodEnum<{
                                evaluatorContext: "evaluatorContext";
                                expectedOutput: "expectedOutput";
                                input: "input";
                                output: "output";
                            }>;
                            sourcePath: z.ZodArray<z.ZodString>;
                        }, z.core.$strict>>;
                    }, z.core.$strict>>;
                    environmentHash: z.ZodString;
                    privateDatasetClosureHash: z.ZodString;
                    criterion: z.ZodObject<{
                        minimumPassRate: z.ZodNumber;
                        requireComplete: z.ZodBoolean;
                    }, z.core.$strict>;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                sourceCandidate: z.ZodOptional<z.ZodObject<{
                    candidateId: z.ZodString;
                    frozenRevision: z.ZodNumber;
                    frozenHash: z.ZodString;
                    harnessRelease: z.ZodObject<{
                        id: z.ZodString;
                        contentHash: z.ZodString;
                    }, z.core.$strict>;
                    protectedClosureHash: z.ZodString;
                }, z.core.$strict>>;
            }, z.core.$strict>;
            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"model">;
                model: z.ZodObject<{
                    provider: z.ZodString;
                    model: z.ZodString;
                    revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    artifactHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    tokenizerRevision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    chatTemplateHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                }, z.core.$strict>;
                configurationHash: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                kind: z.ZodLiteral<"fixture">;
            }, z.core.$strict>], "kind">;
            score: z.ZodNullable<z.ZodNumber>;
        }, z.core.$strict>>;
        createdAt: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    suiteRuns: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.profileEvaluationSuiteRun.v1">;
        id: z.ZodString;
        suiteId: z.ZodString;
        suiteHash: z.ZodString;
        catalogHash: z.ZodString;
        profileId: z.ZodString;
        sourceRevision: z.ZodString;
        harnessRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        members: z.ZodArray<z.ZodObject<{
            definitionId: z.ZodString;
            runManifest: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            runHash: z.ZodString;
            passed: z.ZodBoolean;
            score: z.ZodNullable<z.ZodNumber>;
        }, z.core.$strict>>;
        passed: z.ZodBoolean;
        createdAt: z.ZodString;
        completedAt: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
    reports: z.ZodArray<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.profileEvaluationReport.v1">;
        id: z.ZodString;
        createdAt: z.ZodString;
        testedSources: z.ZodArray<z.ZodObject<{
            profileId: z.ZodString;
            sourceRevision: z.ZodString;
            harnessRelease: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>;
        tasksetReleases: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        metricPolicyHashes: z.ZodArray<z.ZodString>;
        modelConfigurationHashes: z.ZodArray<z.ZodString>;
        evidence: z.ZodArray<z.ZodObject<{
            kind: z.ZodEnum<{
                comparison: "comparison";
                run: "run";
                suite: "suite";
            }>;
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        summary: z.ZodObject<{
            totalChecks: z.ZodNumber;
            passedChecks: z.ZodNumber;
            failedChecks: z.ZodNumber;
            unscoredChecks: z.ZodNumber;
            meanScore: z.ZodNullable<z.ZodNumber>;
        }, z.core.$strict>;
        contentHash: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type ProfileEvaluationDiscovery = z.infer<typeof ProfileEvaluationDiscoverySchema>;
export declare const ProfileEvaluationDiscoveryRequestSchema: z.ZodObject<{
    teamId: z.ZodString;
    profileRepositoryId: z.ZodString;
    trainingProjectId: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
/** Reads the existing source owner's receipts. No resource is copied and no
 * incomplete execution is turned into a synthetic rerunnable configuration. */
export declare class OpenPondProfileEvaluationDiscoveryClient {
    private readonly options;
    constructor(options: {
        baseUrl: string;
        apiKey: string;
        teamId: string;
        fetch?: typeof fetch;
    });
    read(input: {
        profileRepositoryId: string;
        trainingProjectId?: string;
    }, signal?: AbortSignal): Promise<{
        profileRef: {
            source: "github" | "local" | "openpond_git";
            repositoryId: string;
            profileId: string;
        };
        sourceRevision: string;
        harnessRelease: {
            id: string;
            contentHash: string;
        };
        catalogHash: string | null;
        definitions: {
            id: string;
            label: string;
            description: string;
            target: {
                kind: "profile";
            } | {
                kind: "workflow";
                workflowId: string;
            } | {
                kind: "skill";
                skillPath: string;
            } | {
                kind: "agent_action";
                actionId: string;
            };
            tasksetRelease: {
                id: string;
                contentHash: string;
            };
            split: "frozen_eval" | "test" | "train" | "validation";
            taskIds: string[];
            seeds: string[];
            criterion: {
                minimumPassRate: number;
                requireComplete: boolean;
            };
        }[];
        suites: {
            id: string;
            label: string;
            scope: "component" | "profile";
            definitionIds: string[];
        }[];
        runs: {
            profileRef: {
                source: "github" | "local" | "openpond_git";
                repositoryId: string;
                profileId: string;
            };
            manifest: {
                schemaVersion: "openpond.tasksetRunManifest.v1";
                id: string;
                tasksetRelease: {
                    id: string;
                    contentHash: string;
                };
                packageHash: string;
                execution: {
                    kind: "taskset";
                    environmentRelease: {
                        id: string;
                        contentHash: string;
                    };
                    verifierSetRelease: {
                        id: string;
                        contentHash: string;
                    };
                    policyHash: string;
                } | {
                    kind: "harness";
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                };
                profileEvaluation?: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                } | undefined;
                policy: {
                    kind: "model";
                    model: {
                        provider: string;
                        model: string;
                        revision: string | null;
                        artifactHash: string | null;
                        tokenizerRevision: string | null;
                        chatTemplateHash: string | null;
                    };
                    configurationHash: string;
                } | {
                    kind: "fixture";
                };
                gradingRole: "evaluation";
                metricPolicy: {
                    schemaVersion: "openpond.tasksetMetricPolicy.v1";
                    primaryMetric: string;
                    aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                    missingReward: "exclude" | "zero";
                    taskWeights?: Record<string, number> | undefined;
                    customAggregator: {
                        module: string;
                        exportName: string;
                        contentHash: string;
                        timeoutMs: number;
                        networkPolicy: "none";
                    } | null;
                };
                population: {
                    receiptId: string;
                    taskId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
                runtimeTarget: {
                    adapterId: string;
                    placement: "colocated" | "local" | "provider_native" | "remote";
                    runtimeVersion: string;
                    capabilityReceipt: string;
                };
                limits: {
                    maxTurns: number;
                    timeoutMs: number;
                    maxOutputBytes: number;
                    maximumSpendUsd: number | null;
                };
                createdAt: string;
                metadata: Record<string, unknown>;
                contentHash: string;
            };
            metric: {
                schemaVersion: "openpond.tasksetMetricResult.v1";
                runManifest: {
                    id: string;
                    contentHash: string;
                };
                tasksetRelease: {
                    id: string;
                    contentHash: string;
                };
                policy: {
                    schemaVersion: "openpond.tasksetMetricPolicy.v1";
                    primaryMetric: string;
                    aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                    missingReward: "exclude" | "zero";
                    taskWeights?: Record<string, number> | undefined;
                    customAggregator: {
                        module: string;
                        exportName: string;
                        contentHash: string;
                        timeoutMs: number;
                        networkPolicy: "none";
                    } | null;
                };
                policyHash: string;
                receiptRefs: {
                    id: string;
                    contentHash: string;
                }[];
                includedCount: number;
                missingRewardCount: number;
                excludedCount: number;
                value: number | null;
                contentHash: string;
            };
            gradeRefs: {
                id: string;
                contentHash: string;
            }[];
            receiptRefs: {
                id: string;
                contentHash: string;
            }[];
            passRate: number;
            passed: boolean;
            completedAt: string;
            contentHash: string;
        }[];
        comparisons: {
            schemaVersion: "openpond.profileEvaluationComparison.v1";
            id: string;
            tasksetRelease: {
                id: string;
                contentHash: string;
            };
            populationHash: string;
            environmentHash: string;
            metricPolicyHash: string;
            limitsHash: string;
            members: {
                runManifest: {
                    id: string;
                    contentHash: string;
                };
                metricResultHash: string;
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                policy: {
                    kind: "model";
                    model: {
                        provider: string;
                        model: string;
                        revision: string | null;
                        artifactHash: string | null;
                        tokenizerRevision: string | null;
                        chatTemplateHash: string | null;
                    };
                    configurationHash: string;
                } | {
                    kind: "fixture";
                };
                score: number | null;
            }[];
            createdAt: string;
            contentHash: string;
        }[];
        suiteRuns: {
            schemaVersion: "openpond.profileEvaluationSuiteRun.v1";
            id: string;
            suiteId: string;
            suiteHash: string;
            catalogHash: string;
            profileId: string;
            sourceRevision: string;
            harnessRelease: {
                id: string;
                contentHash: string;
            };
            members: {
                definitionId: string;
                runManifest: {
                    id: string;
                    contentHash: string;
                };
                runHash: string;
                passed: boolean;
                score: number | null;
            }[];
            passed: boolean;
            createdAt: string;
            completedAt: string;
            contentHash: string;
        }[];
        reports: {
            schemaVersion: "openpond.profileEvaluationReport.v1";
            id: string;
            createdAt: string;
            testedSources: {
                profileId: string;
                sourceRevision: string;
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
            }[];
            tasksetReleases: {
                id: string;
                contentHash: string;
            }[];
            metricPolicyHashes: string[];
            modelConfigurationHashes: string[];
            evidence: {
                kind: "comparison" | "run" | "suite";
                id: string;
                contentHash: string;
            }[];
            summary: {
                totalChecks: number;
                passedChecks: number;
                failedChecks: number;
                unscoredChecks: number;
                meanScore: number | null;
            };
            contentHash: string;
        }[];
    }>;
}
//# sourceMappingURL=profile-evaluation-discovery.d.ts.map