import { z } from "zod";
import { ToolLearningInstallationUpdateSchema, type ToolLearningRegistration, type ToolEpisodeAppend, type ToolLearningConsultationRequest } from "@openpond/evals/tool-learning";
/** Prepare and retain this request privately before registration. Retrying the
 * same bytes recovers issuance without storing plaintext on the host. */
export declare const ToolLearningRegistrationRequestSchema: z.ZodPreprocess<z.ZodObject<{
    registration: z.ZodPreprocess<z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.toolLearningRegistration.v1">;
        operationId: z.ZodString;
        installationId: z.ZodString;
        projectId: z.ZodString;
        machineSourceId: z.ZodString;
        client: z.ZodEnum<{
            claude_code: "claude_code";
            codex: "codex";
            opencode: "opencode";
            openpond: "openpond";
        }>;
        clientVersion: z.ZodString;
        adapterRelease: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>;
        collectionPolicy: z.ZodObject<{
            revision: z.ZodNumber;
            permittedTools: z.ZodArray<z.ZodString>;
            workspaceRootHashes: z.ZodArray<z.ZodString>;
            permittedFields: z.ZodArray<z.ZodEnum<{
                action: "action";
                artifact_reference: "artifact_reference";
                intent: "intent";
                result_excerpt: "result_excerpt";
                state: "state";
            }>>;
            unchangedControls: z.ZodObject<{
                numerator: z.ZodNumber;
                denominator: z.ZodNumber;
            }, z.core.$strict>;
            maximumEventBytes: z.ZodNumber;
            maximumEpisodeBytes: z.ZodNumber;
            maximumEpisodeEvents: z.ZodNumber;
            maximumQueueBytes: z.ZodNumber;
            maximumQueueEvents: z.ZodNumber;
            maximumQueueAgeSeconds: z.ZodNumber;
            rawRetentionDays: z.ZodNumber;
            purposes: z.ZodArray<z.ZodEnum<{
                capture: "capture";
                consultation: "consultation";
            }>>;
            modelUpdates: z.ZodLiteral<"requires_separate_review">;
            variantGeneration: z.ZodLiteral<"disabled">;
        }, z.core.$strict>;
    }, z.core.$strict>>;
    credential: z.ZodObject<{
        apiKey: z.ZodString;
        expiresAt: z.ZodISODateTime;
    }, z.core.$strict>;
}, z.core.$strict>>;
export declare const ToolLearningProjectionRequestSchema: z.ZodPreprocess<z.ZodObject<{
    operationId: z.ZodString;
    expectedRevision: z.ZodNumber;
    episodeId: z.ZodString;
    failure: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    recovery: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    taskDefinition: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    familyKey: z.ZodString;
    split: z.ZodLiteral<"train">;
    proposedTarget: z.ZodDiscriminatedUnion<[z.ZodObject<{
        decision: z.ZodLiteral<"proceed">;
    }, z.core.$strict>, z.ZodObject<{
        decision: z.ZodLiteral<"revise">;
        issues: z.ZodArray<z.ZodObject<{
            category: z.ZodString;
            feedback: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>, z.ZodObject<{
        decision: z.ZodLiteral<"needs_context">;
        missing: z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            reason: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>], "decision">;
    saveToPrivateDataset: z.ZodLiteral<true>;
    targetApproval: z.ZodLiteral<"pending_owner_review">;
}, z.core.$strict>>;
export declare const ToolLearningProjectionReceiptSchema: z.ZodPreprocess<z.ZodObject<{
    installationId: z.ZodString;
    projectId: z.ZodString;
    operationId: z.ZodString;
    source: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    evidence: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
        revision: z.ZodNumber;
    }, z.core.$strict>;
    originHash: z.ZodString;
    requestHash: z.ZodString;
    projectedAt: z.ZodISODateTime;
    targetApproval: z.ZodLiteral<"pending_owner_review">;
    learningEnrollment: z.ZodLiteral<false>;
}, z.core.$strict>>;
/** Explicit owner selection. Capturing events never authorizes inference spend. */
export declare const ToolLearningRoutingRequestSchema: z.ZodPreprocess<z.ZodObject<{
    operationId: z.ZodString;
    expectedRevision: z.ZodNumber;
    state: z.ZodEnum<{
        disabled: "disabled";
        enabled: "enabled";
    }>;
    modelId: z.ZodString;
    qualification: z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"integration">;
        evaluationRunId: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"learned">;
        evaluationRunId: z.ZodString;
        baselineRunId: z.ZodString;
        trainingRunId: z.ZodString;
    }, z.core.$strict>], "kind">;
    capabilities: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        application: z.ZodString;
        versions: z.ZodArray<z.ZodString>;
        tools: z.ZodArray<z.ZodString>;
        mode: z.ZodLiteral<"recovery">;
        routingInstruction: z.ZodString;
    }, z.core.$strict>>;
    limits: z.ZodObject<{
        maxOutputTokens: z.ZodNumber;
        maximumCallUsd: z.ZodNumber;
        maximumDayUsd: z.ZodNumber;
        maximumSessionCalls: z.ZodNumber;
        maximumDayCalls: z.ZodNumber;
    }, z.core.$strict>;
}, z.core.$strict>>;
export declare const ToolLearningRoutingSchema: z.ZodPreprocess<z.ZodObject<{
    installationId: z.ZodString;
    scope: z.ZodObject<{
        teamId: z.ZodString;
        projectId: z.ZodString;
    }, z.core.$strict>;
    revision: z.ZodNumber;
    operationId: z.ZodString;
    requestHash: z.ZodString;
    configuration: z.ZodPreprocess<z.ZodObject<{
        operationId: z.ZodString;
        expectedRevision: z.ZodNumber;
        state: z.ZodEnum<{
            disabled: "disabled";
            enabled: "enabled";
        }>;
        modelId: z.ZodString;
        qualification: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"integration">;
            evaluationRunId: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"learned">;
            evaluationRunId: z.ZodString;
            baselineRunId: z.ZodString;
            trainingRunId: z.ZodString;
        }, z.core.$strict>], "kind">;
        capabilities: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            application: z.ZodString;
            versions: z.ZodArray<z.ZodString>;
            tools: z.ZodArray<z.ZodString>;
            mode: z.ZodLiteral<"recovery">;
            routingInstruction: z.ZodString;
        }, z.core.$strict>>;
        limits: z.ZodObject<{
            maxOutputTokens: z.ZodNumber;
            maximumCallUsd: z.ZodNumber;
            maximumDayUsd: z.ZodNumber;
            maximumSessionCalls: z.ZodNumber;
            maximumDayCalls: z.ZodNumber;
        }, z.core.$strict>;
    }, z.core.$strict>>;
    modelRelease: z.ZodObject<{
        id: z.ZodString;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    policySystemPrompt: z.ZodString;
    capabilities: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        application: z.ZodString;
        versions: z.ZodArray<z.ZodString>;
        tools: z.ZodArray<z.ZodString>;
        mode: z.ZodLiteral<"recovery">;
        routingInstruction: z.ZodString;
        qualification: z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"integration">;
            receipt: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"learned">;
            receipt: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            trainingRun: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            adapter: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            evaluation: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
            activation: z.ZodObject<{
                id: z.ZodString;
                contentHash: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>], "kind">;
    }, z.core.$strict>>;
    updatedAt: z.ZodISODateTime;
}, z.core.$strict>>;
export declare function prepareToolLearningRegistration(registration: ToolLearningRegistration, expiresAt: string): {
    registration: {
        schemaVersion: "openpond.toolLearningRegistration.v1";
        operationId: string;
        installationId: string;
        projectId: string;
        machineSourceId: string;
        client: "claude_code" | "codex" | "opencode" | "openpond";
        clientVersion: string;
        adapterRelease: {
            id: string;
            contentHash: string;
        };
        collectionPolicy: {
            revision: number;
            permittedTools: string[];
            workspaceRootHashes: string[];
            permittedFields: ("action" | "artifact_reference" | "intent" | "result_excerpt" | "state")[];
            unchangedControls: {
                numerator: number;
                denominator: number;
            };
            maximumEventBytes: number;
            maximumEpisodeBytes: number;
            maximumEpisodeEvents: number;
            maximumQueueBytes: number;
            maximumQueueEvents: number;
            maximumQueueAgeSeconds: number;
            rawRetentionDays: number;
            purposes: ("capture" | "consultation")[];
            modelUpdates: "requires_separate_review";
            variantGeneration: "disabled";
        };
    };
    credential: {
        apiKey: string;
        expiresAt: string;
    };
};
export declare class OpenPondToolLearningError extends Error {
    readonly status: number;
    readonly code: string;
    constructor(status: number, code: string);
}
/** Owner credentials register/control installations. External hooks and MCP
 * use only the separate installation credential returned by registration. */
