@azizbekdevuz/gitguard-schema 1.0.0

package/dist/api.d.ts

@@ -0,0 +1,2545 @@
+import { z } from 'zod';
+import { type VerificationResult } from './plan.js';
+export declare const CreateSessionRequestSchema: z.ZodObject<{
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        timestamp: z.ZodString;
+        platform: z.ZodEnum<["win32", "darwin", "linux"]>;
+        repoRoot: z.ZodString;
+        gitDir: z.ZodString;
+        branch: z.ZodObject<{
+            head: z.ZodString;
+            oid: z.ZodString;
+            upstream: z.ZodOptional<z.ZodString>;
+            aheadBehind: z.ZodOptional<z.ZodObject<{
+                ahead: z.ZodNumber;
+                behind: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                ahead: number;
+                behind: number;
+            }, {
+                ahead: number;
+                behind: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        }, {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        }>;
+        isDetachedHead: z.ZodBoolean;
+        rebaseState: z.ZodObject<{
+            inProgress: z.ZodBoolean;
+            type: z.ZodEnum<["merge", "apply", "none"]>;
+            headName: z.ZodOptional<z.ZodString>;
+            onto: z.ZodOptional<z.ZodString>;
+            currentStep: z.ZodOptional<z.ZodNumber>;
+            totalSteps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        }, {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        }>;
+        unmergedFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            stageOurs: z.ZodOptional<z.ZodString>;
+            stageTheirs: z.ZodOptional<z.ZodString>;
+            stageBase: z.ZodOptional<z.ZodString>;
+            conflictBlocks: z.ZodArray<z.ZodObject<{
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                oursContent: z.ZodString;
+                theirsContent: z.ZodString;
+                context: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }, {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }, {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }>, "many">;
+        stagedFiles: z.ZodArray<z.ZodString, "many">;
+        modifiedFiles: z.ZodArray<z.ZodString, "many">;
+        untrackedFiles: z.ZodArray<z.ZodString, "many">;
+        recentLog: z.ZodArray<z.ZodObject<{
+            hash: z.ZodString;
+            refs: z.ZodArray<z.ZodString, "many">;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            hash: string;
+            refs: string[];
+        }, {
+            message: string;
+            hash: string;
+            refs: string[];
+        }>, "many">;
+        recentReflog: z.ZodArray<z.ZodObject<{
+            hash: z.ZodString;
+            selector: z.ZodString;
+            action: z.ZodString;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }, {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }>, "many">;
+        commitGraph: z.ZodOptional<z.ZodString>;
+        diffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            additions: z.ZodNumber;
+            deletions: z.ZodNumber;
+            binary: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }, {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }>, "many">>;
+        mergeHead: z.ZodOptional<z.ZodString>;
+        mergeMessage: z.ZodOptional<z.ZodString>;
+        rawStatus: z.ZodString;
+        rawBranches: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    }, {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    snapshot: {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    };
+}, {
+    snapshot: {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    };
+}>;
+export type CreateSessionRequest = z.infer<typeof CreateSessionRequestSchema>;
+export declare const CreateSessionResponseSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sessionId: string;
+}, {
+    sessionId: string;
+}>;
+export type CreateSessionResponse = z.infer<typeof CreateSessionResponseSchema>;
+export declare const TraceOutputSchema: z.ZodObject<{
+    stage: z.ZodString;
+    output: z.ZodUnknown;
+    createdAt: z.ZodString;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number | null;
+    stage: string;
+    createdAt: string;
+    output?: unknown;
+}, {
+    durationMs: number | null;
+    stage: string;
+    createdAt: string;
+    output?: unknown;
+}>;
+export type TraceOutput = z.infer<typeof TraceOutputSchema>;
+export declare const SessionSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string | null;
+    createdAt: string;
+}, {
+    id: string;
+    title: string | null;
+    createdAt: string;
+}>;
+export type SessionSummary = z.infer<typeof SessionSummarySchema>;
+export declare const GetSessionResponseSchema: z.ZodObject<{
+    session: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string | null;
+        createdAt: string;
+    }, {
+        id: string;
+        title: string | null;
+        createdAt: string;
+    }>;
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        timestamp: z.ZodString;
+        platform: z.ZodEnum<["win32", "darwin", "linux"]>;
+        repoRoot: z.ZodString;
+        gitDir: z.ZodString;
+        branch: z.ZodObject<{
+            head: z.ZodString;
+            oid: z.ZodString;
+            upstream: z.ZodOptional<z.ZodString>;
+            aheadBehind: z.ZodOptional<z.ZodObject<{
+                ahead: z.ZodNumber;
+                behind: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                ahead: number;
+                behind: number;
+            }, {
+                ahead: number;
+                behind: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        }, {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        }>;
+        isDetachedHead: z.ZodBoolean;
+        rebaseState: z.ZodObject<{
+            inProgress: z.ZodBoolean;
+            type: z.ZodEnum<["merge", "apply", "none"]>;
+            headName: z.ZodOptional<z.ZodString>;
+            onto: z.ZodOptional<z.ZodString>;
+            currentStep: z.ZodOptional<z.ZodNumber>;
+            totalSteps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        }, {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        }>;
+        unmergedFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            stageOurs: z.ZodOptional<z.ZodString>;
+            stageTheirs: z.ZodOptional<z.ZodString>;
+            stageBase: z.ZodOptional<z.ZodString>;
+            conflictBlocks: z.ZodArray<z.ZodObject<{
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                oursContent: z.ZodString;
+                theirsContent: z.ZodString;
+                context: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }, {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }, {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }>, "many">;
+        stagedFiles: z.ZodArray<z.ZodString, "many">;
+        modifiedFiles: z.ZodArray<z.ZodString, "many">;
+        untrackedFiles: z.ZodArray<z.ZodString, "many">;
+        recentLog: z.ZodArray<z.ZodObject<{
+            hash: z.ZodString;
+            refs: z.ZodArray<z.ZodString, "many">;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            hash: string;
+            refs: string[];
+        }, {
+            message: string;
+            hash: string;
+            refs: string[];
+        }>, "many">;
+        recentReflog: z.ZodArray<z.ZodObject<{
+            hash: z.ZodString;
+            selector: z.ZodString;
+            action: z.ZodString;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }, {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }>, "many">;
+        commitGraph: z.ZodOptional<z.ZodString>;
+        diffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            additions: z.ZodNumber;
+            deletions: z.ZodNumber;
+            binary: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }, {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }>, "many">>;
+        mergeHead: z.ZodOptional<z.ZodString>;
+        mergeMessage: z.ZodOptional<z.ZodString>;
+        rawStatus: z.ZodString;
+        rawBranches: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    }, {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    }>;
+    signals: z.ZodNullable<z.ZodObject<{
+        hasConflicts: z.ZodBoolean;
+        conflictCount: z.ZodNumber;
+        conflictFiles: z.ZodArray<z.ZodString, "many">;
+        isDetachedHead: z.ZodBoolean;
+        detachedAt: z.ZodOptional<z.ZodString>;
+        isRebaseInProgress: z.ZodBoolean;
+        rebaseType: z.ZodEnum<["merge", "apply", "none"]>;
+        rebaseOnto: z.ZodOptional<z.ZodString>;
+        currentBranch: z.ZodString;
+        upstreamBranch: z.ZodOptional<z.ZodString>;
+        aheadCount: z.ZodNumber;
+        behindCount: z.ZodNumber;
+        hasStagedChanges: z.ZodBoolean;
+        hasUnstagedChanges: z.ZodBoolean;
+        hasUntrackedFiles: z.ZodBoolean;
+        recentCheckouts: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            reflogSelector: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            reflogSelector: string;
+        }, {
+            from: string;
+            to: string;
+            reflogSelector: string;
+        }>, "many">;
+        recentResets: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            target: z.ZodString;
+            reflogSelector: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            reflogSelector: string;
+            target: string;
+        }, {
+            type: string;
+            reflogSelector: string;
+            target: string;
+        }>, "many">;
+        primaryIssue: z.ZodEnum<["merge_conflict", "detached_head", "rebase_in_progress", "clean", "unknown"]>;
+        secondaryIssues: z.ZodArray<z.ZodEnum<["merge_conflict", "detached_head", "rebase_in_progress", "clean", "unknown"]>, "many">;
+        estimatedRisk: z.ZodEnum<["low", "medium", "high"]>;
+    }, "strip", z.ZodTypeAny, {
+        isDetachedHead: boolean;
+        hasConflicts: boolean;
+        conflictCount: number;
+        conflictFiles: string[];
+        isRebaseInProgress: boolean;
+        rebaseType: "merge" | "apply" | "none";
+        currentBranch: string;
+        aheadCount: number;
+        behindCount: number;
+        hasStagedChanges: boolean;
+        hasUnstagedChanges: boolean;
+        hasUntrackedFiles: boolean;
+        recentCheckouts: {
+            from: string;
+            to: string;
+            reflogSelector: string;
+        }[];
+        recentResets: {
+            type: string;
+            reflogSelector: string;
+            target: string;
+        }[];
+        primaryIssue: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        secondaryIssues: ("merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown")[];
+        estimatedRisk: "low" | "medium" | "high";
+        detachedAt?: string | undefined;
+        rebaseOnto?: string | undefined;
+        upstreamBranch?: string | undefined;
+    }, {
+        isDetachedHead: boolean;
+        hasConflicts: boolean;
+        conflictCount: number;
+        conflictFiles: string[];
+        isRebaseInProgress: boolean;
+        rebaseType: "merge" | "apply" | "none";
+        currentBranch: string;
+        aheadCount: number;
+        behindCount: number;
+        hasStagedChanges: boolean;
+        hasUnstagedChanges: boolean;
+        hasUntrackedFiles: boolean;
+        recentCheckouts: {
+            from: string;
+            to: string;
+            reflogSelector: string;
+        }[];
+        recentResets: {
+            type: string;
+            reflogSelector: string;
+            target: string;
+        }[];
+        primaryIssue: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        secondaryIssues: ("merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown")[];
+        estimatedRisk: "low" | "medium" | "high";
+        detachedAt?: string | undefined;
+        rebaseOnto?: string | undefined;
+        upstreamBranch?: string | undefined;
+    }>>;
+    plan: z.ZodNullable<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        timestamp: z.ZodString;
+        issueType: z.ZodEnum<["merge_conflict", "detached_head", "rebase_in_progress", "clean", "unknown"]>;
+        issueSummary: z.ZodString;
+        risk: z.ZodEnum<["low", "medium", "high"]>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            commands: z.ZodArray<z.ZodString, "many">;
+            expected: z.ZodString;
+            undo: z.ZodObject<{
+                possible: z.ZodBoolean;
+                commands: z.ZodArray<z.ZodString, "many">;
+                description: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            }, {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            }>;
+            dangerous: z.ZodBoolean;
+            warning: z.ZodOptional<z.ZodString>;
+            requiresUserInput: z.ZodDefault<z.ZodBoolean>;
+            userInputHint: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            requiresUserInput: boolean;
+            warning?: string | undefined;
+            userInputHint?: string | undefined;
+        }, {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            warning?: string | undefined;
+            requiresUserInput?: boolean | undefined;
+            userInputHint?: string | undefined;
+        }>, "many">;
+        saferAlternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            tradeoff: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodString;
+                commands: z.ZodArray<z.ZodString, "many">;
+                expected: z.ZodString;
+                undo: z.ZodObject<{
+                    possible: z.ZodBoolean;
+                    commands: z.ZodArray<z.ZodString, "many">;
+                    description: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                }, {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                }>;
+                dangerous: z.ZodBoolean;
+                warning: z.ZodOptional<z.ZodString>;
+                requiresUserInput: z.ZodDefault<z.ZodBoolean>;
+                userInputHint: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }, {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }, {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }>, "many">>;
+        reflogRecovery: z.ZodOptional<z.ZodObject<{
+            description: z.ZodString;
+            relevantEntries: z.ZodArray<z.ZodString, "many">;
+            recoveryCommand: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        }, {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            requiresUserInput: boolean;
+            warning?: string | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    }, {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            warning?: string | undefined;
+            requiresUserInput?: boolean | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    }>>;
+    traces: z.ZodArray<z.ZodObject<{
+        stage: z.ZodString;
+        output: z.ZodUnknown;
+        createdAt: z.ZodString;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number | null;
+        stage: string;
+        createdAt: string;
+        output?: unknown;
+    }, {
+        durationMs: number | null;
+        stage: string;
+        createdAt: string;
+        output?: unknown;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    plan: {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            requiresUserInput: boolean;
+            warning?: string | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    } | null;
+    snapshot: {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    };
+    session: {
+        id: string;
+        title: string | null;
+        createdAt: string;
+    };
+    signals: {
+        isDetachedHead: boolean;
+        hasConflicts: boolean;
+        conflictCount: number;
+        conflictFiles: string[];
+        isRebaseInProgress: boolean;
+        rebaseType: "merge" | "apply" | "none";
+        currentBranch: string;
+        aheadCount: number;
+        behindCount: number;
+        hasStagedChanges: boolean;
+        hasUnstagedChanges: boolean;
+        hasUntrackedFiles: boolean;
+        recentCheckouts: {
+            from: string;
+            to: string;
+            reflogSelector: string;
+        }[];
+        recentResets: {
+            type: string;
+            reflogSelector: string;
+            target: string;
+        }[];
+        primaryIssue: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        secondaryIssues: ("merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown")[];
+        estimatedRisk: "low" | "medium" | "high";
+        detachedAt?: string | undefined;
+        rebaseOnto?: string | undefined;
+        upstreamBranch?: string | undefined;
+    } | null;
+    traces: {
+        durationMs: number | null;
+        stage: string;
+        createdAt: string;
+        output?: unknown;
+    }[];
+}, {
+    plan: {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            warning?: string | undefined;
+            requiresUserInput?: boolean | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    } | null;
+    snapshot: {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    };
+    session: {
+        id: string;
+        title: string | null;
+        createdAt: string;
+    };
+    signals: {
+        isDetachedHead: boolean;
+        hasConflicts: boolean;
+        conflictCount: number;
+        conflictFiles: string[];
+        isRebaseInProgress: boolean;
+        rebaseType: "merge" | "apply" | "none";
+        currentBranch: string;
+        aheadCount: number;
+        behindCount: number;
+        hasStagedChanges: boolean;
+        hasUnstagedChanges: boolean;
+        hasUntrackedFiles: boolean;
+        recentCheckouts: {
+            from: string;
+            to: string;
+            reflogSelector: string;
+        }[];
+        recentResets: {
+            type: string;
+            reflogSelector: string;
+            target: string;
+        }[];
+        primaryIssue: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        secondaryIssues: ("merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown")[];
+        estimatedRisk: "low" | "medium" | "high";
+        detachedAt?: string | undefined;
+        rebaseOnto?: string | undefined;
+        upstreamBranch?: string | undefined;
+    } | null;
+    traces: {
+        durationMs: number | null;
+        stage: string;
+        createdAt: string;
+        output?: unknown;
+    }[];
+}>;
+export type GetSessionResponse = z.infer<typeof GetSessionResponseSchema>;
+export declare const GeneratePlanRequestSchema: z.ZodObject<{
+    dangerousAllowed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    dangerousAllowed: boolean;
+}, {
+    dangerousAllowed?: boolean | undefined;
+}>;
+export type GeneratePlanRequest = z.infer<typeof GeneratePlanRequestSchema>;
+export declare const GeneratePlanResponseSchema: z.ZodObject<{
+    plan: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        timestamp: z.ZodString;
+        issueType: z.ZodEnum<["merge_conflict", "detached_head", "rebase_in_progress", "clean", "unknown"]>;
+        issueSummary: z.ZodString;
+        risk: z.ZodEnum<["low", "medium", "high"]>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            commands: z.ZodArray<z.ZodString, "many">;
+            expected: z.ZodString;
+            undo: z.ZodObject<{
+                possible: z.ZodBoolean;
+                commands: z.ZodArray<z.ZodString, "many">;
+                description: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            }, {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            }>;
+            dangerous: z.ZodBoolean;
+            warning: z.ZodOptional<z.ZodString>;
+            requiresUserInput: z.ZodDefault<z.ZodBoolean>;
+            userInputHint: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            requiresUserInput: boolean;
+            warning?: string | undefined;
+            userInputHint?: string | undefined;
+        }, {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            warning?: string | undefined;
+            requiresUserInput?: boolean | undefined;
+            userInputHint?: string | undefined;
+        }>, "many">;
+        saferAlternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            tradeoff: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodString;
+                commands: z.ZodArray<z.ZodString, "many">;
+                expected: z.ZodString;
+                undo: z.ZodObject<{
+                    possible: z.ZodBoolean;
+                    commands: z.ZodArray<z.ZodString, "many">;
+                    description: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                }, {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                }>;
+                dangerous: z.ZodBoolean;
+                warning: z.ZodOptional<z.ZodString>;
+                requiresUserInput: z.ZodDefault<z.ZodBoolean>;
+                userInputHint: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }, {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }, {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }>, "many">>;
+        reflogRecovery: z.ZodOptional<z.ZodObject<{
+            description: z.ZodString;
+            relevantEntries: z.ZodArray<z.ZodString, "many">;
+            recoveryCommand: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        }, {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            requiresUserInput: boolean;
+            warning?: string | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    }, {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            warning?: string | undefined;
+            requiresUserInput?: boolean | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    plan: {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            requiresUserInput: boolean;
+            warning?: string | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                requiresUserInput: boolean;
+                warning?: string | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    };
+}, {
+    plan: {
+        issueType: "merge_conflict" | "detached_head" | "rebase_in_progress" | "clean" | "unknown";
+        version: 1;
+        timestamp: string;
+        issueSummary: string;
+        risk: "low" | "medium" | "high";
+        steps: {
+            dangerous: boolean;
+            id: string;
+            expected: string;
+            title: string;
+            commands: string[];
+            undo: {
+                commands: string[];
+                description: string;
+                possible: boolean;
+            };
+            description: string;
+            warning?: string | undefined;
+            requiresUserInput?: boolean | undefined;
+            userInputHint?: string | undefined;
+        }[];
+        saferAlternatives?: {
+            description: string;
+            steps: {
+                dangerous: boolean;
+                id: string;
+                expected: string;
+                title: string;
+                commands: string[];
+                undo: {
+                    commands: string[];
+                    description: string;
+                    possible: boolean;
+                };
+                description: string;
+                warning?: string | undefined;
+                requiresUserInput?: boolean | undefined;
+                userInputHint?: string | undefined;
+            }[];
+            tradeoff: string;
+        }[] | undefined;
+        reflogRecovery?: {
+            description: string;
+            relevantEntries: string[];
+            recoveryCommand: string;
+        } | undefined;
+    };
+}>;
+export type GeneratePlanResponse = z.infer<typeof GeneratePlanResponseSchema>;
+export declare const VerifyProgressRequestSchema: z.ZodObject<{
+    snapshot: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        timestamp: z.ZodString;
+        platform: z.ZodEnum<["win32", "darwin", "linux"]>;
+        repoRoot: z.ZodString;
+        gitDir: z.ZodString;
+        branch: z.ZodObject<{
+            head: z.ZodString;
+            oid: z.ZodString;
+            upstream: z.ZodOptional<z.ZodString>;
+            aheadBehind: z.ZodOptional<z.ZodObject<{
+                ahead: z.ZodNumber;
+                behind: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                ahead: number;
+                behind: number;
+            }, {
+                ahead: number;
+                behind: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        }, {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        }>;
+        isDetachedHead: z.ZodBoolean;
+        rebaseState: z.ZodObject<{
+            inProgress: z.ZodBoolean;
+            type: z.ZodEnum<["merge", "apply", "none"]>;
+            headName: z.ZodOptional<z.ZodString>;
+            onto: z.ZodOptional<z.ZodString>;
+            currentStep: z.ZodOptional<z.ZodNumber>;
+            totalSteps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        }, {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        }>;
+        unmergedFiles: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            stageOurs: z.ZodOptional<z.ZodString>;
+            stageTheirs: z.ZodOptional<z.ZodString>;
+            stageBase: z.ZodOptional<z.ZodString>;
+            conflictBlocks: z.ZodArray<z.ZodObject<{
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                oursContent: z.ZodString;
+                theirsContent: z.ZodString;
+                context: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }, {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }, {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }>, "many">;
+        stagedFiles: z.ZodArray<z.ZodString, "many">;
+        modifiedFiles: z.ZodArray<z.ZodString, "many">;
+        untrackedFiles: z.ZodArray<z.ZodString, "many">;
+        recentLog: z.ZodArray<z.ZodObject<{
+            hash: z.ZodString;
+            refs: z.ZodArray<z.ZodString, "many">;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            hash: string;
+            refs: string[];
+        }, {
+            message: string;
+            hash: string;
+            refs: string[];
+        }>, "many">;
+        recentReflog: z.ZodArray<z.ZodObject<{
+            hash: z.ZodString;
+            selector: z.ZodString;
+            action: z.ZodString;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }, {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }>, "many">;
+        commitGraph: z.ZodOptional<z.ZodString>;
+        diffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            additions: z.ZodNumber;
+            deletions: z.ZodNumber;
+            binary: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }, {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }>, "many">>;
+        mergeHead: z.ZodOptional<z.ZodString>;
+        mergeMessage: z.ZodOptional<z.ZodString>;
+        rawStatus: z.ZodString;
+        rawBranches: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    }, {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    snapshot: {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    };
+}, {
+    snapshot: {
+        branch: {
+            head: string;
+            oid: string;
+            upstream?: string | undefined;
+            aheadBehind?: {
+                ahead: number;
+                behind: number;
+            } | undefined;
+        };
+        version: 1;
+        timestamp: string;
+        platform: "win32" | "darwin" | "linux";
+        repoRoot: string;
+        gitDir: string;
+        isDetachedHead: boolean;
+        rebaseState: {
+            type: "merge" | "apply" | "none";
+            inProgress: boolean;
+            headName?: string | undefined;
+            onto?: string | undefined;
+            currentStep?: number | undefined;
+            totalSteps?: number | undefined;
+        };
+        unmergedFiles: {
+            path: string;
+            conflictBlocks: {
+                startLine: number;
+                endLine: number;
+                oursContent: string;
+                theirsContent: string;
+                context: string;
+            }[];
+            stageOurs?: string | undefined;
+            stageTheirs?: string | undefined;
+            stageBase?: string | undefined;
+        }[];
+        stagedFiles: string[];
+        modifiedFiles: string[];
+        untrackedFiles: string[];
+        recentLog: {
+            message: string;
+            hash: string;
+            refs: string[];
+        }[];
+        recentReflog: {
+            message: string;
+            hash: string;
+            selector: string;
+            action: string;
+        }[];
+        rawStatus: string;
+        rawBranches: string;
+        commitGraph?: string | undefined;
+        diffStats?: {
+            path: string;
+            additions: number;
+            deletions: number;
+            binary?: boolean | undefined;
+        }[] | undefined;
+        mergeHead?: string | undefined;
+        mergeMessage?: string | undefined;
+    };
+}>;
+export type VerifyProgressRequest = z.infer<typeof VerifyProgressRequestSchema>;
+export declare const VerifyProgressResponseSchema: z.ZodObject<{
+    stepsCompleted: z.ZodArray<z.ZodString, "many">;
+    issueResolved: z.ZodBoolean;
+    remainingIssues: z.ZodArray<z.ZodString, "many">;
+    nextStepId: z.ZodOptional<z.ZodString>;
+    guidance: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    stepsCompleted: string[];
+    issueResolved: boolean;
+    remainingIssues: string[];
+    guidance: string;
+    nextStepId?: string | undefined;
+}, {
+    stepsCompleted: string[];
+    issueResolved: boolean;
+    remainingIssues: string[];
+    guidance: string;
+    nextStepId?: string | undefined;
+}>;
+export type VerifyProgressResponse = VerificationResult;
+export declare const ExplainConflictRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"conflict">;
+    fileIndex: z.ZodNumber;
+    blockIndex: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "conflict";
+    fileIndex: number;
+    blockIndex: number;
+}, {
+    type: "conflict";
+    fileIndex: number;
+    blockIndex: number;
+}>;
+export declare const ExplainStateRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"state">;
+}, "strip", z.ZodTypeAny, {
+    type: "state";
+}, {
+    type: "state";
+}>;
+export declare const ExplainRequestSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"conflict">;
+    fileIndex: z.ZodNumber;
+    blockIndex: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "conflict";
+    fileIndex: number;
+    blockIndex: number;
+}, {
+    type: "conflict";
+    fileIndex: number;
+    blockIndex: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"state">;
+}, "strip", z.ZodTypeAny, {
+    type: "state";
+}, {
+    type: "state";
+}>]>;
+export type ExplainRequest = z.infer<typeof ExplainRequestSchema>;
+export declare const ConflictExplanationSchema: z.ZodObject<{
+    summary: z.ZodString;
+    oursInterpretation: z.ZodString;
+    theirsInterpretation: z.ZodString;
+    suggestedResolution: z.ZodString;
+    riskNotes: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    oursInterpretation: string;
+    theirsInterpretation: string;
+    suggestedResolution: string;
+    riskNotes?: string | undefined;
+}, {
+    summary: string;
+    oursInterpretation: string;
+    theirsInterpretation: string;
+    suggestedResolution: string;
+    riskNotes?: string | undefined;
+}>;
+export type ConflictExplanation = z.infer<typeof ConflictExplanationSchema>;
+export declare const StateExplanationSchema: z.ZodObject<{
+    summary: z.ZodString;
+    howItHappened: z.ZodString;
+    currentPosition: z.ZodString;
+    safeNextSteps: z.ZodArray<z.ZodString, "many">;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    howItHappened: string;
+    currentPosition: string;
+    safeNextSteps: string[];
+    warnings?: string[] | undefined;
+}, {
+    summary: string;
+    howItHappened: string;
+    currentPosition: string;
+    safeNextSteps: string[];
+    warnings?: string[] | undefined;
+}>;
+export type StateExplanation = z.infer<typeof StateExplanationSchema>;
+export declare const ExplainResponseSchema: z.ZodObject<{
+    explanation: z.ZodUnion<[z.ZodObject<{
+        summary: z.ZodString;
+        oursInterpretation: z.ZodString;
+        theirsInterpretation: z.ZodString;
+        suggestedResolution: z.ZodString;
+        riskNotes: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        summary: string;
+        oursInterpretation: string;
+        theirsInterpretation: string;
+        suggestedResolution: string;
+        riskNotes?: string | undefined;
+    }, {
+        summary: string;
+        oursInterpretation: string;
+        theirsInterpretation: string;
+        suggestedResolution: string;
+        riskNotes?: string | undefined;
+    }>, z.ZodObject<{
+        summary: z.ZodString;
+        howItHappened: z.ZodString;
+        currentPosition: z.ZodString;
+        safeNextSteps: z.ZodArray<z.ZodString, "many">;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        summary: string;
+        howItHappened: string;
+        currentPosition: string;
+        safeNextSteps: string[];
+        warnings?: string[] | undefined;
+    }, {
+        summary: string;
+        howItHappened: string;
+        currentPosition: string;
+        safeNextSteps: string[];
+        warnings?: string[] | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    explanation: {
+        summary: string;
+        oursInterpretation: string;
+        theirsInterpretation: string;
+        suggestedResolution: string;
+        riskNotes?: string | undefined;
+    } | {
+        summary: string;
+        howItHappened: string;
+        currentPosition: string;
+        safeNextSteps: string[];
+        warnings?: string[] | undefined;
+    };
+}, {
+    explanation: {
+        summary: string;
+        oursInterpretation: string;
+        theirsInterpretation: string;
+        suggestedResolution: string;
+        riskNotes?: string | undefined;
+    } | {
+        summary: string;
+        howItHappened: string;
+        currentPosition: string;
+        safeNextSteps: string[];
+        warnings?: string[] | undefined;
+    };
+}>;
+export type ExplainResponse = z.infer<typeof ExplainResponseSchema>;
+export declare const RegisterRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    name?: string | undefined;
+}, {
+    email: string;
+    password: string;
+    name?: string | undefined;
+}>;
+export type RegisterRequest = z.infer<typeof RegisterRequestSchema>;
+export declare const RegisterResponseSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        email: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string | null;
+        email: string;
+    }, {
+        id: string;
+        name: string | null;
+        email: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    user: {
+        id: string;
+        name: string | null;
+        email: string;
+    };
+}, {
+    user: {
+        id: string;
+        name: string | null;
+        email: string;
+    };
+}>;
+export type RegisterResponse = z.infer<typeof RegisterResponseSchema>;
+export declare const ApiErrorSchema: z.ZodObject<{
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+}, {
+    error: string;
+}>;
+export type ApiError = z.infer<typeof ApiErrorSchema>;
+export declare const SessionListItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    os: z.ZodNullable<z.ZodString>;
+    hasPlan: z.ZodBoolean;
+    issueType: z.ZodNullable<z.ZodString>;
+    risk: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string | null;
+    issueType: string | null;
+    risk: string | null;
+    createdAt: string;
+    os: string | null;
+    hasPlan: boolean;
+}, {
+    id: string;
+    title: string | null;
+    issueType: string | null;
+    risk: string | null;
+    createdAt: string;
+    os: string | null;
+    hasPlan: boolean;
+}>;
+export type SessionListItem = z.infer<typeof SessionListItemSchema>;
+export declare const SessionListResponseSchema: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        os: z.ZodNullable<z.ZodString>;
+        hasPlan: z.ZodBoolean;
+        issueType: z.ZodNullable<z.ZodString>;
+        risk: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string | null;
+        issueType: string | null;
+        risk: string | null;
+        createdAt: string;
+        os: string | null;
+        hasPlan: boolean;
+    }, {
+        id: string;
+        title: string | null;
+        issueType: string | null;
+        risk: string | null;
+        createdAt: string;
+        os: string | null;
+        hasPlan: boolean;
+    }>, "many">;
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    sessions: {
+        id: string;
+        title: string | null;
+        issueType: string | null;
+        risk: string | null;
+        createdAt: string;
+        os: string | null;
+        hasPlan: boolean;
+    }[];
+    total: number;
+    page: number;
+    pageSize: number;
+}, {
+    sessions: {
+        id: string;
+        title: string | null;
+        issueType: string | null;
+        risk: string | null;
+        createdAt: string;
+        os: string | null;
+        hasPlan: boolean;
+    }[];
+    total: number;
+    page: number;
+    pageSize: number;
+}>;
+export type SessionListResponse = z.infer<typeof SessionListResponseSchema>;
+//# sourceMappingURL=api.d.ts.map