import { z } from 'zod';
import type { Context } from '@deepseek-ai/cordis';
export declare const COPILOT_CONTEXT_EVIDENCE = "githubCopilotContextEvidence";
export declare const ContextEvidenceSchema: z.ZodObject<{
    route: z.ZodNullable<z.ZodObject<{
        provider: z.ZodString;
        model: z.ZodString;
    }, z.core.$strict>>;
    sample: z.ZodNullable<z.ZodObject<{
        tokens: z.ZodNumber;
        seq: z.ZodNumber;
        route: z.ZodObject<{
            provider: z.ZodString;
            model: z.ZodString;
        }, z.core.$strict>;
    }, z.core.$strict>>;
    invalid: z.ZodBoolean;
    reason: z.ZodEnum<{
        none: "none";
        compaction: "compaction";
        unknown: "unknown";
        "failed-zero": "failed-zero";
        "invalid-sample": "invalid-sample";
        selection: "selection";
    }>;
    incident: z.ZodNullable<z.ZodObject<{
        kind: z.ZodEnum<{
            "failed-zero": "failed-zero";
            "invalid-sample": "invalid-sample";
        }>;
        seq: z.ZodNumber;
    }, z.core.$strict>>;
    compaction: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        startSeq: z.ZodNumber;
        endSeq: z.ZodNullable<z.ZodNumber>;
        state: z.ZodEnum<{
            running: "running";
            unknown: "unknown";
            failed: "failed";
            completed: "completed";
        }>;
        checkpoint: z.ZodBoolean;
        headerSeq: z.ZodNullable<z.ZodNumber>;
        requestRoute: z.ZodNullable<z.ZodObject<{
            provider: z.ZodString;
            model: z.ZodString;
        }, z.core.$strict>>;
        step: z.ZodNullable<z.ZodObject<{
            turn: z.ZodNumber;
            step: z.ZodNumber;
        }, z.core.$strict>>;
        request: z.ZodEnum<{
            unknown: "unknown";
            cancelled: "cancelled";
            failed: "failed";
            pending: "pending";
            idle: "idle";
            succeeded: "succeeded";
        }>;
    }, z.core.$strict>>>;
    activeStep: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        turn: z.ZodNumber;
        step: z.ZodNumber;
    }, z.core.$strict>>>;
}, z.core.$strict>;
export type ContextEvidence = z.infer<typeof ContextEvidenceSchema>;
declare module '@deepseek-ai/dsh-session-projection/types' {
    interface SessionProjectionMap {
        githubCopilotContextEvidence: ContextEvidence;
    }
    interface SessionProjectionStateMap {
        githubCopilotContextEvidence: ContextEvidence;
    }
}
export declare function initialContextEvidence(): ContextEvidence;
/** Read only counts and routing leaves; never message content or opaque replay. */
export declare function foldContextEvidence(state: ContextEvidence, event: unknown): ContextEvidence;
/** Separate bounded replay unit; never register under or modify a Core key. */
export declare const contextEvidenceDefinition: {
    key: "githubCopilotContextEvidence";
    stateVersion: number;
    stateSchema: z.ZodObject<{
        route: z.ZodNullable<z.ZodObject<{
            provider: z.ZodString;
            model: z.ZodString;
        }, z.core.$strict>>;
        sample: z.ZodNullable<z.ZodObject<{
            tokens: z.ZodNumber;
            seq: z.ZodNumber;
            route: z.ZodObject<{
                provider: z.ZodString;
                model: z.ZodString;
            }, z.core.$strict>;
        }, z.core.$strict>>;
        invalid: z.ZodBoolean;
        reason: z.ZodEnum<{
            none: "none";
            compaction: "compaction";
            unknown: "unknown";
            "failed-zero": "failed-zero";
            "invalid-sample": "invalid-sample";
            selection: "selection";
        }>;
        incident: z.ZodNullable<z.ZodObject<{
            kind: z.ZodEnum<{
                "failed-zero": "failed-zero";
                "invalid-sample": "invalid-sample";
            }>;
            seq: z.ZodNumber;
        }, z.core.$strict>>;
        compaction: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            startSeq: z.ZodNumber;
            endSeq: z.ZodNullable<z.ZodNumber>;
            state: z.ZodEnum<{
                running: "running";
                unknown: "unknown";
                failed: "failed";
                completed: "completed";
            }>;
            checkpoint: z.ZodBoolean;
            headerSeq: z.ZodNullable<z.ZodNumber>;
            requestRoute: z.ZodNullable<z.ZodObject<{
                provider: z.ZodString;
                model: z.ZodString;
            }, z.core.$strict>>;
            step: z.ZodNullable<z.ZodObject<{
                turn: z.ZodNumber;
                step: z.ZodNumber;
            }, z.core.$strict>>;
            request: z.ZodEnum<{
                unknown: "unknown";
                cancelled: "cancelled";
                failed: "failed";
                pending: "pending";
                idle: "idle";
                succeeded: "succeeded";
            }>;
        }, z.core.$strict>>>;
        activeStep: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            turn: z.ZodNumber;
            step: z.ZodNumber;
        }, z.core.$strict>>>;
    }, z.core.$strict>;
    init: typeof initialContextEvidence;
    apply: typeof foldContextEvidence;
    wire: {
        viewSchema: z.ZodObject<{
            route: z.ZodNullable<z.ZodObject<{
                provider: z.ZodString;
                model: z.ZodString;
            }, z.core.$strict>>;
            sample: z.ZodNullable<z.ZodObject<{
                tokens: z.ZodNumber;
                seq: z.ZodNumber;
                route: z.ZodObject<{
                    provider: z.ZodString;
                    model: z.ZodString;
                }, z.core.$strict>;
            }, z.core.$strict>>;
            invalid: z.ZodBoolean;
            reason: z.ZodEnum<{
                none: "none";
                compaction: "compaction";
                unknown: "unknown";
                "failed-zero": "failed-zero";
                "invalid-sample": "invalid-sample";
                selection: "selection";
            }>;
            incident: z.ZodNullable<z.ZodObject<{
                kind: z.ZodEnum<{
                    "failed-zero": "failed-zero";
                    "invalid-sample": "invalid-sample";
                }>;
                seq: z.ZodNumber;
            }, z.core.$strict>>;
            compaction: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                id: z.ZodString;
                startSeq: z.ZodNumber;
                endSeq: z.ZodNullable<z.ZodNumber>;
                state: z.ZodEnum<{
                    running: "running";
                    unknown: "unknown";
                    failed: "failed";
                    completed: "completed";
                }>;
                checkpoint: z.ZodBoolean;
                headerSeq: z.ZodNullable<z.ZodNumber>;
                requestRoute: z.ZodNullable<z.ZodObject<{
                    provider: z.ZodString;
                    model: z.ZodString;
                }, z.core.$strict>>;
                step: z.ZodNullable<z.ZodObject<{
                    turn: z.ZodNumber;
                    step: z.ZodNumber;
                }, z.core.$strict>>;
                request: z.ZodEnum<{
                    unknown: "unknown";
                    cancelled: "cancelled";
                    failed: "failed";
                    pending: "pending";
                    idle: "idle";
                    succeeded: "succeeded";
                }>;
            }, z.core.$strict>>>;
            activeStep: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                turn: z.ZodNumber;
                step: z.ZodNumber;
            }, z.core.$strict>>>;
        }, z.core.$strict>;
        view: (state: ContextEvidence) => {
            route: {
                provider: string;
                model: string;
            } | null;
            sample: {
                tokens: number;
                seq: number;
                route: {
                    provider: string;
                    model: string;
                };
            } | null;
            invalid: boolean;
            reason: "none" | "compaction" | "unknown" | "failed-zero" | "invalid-sample" | "selection";
            incident: {
                kind: "failed-zero" | "invalid-sample";
                seq: number;
            } | null;
            compaction?: {
                id: string;
                startSeq: number;
                endSeq: number | null;
                state: "running" | "unknown" | "failed" | "completed";
                checkpoint: boolean;
                headerSeq: number | null;
                requestRoute: {
                    provider: string;
                    model: string;
                } | null;
                step: {
                    turn: number;
                    step: number;
                } | null;
                request: "unknown" | "cancelled" | "failed" | "pending" | "idle" | "succeeded";
            } | null | undefined;
            activeStep?: {
                turn: number;
                step: number;
            } | null | undefined;
        };
    };
};
export declare function installContextEvidence(ctx: Context): void;
//# sourceMappingURL=context-evidence.d.ts.map