import { z } from "zod";
/** This export attests native owner execution. It never asserts a hosted run,
 * grants training eligibility, or authorizes automatic candidate adoption. */
export declare const HostedProfileCandidateExportSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.hostedProfileCandidateExport.v1">;
    actorId: z.ZodString;
    teamId: z.ZodString;
    candidateId: z.ZodString;
    candidateRevision: z.ZodNumber;
    projectId: z.ZodNullable<z.ZodString>;
    profileRef: z.ZodObject<{
        source: z.ZodLiteral<"openpond_git">;
        repositoryId: z.ZodString;
        profileId: z.ZodString;
    }, z.core.$strict>;
    expectedCommit: z.ZodString;
    component: z.ZodObject<{
        kind: z.ZodEnum<{
            agent: "agent";
            instruction: "instruction";
            skill: "skill";
            workflow: "workflow";
        }>;
        path: z.ZodString;
        workflowId: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    baseRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    frozenHash: z.ZodString;
    executableSourceHash: z.ZodString;
    protectedClosureHash: z.ZodString;
    compiler: z.ZodObject<{
        workspaceId: z.ZodString;
        name: z.ZodString;
        repositoryId: z.ZodString;
    }, z.core.$strict>;
    sourceManifest: z.ZodObject<{
        base64: z.ZodString;
        contentHash: z.ZodString;
        sizeBytes: z.ZodNumber;
    }, z.core.$strict>;
    policySource: z.ZodObject<{
        agentSnapshot: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.agentSnapshot.v2">;
            id: z.ZodString;
            sourceRelease: z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>>;
            instructions: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>;
            skills: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>;
            agents: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>;
            toolDeclarations: z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                inputSchemaHash: z.ZodString;
                sideEffect: z.ZodEnum<{
                    read: "read";
                    write: "write";
                }>;
                timeoutMs: z.ZodNumber;
            }, z.core.$strict>>;
            capabilityRequirements: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                required: z.ZodBoolean;
                scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
                portability: z.ZodEnum<{
                    host_adapter: "host_adapter";
                    hosted_only: "hosted_only";
                    local_only: "local_only";
                    portable: "portable";
                }>;
            }, z.core.$strict>>;
            dependencyLock: z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>;
            portability: z.ZodObject<{
                portable: z.ZodBoolean;
                blockers: z.ZodArray<z.ZodString>;
                localOnlyAssetRefs: z.ZodArray<z.ZodString>;
                hostPrivateAssetRefs: z.ZodArray<z.ZodString>;
            }, z.core.$strict>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        harnessRelease: z.ZodObject<{
            schemaVersion: z.ZodLiteral<"openpond.harnessRelease.v2">;
            id: z.ZodString;
            agentSnapshot: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            program: z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>;
            tools: z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                inputSchemaHash: z.ZodString;
                sideEffect: z.ZodEnum<{
                    read: "read";
                    write: "write";
                }>;
                timeoutMs: z.ZodNumber;
            }, z.core.$strict>>;
            lifecycle: z.ZodObject<{
                create: z.ZodLiteral<true>;
                reset: z.ZodLiteral<true>;
                step: z.ZodLiteral<true>;
                collect: z.ZodLiteral<true>;
                destroy: z.ZodLiteral<true>;
                resetScope: z.ZodEnum<{
                    attempt: "attempt";
                    task: "task";
                }>;
            }, z.core.$strict>;
            graderInterface: z.ZodObject<{
                visibleEvidence: z.ZodArray<z.ZodString>;
                privilegedEvidence: z.ZodArray<z.ZodString>;
                privateVerifierIsolation: z.ZodBoolean;
            }, z.core.$strict>;
            files: z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>>;
            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        files: z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            base64: z.ZodString;
        }, z.core.$strict>>;
        schemaVersion: z.ZodLiteral<"openpond.harnessPolicySourcePackage.v1">;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    qualification: z.ZodObject<{
        kind: z.ZodEnum<{
            hosted_execution: "hosted_execution";
            owner_attested_local: "owner_attested_local";
        }>;
        ownerActorId: z.ZodString;
        teamId: z.ZodString;
        originalEvidence: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        baseline: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        candidate: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        comparisonHash: z.ZodString;
        recipe: z.ZodObject<{
            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>;
            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>>;
            modelId: z.ZodString;
            maximumCostUsd: z.ZodNumber;
        }, z.core.$strict>;
    }, z.core.$strict>;
    createdAt: z.ZodString;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type HostedProfileCandidateExport = z.infer<typeof HostedProfileCandidateExportSchema>;