type ToolLearningClientOptions = {
    baseUrl: string;
    apiKey: string;
    teamId: string;
    projectId: string;
    fetch?: typeof globalThis.fetch;
};
export declare class OpenPondToolLearningClient {
    #private;
    constructor(options: ToolLearningClientOptions);
    register(value: z.input<typeof ToolLearningRegistrationRequestSchema>, signal?: AbortSignal): Promise<{
        installation: {
            schemaVersion: "openpond.toolLearningInstallation.v1";
            id: string;
            revision: number;
            scope: {
                teamId: string;
                projectId: string;
            };
            ownerUserId: string;
            machineSourceId: string;
            client: "claude_code" | "codex" | "opencode" | "openpond";
            clientVersion: string;
            adapterRelease: {
                id: string;
                contentHash: string;
            };
            state: "disabled" | "enabled" | "pending_client_trust" | "revoked";
            collectionPolicy: {
                revision: number;
                permittedTools: string[];
                workspaceRootHashes: string[];
                permittedFields: ("action" | "artifact_reference" | "intent" | "result_excerpt" | "state")[];
                unchangedControls: {
                    numerator: number;
                    denominator: number;
                };
                maximumEventBytes: number;
                maximumEpisodeBytes: number;
                maximumEpisodeEvents: number;
                maximumQueueBytes: number;
                maximumQueueEvents: number;
                maximumQueueAgeSeconds: number;
                rawRetentionDays: number;
                purposes: ("capture" | "consultation")[];
                modelUpdates: "requires_separate_review";
                variantGeneration: "disabled";
            };
            collectionPolicyHash: string;
            coverage: {
                receipt: {
                    id: string;
                    contentHash: string;
                } | null;
                start: "documented" | "observed" | "unqualified" | "unsupported";
                resume: "documented" | "observed" | "unqualified" | "unsupported";
                compaction: "documented" | "observed" | "unqualified" | "unsupported";
                executionFailure: "documented" | "observed" | "unqualified" | "unsupported";
                processFailure: "documented" | "observed" | "unqualified" | "unsupported";
                validationFailure: "documented" | "observed" | "unqualified" | "unsupported";
                nestedCalls: "documented" | "observed" | "unqualified" | "unsupported";
                contextRefresh: "revision_aware_turn" | "session_start" | "start_resume" | "start_resume_compaction" | "unqualified";
                gaps: string[];
            };
            credential: {
                id: string;
                expiresAt: string;
                revokedAt: string | null;
                capabilities: ("consultation_read" | "consultation_submit" | "episode_append" | "manifest_read")[];
            } | null;
            createdAt: string;
            updatedAt: string;
        };
        apiKey: string;
    }>;
    installation(id: string, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.toolLearningInstallation.v1";
        id: string;
        revision: number;
        scope: {
            teamId: string;
            projectId: string;
        };
        ownerUserId: string;
        machineSourceId: string;
        client: "claude_code" | "codex" | "opencode" | "openpond";
        clientVersion: string;
        adapterRelease: {
            id: string;
            contentHash: string;
        };
        state: "disabled" | "enabled" | "pending_client_trust" | "revoked";
        collectionPolicy: {
            revision: number;
            permittedTools: string[];
            workspaceRootHashes: string[];
            permittedFields: ("action" | "artifact_reference" | "intent" | "result_excerpt" | "state")[];
            unchangedControls: {
                numerator: number;
                denominator: number;
            };
            maximumEventBytes: number;
            maximumEpisodeBytes: number;
            maximumEpisodeEvents: number;
            maximumQueueBytes: number;
            maximumQueueEvents: number;
            maximumQueueAgeSeconds: number;
            rawRetentionDays: number;
            purposes: ("capture" | "consultation")[];
            modelUpdates: "requires_separate_review";
            variantGeneration: "disabled";
        };
        collectionPolicyHash: string;
        coverage: {
            receipt: {
                id: string;
                contentHash: string;
            } | null;
            start: "documented" | "observed" | "unqualified" | "unsupported";
            resume: "documented" | "observed" | "unqualified" | "unsupported";
            compaction: "documented" | "observed" | "unqualified" | "unsupported";
            executionFailure: "documented" | "observed" | "unqualified" | "unsupported";
            processFailure: "documented" | "observed" | "unqualified" | "unsupported";
            validationFailure: "documented" | "observed" | "unqualified" | "unsupported";
            nestedCalls: "documented" | "observed" | "unqualified" | "unsupported";
            contextRefresh: "revision_aware_turn" | "session_start" | "start_resume" | "start_resume_compaction" | "unqualified";
            gaps: string[];
        };
        credential: {
            id: string;
            expiresAt: string;
            revokedAt: string | null;
            capabilities: ("consultation_read" | "consultation_submit" | "episode_append" | "manifest_read")[];
        } | null;
        createdAt: string;
        updatedAt: string;
    }>;
    installations(after?: string, signal?: AbortSignal): Promise<{
        items: {
            schemaVersion: "openpond.toolLearningInstallation.v1";
            id: string;
            revision: number;
            scope: {
                teamId: string;
                projectId: string;
            };
            ownerUserId: string;
            machineSourceId: string;
            client: "claude_code" | "codex" | "opencode" | "openpond";
            clientVersion: string;
            adapterRelease: {
                id: string;
                contentHash: string;
            };
            state: "disabled" | "enabled" | "pending_client_trust" | "revoked";
            collectionPolicy: {
                revision: number;
                permittedTools: string[];
                workspaceRootHashes: string[];
                permittedFields: ("action" | "artifact_reference" | "intent" | "result_excerpt" | "state")[];
                unchangedControls: {
                    numerator: number;
                    denominator: number;
                };
                maximumEventBytes: number;
                maximumEpisodeBytes: number;
                maximumEpisodeEvents: number;
                maximumQueueBytes: number;
                maximumQueueEvents: number;
                maximumQueueAgeSeconds: number;
                rawRetentionDays: number;
                purposes: ("capture" | "consultation")[];
                modelUpdates: "requires_separate_review";
                variantGeneration: "disabled";
            };
            collectionPolicyHash: string;
            coverage: {
                receipt: {
                    id: string;
                    contentHash: string;
                } | null;
                start: "documented" | "observed" | "unqualified" | "unsupported";
                resume: "documented" | "observed" | "unqualified" | "unsupported";
                compaction: "documented" | "observed" | "unqualified" | "unsupported";
                executionFailure: "documented" | "observed" | "unqualified" | "unsupported";
                processFailure: "documented" | "observed" | "unqualified" | "unsupported";
                validationFailure: "documented" | "observed" | "unqualified" | "unsupported";
                nestedCalls: "documented" | "observed" | "unqualified" | "unsupported";
                contextRefresh: "revision_aware_turn" | "session_start" | "start_resume" | "start_resume_compaction" | "unqualified";
                gaps: string[];
            };
            credential: {
                id: string;
                expiresAt: string;
                revokedAt: string | null;
                capabilities: ("consultation_read" | "consultation_submit" | "episode_append" | "manifest_read")[];
            } | null;
            createdAt: string;
            updatedAt: string;
        }[];
        nextCursor: string | null;
    }>;
    episodes(installationId: string, after?: string, signal?: AbortSignal): Promise<{
        installationId: string;
        scope: {
            teamId: string;
            projectId: string;
        };
        items: {
            episodeId: string;
            eventCount: number;
            lastReceivedAt: string;
        }[];
        nextCursor: string | null;
        learningEnrollment: false;
    }>;
    episode(installationId: string, episodeId: string, signal?: AbortSignal): Promise<{
        installationId: string;
        episodeId: string;
        scope: {
            teamId: string;
            projectId: string;
        };
        events: ({
            schemaVersion: "openpond.toolEpisodeEvent.v1";
            operationId: string;
            installationId: string;
            episodeId: string;
            eventId: string;
            sessionId: string;
            parentSessionId: string | null;
            turnId: string | null;
            callId: string;
            occurredAt: string;
            sequence: number;
            adapterVersion: string;
            sanitization: {
                policyRevision: number;
                policyHash: string;
                redactedFields: number;
                omittedFields: number;
                truncated: boolean;
            };
            contentHash: string;
            eventKind: "attempt";
            payload: {
                intent: string;
                tool: {
                    name: string;
                    version: string | null;
                    server: string | null;
                };
                action: {
                    kind: "python";
                    code: string;
                } | {
                    kind: "shell";
                    command: string;
                    shell: string;
                } | {
                    kind: "tool_arguments";
                    arguments: Record<string, z.JSONType>;
                } | {
                    kind: "edit";
                    patch: string;
                    baseFiles: {
                        path: string;
                        contentHash: string | null;
                    }[];
                };
                actionHash: string;
                environment: {
                    application: string;
                    version: string;
                    state: Record<string, string | number | boolean | null>;
                    fingerprint: string;
                };
                contextAssets: {
                    id: string;
                    contentHash: string;
                    mediaType: "application/json" | "text/plain" | "text/x-diff" | "text/x-python";
                    sizeBytes: number;
                    purpose: "action" | "result" | "state" | "verification";
                }[];
                selection: {
                    kind: "eligible_attempt";
                } | {
                    kind: "unchanged_control";
                    numerator: number;
                    denominator: number;
                    policyHash: string;
                };
            };
        } | {
            schemaVersion: "openpond.toolEpisodeEvent.v1";
            operationId: string;
            installationId: string;
            episodeId: string;
            eventId: string;
            sessionId: string;
            parentSessionId: string | null;
            turnId: string | null;
            callId: string;
            occurredAt: string;
            sequence: number;
            adapterVersion: string;
            sanitization: {
                policyRevision: number;
                policyHash: string;
                redactedFields: number;
                omittedFields: number;
                truncated: boolean;
            };
            contentHash: string;
            eventKind: "observation";
            payload: {
                attempt: {
                    id: string;
                    contentHash: string;
                };
                actionHash: string;
                execution: "executed" | "not_executed" | "unknown";
                sideEffects: "none" | "observed" | "possible" | "unknown";
                resultExcerpt: string;
                resultHash: string | null;
                assets: {
                    id: string;
                    contentHash: string;
                    mediaType: "application/json" | "text/plain" | "text/x-diff" | "text/x-python";
                    sizeBytes: number;
                    purpose: "action" | "result" | "state" | "verification";
                }[];
                outcome: "succeeded";
                exitCode: 0 | null;
            } | {
                attempt: {
                    id: string;
                    contentHash: string;
                };
                actionHash: string;
                execution: "executed" | "not_executed" | "unknown";
                sideEffects: "none" | "observed" | "possible" | "unknown";
                resultExcerpt: string;
                resultHash: string | null;
                assets: {
                    id: string;
                    contentHash: string;
                    mediaType: "application/json" | "text/plain" | "text/x-diff" | "text/x-python";
                    sizeBytes: number;
                    purpose: "action" | "result" | "state" | "verification";
                }[];
                outcome: "failed";
                classification: "authorization_denied" | "cancelled" | "execution_failure" | "infrastructure_failure" | "outcome_failure" | "process_failure" | "timeout" | "unknown_failure" | "validation_failure";
                errorCode: string;
                message: string;
                exitCode: number | null;
            } | {
                attempt: {
                    id: string;
                    contentHash: string;
                };
                actionHash: string;
                execution: "executed" | "not_executed" | "unknown";
                sideEffects: "none" | "observed" | "possible" | "unknown";
                resultExcerpt: string;
                resultHash: string | null;
                assets: {
                    id: string;
                    contentHash: string;
                    mediaType: "application/json" | "text/plain" | "text/x-diff" | "text/x-python";
                    sizeBytes: number;
                    purpose: "action" | "result" | "state" | "verification";
                }[];
                outcome: "incomplete";
                reason: "completion_not_observed" | "coverage_gap" | "observer_restarted" | "transport_interrupted";
            };
        } | {
            schemaVersion: "openpond.toolEpisodeEvent.v1";
            operationId: string;
            installationId: string;
            episodeId: string;
            eventId: string;
            sessionId: string;
            parentSessionId: string | null;
            turnId: string | null;
            callId: string;
            occurredAt: string;
            sequence: number;
            adapterVersion: string;
            sanitization: {
                policyRevision: number;
                policyHash: string;
                redactedFields: number;
                omittedFields: number;
                truncated: boolean;
            };
            contentHash: string;
            eventKind: "recovery_link";
            payload: {
                failedAttempt: {
                    id: string;
                    contentHash: string;
                };
                failedObservation: {
                    id: string;
                    contentHash: string;
                };
                replacementAttempt: {
                    id: string;
                    contentHash: string;
                };
                goalId: string;
                basis: "artifact_lineage" | "explicit_relation" | "unverified";
                attributionEvidence: {
                    id: string;
                    contentHash: string;
                }[];
            };
        } | {
            schemaVersion: "openpond.toolEpisodeEvent.v1";
            operationId: string;
            installationId: string;
            episodeId: string;
            eventId: string;
            sessionId: string;
            parentSessionId: string | null;
            turnId: string | null;
            callId: string;
            occurredAt: string;
            sequence: number;
            adapterVersion: string;
            sanitization: {
                policyRevision: number;
                policyHash: string;
                redactedFields: number;
                omittedFields: number;
                truncated: boolean;
            };
            contentHash: string;
            eventKind: "verification";
            payload: {
                attempt: {
                    id: string;
                    contentHash: string;
                };
                actionHash: string;
                outcome: "failed" | "passed" | "unknown";
                verifierRelease: {
                    id: string;
                    contentHash: string;
                } | null;
                verifierReceipt: {
                    id: string;
                    contentHash: string;
                } | null;
                environmentFingerprint: string;
                resetStateHash: string | null;
                outputArtifacts: {
                    id: string;
                    contentHash: string;
                    mediaType: "application/json" | "text/plain" | "text/x-diff" | "text/x-python";
                    sizeBytes: number;
                    purpose: "action" | "result" | "state" | "verification";
                }[];
                reason: string;
            };
        } | {
            schemaVersion: "openpond.toolEpisodeEvent.v1";
            operationId: string;
            installationId: string;
            episodeId: string;
            eventId: string;
            sessionId: string;
            parentSessionId: string | null;
            turnId: string | null;
            callId: string;
            occurredAt: string;
            sequence: number;
            adapterVersion: string;
            sanitization: {
                policyRevision: number;
                policyHash: string;
                redactedFields: number;
                omittedFields: number;
                truncated: boolean;
            };
            contentHash: string;
            eventKind: "lineage";
            payload: {
                relation: "fork" | "reopen" | "split";
                parentEpisode: {
                    id: string;
                    contentHash: string;
                };
                parentSessionId: string;
                reason: string;
            };
        })[];
        state: "ambiguous" | "awaiting_owner_review" | "incomplete";
        assembly: {
            state: "ambiguous" | "awaiting_owner_review" | "incomplete";
            issues: ("completion_not_observed" | "conflicting_event" | "conflicting_observations" | "lineage_mismatch" | "missing_attempt" | "missing_observation" | "mixed_scope" | "reference_mismatch")[];
            groups: {
                key: string;
                application: string;
                applicationVersion: string;
                tool: {
                    name: string;
                    version: string | null;
                    server: string | null;
                };
                environmentFingerprints: string[];
                attempts: {
                    id: string;
                    contentHash: string;
                }[];
            }[];
        };
        verificationAuthority: "not_granted";
        learningEnrollment: false;
    }>;
    purge(installationId: string, input: {
        operationId: string;
        expectedRevision: number;
    }, signal?: AbortSignal): Promise<{
        installationId: string;
        operationId: string;
        purgedEvents: number;
        learningEnrollment: false;
    }>;
    project(installationId: string, value: z.input<typeof ToolLearningProjectionRequestSchema>, signal?: AbortSignal): Promise<{
        installationId: string;
        projectId: string;
        operationId: string;
        source: {
            id: string;
            contentHash: string;
            revision: number;
        };
        evidence: {
            id: string;
            contentHash: string;
            revision: number;
        };
        originHash: string;
        requestHash: string;
        projectedAt: string;
        targetApproval: "pending_owner_review";
        learningEnrollment: false;
    }>;
    setState(id: string, value: z.input<typeof ToolLearningInstallationUpdateSchema>, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.toolLearningInstallation.v1";
        id: string;
        revision: number;
        scope: {
            teamId: string;
            projectId: string;
        };
        ownerUserId: string;
        machineSourceId: string;
        client: "claude_code" | "codex" | "opencode" | "openpond";
        clientVersion: string;
        adapterRelease: {
            id: string;
            contentHash: string;
        };
        state: "disabled" | "enabled" | "pending_client_trust" | "revoked";
        collectionPolicy: {
            revision: number;
            permittedTools: string[];
            workspaceRootHashes: string[];
            permittedFields: ("action" | "artifact_reference" | "intent" | "result_excerpt" | "state")[];
            unchangedControls: {
                numerator: number;
                denominator: number;
            };
            maximumEventBytes: number;
            maximumEpisodeBytes: number;
            maximumEpisodeEvents: number;
            maximumQueueBytes: number;
            maximumQueueEvents: number;
            maximumQueueAgeSeconds: number;
            rawRetentionDays: number;
            purposes: ("capture" | "consultation")[];
            modelUpdates: "requires_separate_review";
            variantGeneration: "disabled";
        };
        collectionPolicyHash: string;
        coverage: {
            receipt: {
                id: string;
                contentHash: string;
            } | null;
            start: "documented" | "observed" | "unqualified" | "unsupported";
            resume: "documented" | "observed" | "unqualified" | "unsupported";
            compaction: "documented" | "observed" | "unqualified" | "unsupported";
            executionFailure: "documented" | "observed" | "unqualified" | "unsupported";
            processFailure: "documented" | "observed" | "unqualified" | "unsupported";
            validationFailure: "documented" | "observed" | "unqualified" | "unsupported";
            nestedCalls: "documented" | "observed" | "unqualified" | "unsupported";
            contextRefresh: "revision_aware_turn" | "session_start" | "start_resume" | "start_resume_compaction" | "unqualified";
            gaps: string[];
        };
        credential: {
            id: string;
            expiresAt: string;
            revokedAt: string | null;
            capabilities: ("consultation_read" | "consultation_submit" | "episode_append" | "manifest_read")[];
        } | null;
        createdAt: string;
        updatedAt: string;
    }>;
    append(value: ToolEpisodeAppend, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.toolEpisodeAppendReceipt.v1";
        operationId: string;
        requestHash: string;
        installationId: string;
        teamId: string;
        projectId: string;
        receivedAt: string;
        events: {
            eventId: string;
            contentHash: string;
            state: "already_retained" | "privacy_rejected" | "retained";
            receiptId: string;
            reason: string | null;
        }[];
        learningEnrollment: false;
    }>;
    routing(installationId: string, signal?: AbortSignal): Promise<{
        installationId: string;
        scope: {
            teamId: string;
            projectId: string;
        };
        revision: number;
        operationId: string;
        requestHash: string;
        configuration: {
            operationId: string;
            expectedRevision: number;
            state: "disabled" | "enabled";
            modelId: string;
            qualification: {
                kind: "integration";
                evaluationRunId: string;
            } | {
                kind: "learned";
                evaluationRunId: string;
                baselineRunId: string;
                trainingRunId: string;
            };
            capabilities: {
                id: string;
                application: string;
                versions: string[];
                tools: string[];
                mode: "recovery";
                routingInstruction: string;
            }[];
            limits: {
                maxOutputTokens: number;
                maximumCallUsd: number;
                maximumDayUsd: number;
                maximumSessionCalls: number;
                maximumDayCalls: number;
            };
        };
        modelRelease: {
            id: string;
            contentHash: string;
        };
        policySystemPrompt: string;
        capabilities: {
            id: string;
            application: string;
            versions: string[];
            tools: string[];
            mode: "recovery";
            routingInstruction: string;
            qualification: {
                kind: "integration";
                receipt: {
                    id: string;
                    contentHash: string;
                };
            } | {
                kind: "learned";
                receipt: {
                    id: string;
                    contentHash: string;
                };
                trainingRun: {
                    id: string;
                    contentHash: string;
                };
                adapter: {
                    id: string;
                    contentHash: string;
                };
                evaluation: {
                    id: string;
                    contentHash: string;
                };
                activation: {
                    id: string;
                    contentHash: string;
                };
            };
        }[];
        updatedAt: string;
    }>;
    configureRouting(installationId: string, value: z.input<typeof ToolLearningRoutingRequestSchema>, signal?: AbortSignal): Promise<{
        installationId: string;
        scope: {
            teamId: string;
            projectId: string;
        };
        revision: number;
        operationId: string;
        requestHash: string;
        configuration: {
            operationId: string;
            expectedRevision: number;
            state: "disabled" | "enabled";
            modelId: string;
            qualification: {
                kind: "integration";
                evaluationRunId: string;
            } | {
                kind: "learned";
                evaluationRunId: string;
                baselineRunId: string;
                trainingRunId: string;
            };
            capabilities: {
                id: string;
                application: string;
                versions: string[];
                tools: string[];
                mode: "recovery";
                routingInstruction: string;
            }[];
            limits: {
                maxOutputTokens: number;
                maximumCallUsd: number;
                maximumDayUsd: number;
                maximumSessionCalls: number;
                maximumDayCalls: number;
            };
        };
        modelRelease: {
            id: string;
            contentHash: string;
        };
        policySystemPrompt: string;
        capabilities: {
            id: string;
            application: string;
            versions: string[];
            tools: string[];
            mode: "recovery";
            routingInstruction: string;
            qualification: {
                kind: "integration";
                receipt: {
                    id: string;
                    contentHash: string;
                };
            } | {
                kind: "learned";
                receipt: {
                    id: string;
                    contentHash: string;
                };
                trainingRun: {
                    id: string;
                    contentHash: string;
                };
                adapter: {
                    id: string;
                    contentHash: string;
                };
                evaluation: {
                    id: string;
                    contentHash: string;
                };
                activation: {
                    id: string;
                    contentHash: string;
                };
            };
        }[];
        updatedAt: string;
    }>;
    manifest(installationId: string, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.toolLearningManifest.v1";
        installationId: string;
        scope: {
            teamId: string;
            projectId: string;
        };
        revision: number;
        contentHash: string;
        issuedAt: string;
        expiresAt: string;
        modelRelease: {
            id: string;
            contentHash: string;
        };
        responseSchema: "openpond.toolLearningDecision.v1";
        capabilities: {
            id: string;
            application: string;
            versions: string[];
            tools: string[];
            mode: "recovery";
            routingInstruction: string;
            qualification: {
                kind: "integration";
                receipt: {
                    id: string;
                    contentHash: string;
                };
            } | {
                kind: "learned";
                receipt: {
                    id: string;
                    contentHash: string;
                };
                trainingRun: {
                    id: string;
                    contentHash: string;
                };
                adapter: {
                    id: string;
                    contentHash: string;
                };
                evaluation: {
                    id: string;
                    contentHash: string;
                };
                activation: {
                    id: string;
                    contentHash: string;
                };
            };
        }[];
    }>;
    consult(value: ToolLearningConsultationRequest, signal?: AbortSignal): Promise<{
        operationId: string;
        installationId: string;
        capabilityId: string;
        manifestHash: string;
        modelRelease: {
            id: string;
            contentHash: string;
        };
        actionHash: string;
        contextHash: string;
        schemaVersion: "openpond.toolLearningDecision.v1";
        state: "completed";
        decision: {
            decision: "proceed";
        } | {
            decision: "revise";
            issues: {
                category: string;
                feedback: string;
            }[];
        } | {
            decision: "needs_context";
            missing: {
                field: string;
                reason: string;
            }[];
        };
        usageReceipt: {
            id: string;
            contentHash: string;
        };
        completedAt: string;
    } | {
        operationId: string;
        installationId: string;
        capabilityId: string;
        manifestHash: string;
        modelRelease: {
            id: string;
            contentHash: string;
        };
        actionHash: string;
        contextHash: string;
        schemaVersion: "openpond.toolLearningDecision.v1";
        state: "unavailable";
        reason: "budget_exhausted" | "cancelled" | "disabled" | "dispatch_uncertain" | "expired_manifest" | "invalid_output" | "revoked" | "timeout" | "unsupported_scope";
        usageReceipt: {
            id: string;
            contentHash: string;
        } | null;
    }>;
    consultation(value: ToolLearningConsultationRequest, signal?: AbortSignal): Promise<{
        operationId: string;
        installationId: string;
        capabilityId: string;
        manifestHash: string;
        modelRelease: {
            id: string;
            contentHash: string;
        };
        actionHash: string;
        contextHash: string;
        schemaVersion: "openpond.toolLearningDecision.v1";
        state: "completed";
        decision: {
            decision: "proceed";
        } | {
            decision: "revise";
            issues: {
                category: string;
                feedback: string;
            }[];
        } | {
            decision: "needs_context";
            missing: {
                field: string;
                reason: string;
            }[];
        };
        usageReceipt: {
            id: string;
            contentHash: string;
        };
        completedAt: string;
    } | {
        operationId: string;
        installationId: string;
        capabilityId: string;
        manifestHash: string;
        modelRelease: {
            id: string;
            contentHash: string;
        };
        actionHash: string;
        contextHash: string;
        schemaVersion: "openpond.toolLearningDecision.v1";
        state: "unavailable";
        reason: "budget_exhausted" | "cancelled" | "disabled" | "dispatch_uncertain" | "expired_manifest" | "invalid_output" | "revoked" | "timeout" | "unsupported_scope";
        usageReceipt: {
            id: string;
            contentHash: string;
        } | null;
    }>;
}
export {};
//# sourceMappingURL=tool-learning-client.d.ts.map