export declare function verifyHostedProfileCandidateExport(raw: unknown): {
    schemaVersion: "openpond.hostedProfileCandidateExport.v1";
    actorId: string;
    teamId: string;
    candidateId: string;
    candidateRevision: number;
    projectId: string | null;
    profileRef: {
        source: "openpond_git";
        repositoryId: string;
        profileId: string;
    };
    expectedCommit: string;
    component: {
        kind: "agent" | "instruction" | "skill" | "workflow";
        path: string;
        workflowId?: string | undefined;
    };
    baseRelease: {
        id: string;
        contentHash: string;
    };
    frozenHash: string;
    executableSourceHash: string;
    protectedClosureHash: string;
    compiler: {
        workspaceId: string;
        name: string;
        repositoryId: string;
    };
    sourceManifest: {
        base64: string;
        contentHash: string;
        sizeBytes: number;
    };
    policySource: {
        agentSnapshot: {
            schemaVersion: "openpond.agentSnapshot.v2";
            id: string;
            sourceRelease: {
                id: string;
                contentHash: string;
            } | null;
            instructions: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            skills: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            agents: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            toolDeclarations: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            capabilityRequirements: {
                id: string;
                required: boolean;
                scopes: string[];
                portability: "host_adapter" | "hosted_only" | "local_only" | "portable";
            }[];
            dependencyLock: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            };
            portability: {
                portable: boolean;
                blockers: string[];
                localOnlyAssetRefs: string[];
                hostPrivateAssetRefs: string[];
            };
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        harnessRelease: {
            schemaVersion: "openpond.harnessRelease.v2";
            id: string;
            agentSnapshot: {
                id: string;
                contentHash: string;
            };
            program: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            };
            tools: {
                name: string;
                description: string;
                inputSchema: Record<string, unknown>;
                inputSchemaHash: string;
                sideEffect: "read" | "write";
                timeoutMs: number;
            }[];
            lifecycle: {
                create: true;
                reset: true;
                step: true;
                collect: true;
                destroy: true;
                resetScope: "attempt" | "task";
            };
            graderInterface: {
                visibleEvidence: string[];
                privilegedEvidence: string[];
                privateVerifierIsolation: boolean;
            };
            files: {
                id: string;
                path: string;
                contentHash: string;
                sizeBytes: number;
                mediaType: string;
                visibility: "host_private" | "policy" | "verifier";
            }[];
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        files: {
            path: string;
            base64: string;
        }[];
        schemaVersion: "openpond.harnessPolicySourcePackage.v1";
        contentHash: string;
    };
    qualification: {
        kind: "hosted_execution" | "owner_attested_local";
        ownerActorId: string;
        teamId: string;
        originalEvidence: {
            id: string;
            contentHash: string;
        };
        baseline: {
            id: string;
            contentHash: string;
        };
        candidate: {
            id: string;
            contentHash: string;
        };
        comparisonHash: string;
        recipe: {
            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;
            };
            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;
            modelId: string;
            maximumCostUsd: number;
        };
    };
    createdAt: string;
    contentHash: string;
};
export declare const HostedProfileCandidateReceiptSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.hostedProfileCandidateAdoption.v1">;
    id: z.ZodString;
    operationId: z.ZodString;
    actorId: z.ZodString;
    teamId: z.ZodString;
    candidateId: z.ZodString;
    exportHash: z.ZodString;
    executionOrigin: z.ZodEnum<{
        hosted_execution: "hosted_execution";
        owner_attested_local: "owner_attested_local";
    }>;
    qualification: z.ZodObject<{
        kind: z.ZodEnum<{
            hosted_execution: "hosted_execution";
            owner_attested_local: "owner_attested_local";
        }>;
        ownerActorId: z.ZodString;
        teamId: z.ZodString;
        originalEvidence: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        baseline: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        candidate: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        comparisonHash: z.ZodString;
        recipe: z.ZodObject<{
            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>;
            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>>;
            modelId: z.ZodString;
            maximumCostUsd: z.ZodNumber;
        }, z.core.$strict>;
    }, z.core.$strict>;
    testedCandidateRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    activeRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    expectedCommit: z.ZodString;
    committedProfileGit: z.ZodString;
    executableSourceHash: z.ZodString;
    protectedClosureHash: z.ZodString;
    createdAt: z.ZodString;
    contentHash: z.ZodString;
}, z.core.$strict>;
export type HostedProfileCandidateReceipt = z.infer<typeof HostedProfileCandidateReceiptSchema>;
export declare function verifyHostedProfileCandidateReceipt(raw: unknown): {
    schemaVersion: "openpond.hostedProfileCandidateAdoption.v1";
    id: string;
    operationId: string;
    actorId: string;
    teamId: string;
    candidateId: string;
    exportHash: string;
    executionOrigin: "hosted_execution" | "owner_attested_local";
    qualification: {
        kind: "hosted_execution" | "owner_attested_local";
        ownerActorId: string;
        teamId: string;
        originalEvidence: {
            id: string;
            contentHash: string;
        };
        baseline: {
            id: string;
            contentHash: string;
        };
        candidate: {
            id: string;
            contentHash: string;
        };
        comparisonHash: string;
        recipe: {
            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;
            };
            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;
            modelId: string;
            maximumCostUsd: number;
        };
    };
    testedCandidateRelease: {
        id: string;
        contentHash: string;
    };
    activeRelease: {
        id: string;
        contentHash: string;
    };
    expectedCommit: string;
    committedProfileGit: string;
    executableSourceHash: string;
    protectedClosureHash: string;
    createdAt: string;
    contentHash: string;
};
export declare const HostedProfileCandidateCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    operation: z.ZodLiteral<"adopt">;
    operationId: z.ZodString;
    export: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.hostedProfileCandidateExport.v1">;
        actorId: z.ZodString;
        teamId: z.ZodString;
        candidateId: z.ZodString;
        candidateRevision: z.ZodNumber;
        projectId: z.ZodNullable<z.ZodString>;
        profileRef: z.ZodObject<{
            source: z.ZodLiteral<"openpond_git">;
            repositoryId: z.ZodString;
            profileId: z.ZodString;
        }, z.core.$strict>;
        expectedCommit: z.ZodString;
        component: z.ZodObject<{
            kind: z.ZodEnum<{
                agent: "agent";
                instruction: "instruction";
                skill: "skill";
                workflow: "workflow";
            }>;
            path: z.ZodString;
            workflowId: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>;
        baseRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        frozenHash: z.ZodString;
        executableSourceHash: z.ZodString;
        protectedClosureHash: z.ZodString;
        compiler: z.ZodObject<{
            workspaceId: z.ZodString;
            name: z.ZodString;
            repositoryId: z.ZodString;
        }, z.core.$strict>;
        sourceManifest: z.ZodObject<{
            base64: z.ZodString;
            contentHash: z.ZodString;
            sizeBytes: z.ZodNumber;
        }, z.core.$strict>;
        policySource: z.ZodObject<{
            agentSnapshot: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.agentSnapshot.v2">;
                id: z.ZodString;
                sourceRelease: z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>>;
                instructions: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>>;
                skills: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>>;
                agents: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>>;
                toolDeclarations: z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    description: z.ZodString;
                    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                    inputSchemaHash: z.ZodString;
                    sideEffect: z.ZodEnum<{
                        read: "read";
                        write: "write";
                    }>;
                    timeoutMs: z.ZodNumber;
                }, z.core.$strict>>;
                capabilityRequirements: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    required: z.ZodBoolean;
                    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
                    portability: z.ZodEnum<{
                        host_adapter: "host_adapter";
                        hosted_only: "hosted_only";
                        local_only: "local_only";
                        portable: "portable";
                    }>;
                }, z.core.$strict>>;
                dependencyLock: z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>;
                portability: z.ZodObject<{
                    portable: z.ZodBoolean;
                    blockers: z.ZodArray<z.ZodString>;
                    localOnlyAssetRefs: z.ZodArray<z.ZodString>;
                    hostPrivateAssetRefs: z.ZodArray<z.ZodString>;
                }, z.core.$strict>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            harnessRelease: z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.harnessRelease.v2">;
                id: z.ZodString;
                agentSnapshot: z.ZodObject<{
                    id: z.ZodString;
                    contentHash: z.ZodString;
                }, z.core.$strict>;
                program: z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>;
                tools: z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    description: z.ZodString;
                    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                    inputSchemaHash: z.ZodString;
                    sideEffect: z.ZodEnum<{
                        read: "read";
                        write: "write";
                    }>;
                    timeoutMs: z.ZodNumber;
                }, z.core.$strict>>;
                lifecycle: z.ZodObject<{
                    create: z.ZodLiteral<true>;
                    reset: z.ZodLiteral<true>;
                    step: z.ZodLiteral<true>;
                    collect: z.ZodLiteral<true>;
                    destroy: z.ZodLiteral<true>;
                    resetScope: z.ZodEnum<{
                        attempt: "attempt";
                        task: "task";
                    }>;
                }, z.core.$strict>;
                graderInterface: z.ZodObject<{
                    visibleEvidence: z.ZodArray<z.ZodString>;
                    privilegedEvidence: z.ZodArray<z.ZodString>;
                    privateVerifierIsolation: z.ZodBoolean;
                }, z.core.$strict>;
                files: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    path: z.ZodString;
                    contentHash: z.ZodString;
                    sizeBytes: z.ZodNumber;
                    mediaType: z.ZodString;
                    visibility: z.ZodEnum<{
                        host_private: "host_private";
                        policy: "policy";
                        verifier: "verifier";
                    }>;
                }, z.core.$strict>>;
                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            files: z.ZodArray<z.ZodObject<{
                path: z.ZodString;
                base64: z.ZodString;
            }, z.core.$strict>>;
            schemaVersion: z.ZodLiteral<"openpond.harnessPolicySourcePackage.v1">;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        qualification: z.ZodObject<{
            kind: z.ZodEnum<{
                hosted_execution: "hosted_execution";
                owner_attested_local: "owner_attested_local";
            }>;
            ownerActorId: z.ZodString;
            teamId: z.ZodString;
            originalEvidence: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            baseline: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            candidate: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            comparisonHash: z.ZodString;
            recipe: z.ZodObject<{
                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>;
                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>>;
                modelId: z.ZodString;
                maximumCostUsd: z.ZodNumber;
            }, z.core.$strict>;
        }, z.core.$strict>;
        createdAt: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>, z.ZodObject<{
    operation: z.ZodEnum<{
        read: "read";
        rollback: "rollback";
    }>;
    operationId: z.ZodString;
    adoptionOperationId: z.ZodString;
    profileRepositoryId: z.ZodString;
}, z.core.$strict>], "operation">;
//# sourceMappingURL=experiment-improvement-hosted-adoption.d.ts.map