@otto-code/protocol 0.8.10 → 0.8.12

package/dist/code-intelligence.d.ts

@@ -0,0 +1,917 @@
+import { z } from "zod";
+/**
+ * Otto code-intelligence wire schemas: the code.* symbol, definition, hover,
+ * references, rename and solution RPCs, plus the lsp.* server-state RPCs and
+ * pushes (see docs/code-intelligence.md).
+ *
+ * Declaration order matters here: the Solution schemas first because the Code
+ * responses embed them, then Code, then Lsp, which embeds CodeDiagnosticSchema. These are top-level consts, so a
+ * schema referenced before its declaration is a ReferenceError at module
+ * evaluation (and in the zod-aot build), not a type error.
+ *
+ * Code intelligence is a fork-only capability, so its schemas live in their own
+ * protocol module rather than inside messages.ts. messages.ts re-exports them.
+ */
+/**
+ * Solution view responses (projects/solution-view).
+ *
+ * COMPAT(solutionView): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+ */
+export declare const SolutionFormatSchema: z.ZodEnum<{
+    sln: "sln";
+    slnx: "slnx";
+}>;
+/** One solution a workspace contains. Enough to populate the switcher's picker, nothing more. */
+export declare const SolutionRefSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    format: z.ZodEnum<{
+        sln: "sln";
+        slnx: "slnx";
+    }>;
+}, z.core.$strip>;
+/**
+ * Solution structure is flat on the wire with parent links, not nested.
+ *
+ * A recursive payload would have to be walked to be used, and every consumer would write that
+ * walk again; the file explorer already turns a flat listing plus an expanded-path set into rows,
+ * so this hands it the same shape it already consumes.
+ */
+export declare const SolutionTreeFolderSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    parentPath: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const SolutionTreeProjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    path: z.ZodString;
+    outsideWorkspace: z.ZodBoolean;
+    folderPath: z.ZodNullable<z.ZodString>;
+    typeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Three-valued for the same reason the code-intelligence family is: "the host cannot supply
+ * this", "MSBuild refused this project", and "here are its files" are different things to tell a
+ * user, and reporting the first two as an empty file list is how a working feature reads as
+ * broken. One project that fails must not blank the tree, so this status is per project.
+ */
+export declare const SolutionProjectStatusSchema: z.ZodEnum<{
+    ok: "ok";
+    unavailable: "unavailable";
+    failed: "failed";
+}>;
+/**
+ * One entry in a project's evaluated membership, flat with parent links like the folders above.
+ *
+ * `isImplicit` is what a filesystem tree structurally cannot show and what Phase 2 turns on: an
+ * item contributed by the SDK's default globs is one that creating the file already adds, while
+ * an item the project file itself declares needs a real `.csproj` edit.
+ */
+export declare const SolutionProjectNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"directory">;
+    id: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    path: z.ZodString;
+    outsideWorkspace: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    id: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    path: z.ZodString;
+    outsideWorkspace: z.ZodBoolean;
+    itemType: z.ZodString;
+    isImplicit: z.ZodBoolean;
+}, z.core.$strip>], "kind">;
+export declare const SolutionPackageReferenceSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SolutionFormat = z.infer<typeof SolutionFormatSchema>;
+export type SolutionRef = z.infer<typeof SolutionRefSchema>;
+export type SolutionTreeFolder = z.infer<typeof SolutionTreeFolderSchema>;
+export type SolutionTreeProject = z.infer<typeof SolutionTreeProjectSchema>;
+export type SolutionProjectStatus = z.infer<typeof SolutionProjectStatusSchema>;
+export type SolutionProjectNode = z.infer<typeof SolutionProjectNodeSchema>;
+export type SolutionPackageReference = z.infer<typeof SolutionPackageReferenceSchema>;
+export declare const CodeListFilesRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.list_files.request">;
+    cwd: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const CodeSymbolsRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.symbols.request">;
+    cwd: z.ZodString;
+    name: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const CodeOutlineRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.outline.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * LSP-backed code intelligence (projects/lsp-code-intelligence). Distinct from the
+ * ctags `code.symbols` RPC above in the only way that matters: it carries a
+ * **position**, so the daemon can resolve the reference under the cursor instead of
+ * matching a name.
+ *
+ * Line and column are **1-based** here, matching `CodeSymbolLocation` and the rest of
+ * Otto. LSP itself is 0-based; that conversion is the daemon's business and does not
+ * reach the wire.
+ */
+export declare const CodeDefinitionRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.definition.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The editor's current buffer text, so definitions resolve against unsaved edits
+ * rather than stale disk content. Sent debounced, not per keystroke.
+ */
+export declare const CodeDocumentSyncRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.document.sync.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    text: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const CodeDocumentCloseRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.document.close.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The rest of the position-based code-intelligence family. All three carry a 1-based
+ * position like `code.definition`, and all three are answered against the mirrored
+ * buffer rather than the file on disk.
+ */
+export declare const CodeHoverRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.hover.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const CodeReferencesRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.references.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A rename **dry run**. Deliberately not "do the rename": the daemon computes every edit
+ * and returns them for the user to audit, because a rename's blast radius is the whole
+ * project. Nothing is written by this request.
+ */
+export declare const CodeRenamePreviewRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.rename.preview.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    newName: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Execute a rename the user has audited. **The edits are deliberately NOT on this request.**
+ *
+ * The client sends back only the `planId` it was shown; the daemon recomputes the plan and
+ * refuses unless the identity matches. A request that carried its own edit list would be a
+ * remote arbitrary-write primitive wearing a rename's name - any client could post any text
+ * at any path. This shape makes the daemon's own language server the sole author of what
+ * gets written, and the plan id the proof that the user saw it.
+ */
+export declare const CodeRenameApplyRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.rename.apply.request">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    newName: z.ZodString;
+    planId: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Undo a run. Carries only the run's id - the daemon holds the before-images.
+ *
+ * Declared here, with the other inbound rename schemas, rather than beside its response
+ * further down: `SessionInboundMessageSchema` is a top-level const, so a schema it names
+ * must already be initialized when that line runs. Below the union it is a
+ * ReferenceError at import time, not a type error.
+ */
+export declare const CodeRenameUndoRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.rename.undo.request">;
+    cwd: z.ZodString;
+    runId: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The Solution view (projects/solution-view). A second lens on the Files module showing the tree
+ * as the build system sees it rather than as the filesystem lays it out.
+ *
+ * **Independent of the LSP family above, despite sharing the `code.` domain.** There is no
+ * project-structure request in the Language Server Protocol - not one Otto has yet to wire, one
+ * that does not exist - so this subsystem builds its own model through Microsoft's solution
+ * libraries. Turning C# code intelligence off does not turn this off, and vice versa.
+ *
+ * Discovery is separate from loading on purpose: `list` decides whether the switcher appears at
+ * all, so it runs for every workspace and must stay cheap (a directory walk, no process). Only
+ * `get_tree` reaches the .NET sidecar.
+ *
+ * COMPAT(solutionView): added in v0.6.8; gate lives in features.solutionView.
+ */
+export declare const CodeSolutionListRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.solution.list.request">;
+    cwd: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * One solution's organisation: folders, the projects inside them, and the configurations. No file
+ * membership - that is `load_project`, paid per project on expand, because evaluating fifty
+ * projects to render a collapsed tree is the cost this design exists to avoid.
+ */
+export declare const CodeSolutionGetTreeRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.solution.get_tree.request">;
+    cwd: z.ZodString;
+    solutionPath: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * One project's evaluated file membership. `solutionPath` scopes the sidecar instance so two
+ * solutions in one repo never share a warm `ProjectCollection` - and so Phase 4 has the selection
+ * it needs for `--solution`.
+ */
+export declare const CodeSolutionLoadProjectRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.solution.load_project.request">;
+    cwd: z.ZodString;
+    solutionPath: z.ZodString;
+    projectPath: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Compiler severity, named rather than numbered. LSP uses 1–4; a magic number on the
+ * wire would have every consumer re-deriving which one is a warning.
+ */
+export declare const CodeDiagnosticSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+    hint: "hint";
+}>;
+/** One problem the language server reported, 1-based like every other position. */
+export declare const CodeDiagnosticSchema: z.ZodObject<{
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    endLine: z.ZodNumber;
+    endColumn: z.ZodNumber;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+        hint: "hint";
+    }>;
+    message: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    codeHref: z.ZodOptional<z.ZodString>;
+    serverId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CodeListFilesResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.list_files.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        truncated: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeSymbolKindSchema: z.ZodEnum<{
+    function: "function";
+    type: "type";
+    class: "class";
+    variable: "variable";
+    property: "property";
+}>;
+export declare const CodeSymbolLocationSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        function: "function";
+        type: "type";
+        class: "class";
+        variable: "variable";
+        property: "property";
+    }>;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CodeSymbolsResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.symbols.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        name: z.ZodString;
+        locations: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                function: "function";
+                type: "type";
+                class: "class";
+                variable: "variable";
+                property: "property";
+            }>;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** 1-based, like `CodeSymbolLocation`. The end pair is present when the server gave a range. */
+export declare const CodeDefinitionLocationSchema: z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    endColumn: z.ZodOptional<z.ZodNumber>;
+    serverId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Three-valued on purpose. `unavailable` (no server for this language on the host) and
+ * `indexing` (the server is up but still building its project model) are different
+ * answers to the user, and neither is "not found" - reporting either as an empty
+ * result is how a working feature reads as broken.
+ */
+export declare const CodeDefinitionStatusSchema: z.ZodEnum<{
+    ok: "ok";
+    unavailable: "unavailable";
+    indexing: "indexing";
+}>;
+export declare const CodeDefinitionResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.definition.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            unavailable: "unavailable";
+            indexing: "indexing";
+        }>;
+        locations: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+            serverId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeDocumentSyncResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.document.sync.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        ok: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeDocumentCloseResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.document.close.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        ok: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** 1-based, like every other position on the wire. */
+export declare const CodeHoverRangeSchema: z.ZodObject<{
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    endLine: z.ZodNumber;
+    endColumn: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CodeHoverResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.hover.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            unavailable: "unavailable";
+            indexing: "indexing";
+        }>;
+        markdown: z.ZodNullable<z.ZodString>;
+        range: z.ZodNullable<z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+            endLine: z.ZodNumber;
+            endColumn: z.ZodNumber;
+        }, z.core.$strip>>;
+        serverId: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeReferencesResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.references.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            unavailable: "unavailable";
+            indexing: "indexing";
+        }>;
+        locations: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+            serverId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeRenameEditSchema: z.ZodObject<{
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    endLine: z.ZodNumber;
+    endColumn: z.ZodNumber;
+    newText: z.ZodString;
+    oldText: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const CodeRenameFilePlanSchema: z.ZodObject<{
+    path: z.ZodString;
+    edits: z.ZodArray<z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+        endLine: z.ZodNumber;
+        endColumn: z.ZodNumber;
+        newText: z.ZodString;
+        oldText: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CodeRenamePreviewResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.rename.preview.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        newName: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            unavailable: "unavailable";
+            indexing: "indexing";
+        }>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            edits: z.ZodArray<z.ZodObject<{
+                line: z.ZodNumber;
+                column: z.ZodNumber;
+                endLine: z.ZodNumber;
+                endColumn: z.ZodNumber;
+                newText: z.ZodString;
+                oldText: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        fileCount: z.ZodNumber;
+        editCount: z.ZodNumber;
+        planId: z.ZodDefault<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Five-valued, because the ways a rename can fail to happen are things a user needs told
+ * apart: still loading, no server, the plan moved, or the server pointed outside the
+ * workspace. Collapsing them into one failure is how "nothing happened" becomes unexplainable.
+ */
+/**
+ * Whether the run HAPPENED - deliberately not whether everything applied.
+ *
+ * A run where two of fourteen edits no longer fit is still a run that took place, and the
+ * twelve that landed are real. Collapsing that into a failure would hide them, and hiding a
+ * write is the one thing an auditable edit surface must never do. Per-edit fate lives in the
+ * file outcomes; `complete` is the single-glance answer.
+ */
+export declare const CodeRenameApplyStatusSchema: z.ZodEnum<{
+    ok: "ok";
+    expired: "expired";
+    escaped: "escaped";
+}>;
+export declare const CodeRenameFileOutcomeKindSchema: z.ZodEnum<{
+    failed: "failed";
+    partial: "partial";
+    applied: "applied";
+}>;
+/** What happened to one file in a run. */
+export declare const CodeRenameFileOutcomeSchema: z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        failed: "failed";
+        partial: "partial";
+        applied: "applied";
+    }>;
+    appliedEdits: z.ZodNumber;
+    skippedEdits: z.ZodNumber;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const CodeRenameUndoStatusSchema: z.ZodEnum<{
+    ok: "ok";
+    expired: "expired";
+}>;
+export declare const CodeRenameUndoFileKindSchema: z.ZodEnum<{
+    failed: "failed";
+    restored: "restored";
+    changedSince: "changedSince";
+}>;
+/**
+ * What happened to one file during an undo. `changedSince` is the important one: the file was
+ * edited after the run, so restoring would have destroyed that work and it was left alone.
+ */
+export declare const CodeRenameUndoFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        failed: "failed";
+        restored: "restored";
+        changedSince: "changedSince";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const CodeRenameUndoResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.rename.undo.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        runId: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            expired: "expired";
+        }>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                failed: "failed";
+                restored: "restored";
+                changedSince: "changedSince";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        restoredFiles: z.ZodNumber;
+        complete: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeRenameApplyResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.rename.apply.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        newName: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            expired: "expired";
+            escaped: "escaped";
+        }>;
+        runId: z.ZodNullable<z.ZodString>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                failed: "failed";
+                partial: "partial";
+                applied: "applied";
+            }>;
+            appliedEdits: z.ZodNumber;
+            skippedEdits: z.ZodNumber;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        appliedFiles: z.ZodNumber;
+        appliedEdits: z.ZodNumber;
+        skippedEdits: z.ZodNumber;
+        complete: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeSolutionListResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.solution.list.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        solutions: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodString;
+            format: z.ZodEnum<{
+                sln: "sln";
+                slnx: "slnx";
+            }>;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeSolutionGetTreeResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.solution.get_tree.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        solutionPath: z.ZodString;
+        name: z.ZodDefault<z.ZodString>;
+        format: z.ZodDefault<z.ZodEnum<{
+            sln: "sln";
+            slnx: "slnx";
+        }>>;
+        folders: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodString;
+            parentPath: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        projects: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            path: z.ZodString;
+            outsideWorkspace: z.ZodBoolean;
+            folderPath: z.ZodNullable<z.ZodString>;
+            typeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        buildTypes: z.ZodArray<z.ZodString>;
+        platforms: z.ZodArray<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeSolutionLoadProjectResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.solution.load_project.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        solutionPath: z.ZodString;
+        projectPath: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            unavailable: "unavailable";
+            failed: "failed";
+        }>;
+        nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"directory">;
+            id: z.ZodString;
+            parentId: z.ZodNullable<z.ZodString>;
+            name: z.ZodString;
+            path: z.ZodString;
+            outsideWorkspace: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            id: z.ZodString;
+            parentId: z.ZodNullable<z.ZodString>;
+            name: z.ZodString;
+            path: z.ZodString;
+            outsideWorkspace: z.ZodBoolean;
+            itemType: z.ZodString;
+            isImplicit: z.ZodBoolean;
+        }, z.core.$strip>], "kind">>;
+        projectReferences: z.ZodArray<z.ZodString>;
+        packageReferences: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        targetFrameworks: z.ZodArray<z.ZodString>;
+        outputType: z.ZodNullable<z.ZodString>;
+        isSdkStyle: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CodeOutlineResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"code.outline.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        path: z.ZodString;
+        symbols: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                function: "function";
+                type: "type";
+                class: "class";
+                variable: "variable";
+                property: "property";
+            }>;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CodeListFilesRequest = z.infer<typeof CodeListFilesRequestSchema>;
+export type CodeListFilesResponse = z.infer<typeof CodeListFilesResponseSchema>;
+export type CodeSymbolsRequest = z.infer<typeof CodeSymbolsRequestSchema>;
+export type CodeSymbolsResponse = z.infer<typeof CodeSymbolsResponseSchema>;
+export type CodeOutlineRequest = z.infer<typeof CodeOutlineRequestSchema>;
+export type CodeOutlineResponse = z.infer<typeof CodeOutlineResponseSchema>;
+export type CodeSymbolLocation = z.infer<typeof CodeSymbolLocationSchema>;
+export type CodeSymbolKind = z.infer<typeof CodeSymbolKindSchema>;
+export type CodeDefinitionRequest = z.infer<typeof CodeDefinitionRequestSchema>;
+export type CodeDefinitionResponse = z.infer<typeof CodeDefinitionResponseSchema>;
+export type CodeDefinitionLocation = z.infer<typeof CodeDefinitionLocationSchema>;
+export type CodeDefinitionStatus = z.infer<typeof CodeDefinitionStatusSchema>;
+export type CodeDocumentSyncRequest = z.infer<typeof CodeDocumentSyncRequestSchema>;
+export type CodeDocumentSyncResponse = z.infer<typeof CodeDocumentSyncResponseSchema>;
+export type CodeDocumentCloseRequest = z.infer<typeof CodeDocumentCloseRequestSchema>;
+export type CodeDocumentCloseResponse = z.infer<typeof CodeDocumentCloseResponseSchema>;
+export type CodeHoverRequest = z.infer<typeof CodeHoverRequestSchema>;
+export type CodeHoverResponse = z.infer<typeof CodeHoverResponseSchema>;
+export type CodeHoverRange = z.infer<typeof CodeHoverRangeSchema>;
+export type CodeReferencesRequest = z.infer<typeof CodeReferencesRequestSchema>;
+export type CodeReferencesResponse = z.infer<typeof CodeReferencesResponseSchema>;
+export type CodeRenamePreviewRequest = z.infer<typeof CodeRenamePreviewRequestSchema>;
+export type CodeRenamePreviewResponse = z.infer<typeof CodeRenamePreviewResponseSchema>;
+export type CodeRenameApplyRequest = z.infer<typeof CodeRenameApplyRequestSchema>;
+export type CodeRenameApplyResponse = z.infer<typeof CodeRenameApplyResponseSchema>;
+export type CodeRenameApplyStatus = z.infer<typeof CodeRenameApplyStatusSchema>;
+export type CodeRenameFileOutcome = z.infer<typeof CodeRenameFileOutcomeSchema>;
+export type CodeRenameUndoRequest = z.infer<typeof CodeRenameUndoRequestSchema>;
+export type CodeRenameUndoResponse = z.infer<typeof CodeRenameUndoResponseSchema>;
+export type CodeRenameUndoStatus = z.infer<typeof CodeRenameUndoStatusSchema>;
+export type CodeRenameUndoFile = z.infer<typeof CodeRenameUndoFileSchema>;
+export type CodeRenameEdit = z.infer<typeof CodeRenameEditSchema>;
+export type CodeRenameFilePlan = z.infer<typeof CodeRenameFilePlanSchema>;
+export type CodeSolutionListRequest = z.infer<typeof CodeSolutionListRequestSchema>;
+export type CodeSolutionListResponse = z.infer<typeof CodeSolutionListResponseSchema>;
+export type CodeSolutionGetTreeRequest = z.infer<typeof CodeSolutionGetTreeRequestSchema>;
+export type CodeSolutionGetTreeResponse = z.infer<typeof CodeSolutionGetTreeResponseSchema>;
+export type CodeSolutionLoadProjectRequest = z.infer<typeof CodeSolutionLoadProjectRequestSchema>;
+export type CodeSolutionLoadProjectResponse = z.infer<typeof CodeSolutionLoadProjectResponseSchema>;
+export type CodeDiagnosticSeverity = z.infer<typeof CodeDiagnosticSeveritySchema>;
+export type CodeDiagnostic = z.infer<typeof CodeDiagnosticSchema>;
+/**
+ * Live language-server state for the Daemon → Code screen. Separate from the daemon
+ * config RPCs because none of it is configuration: which servers this machine can
+ * actually supply, and which are running right now.
+ *
+ * Omit `cwd` for the host-wide answer, which is what the settings screen asks for: every
+ * row this daemon knows, resolved against the rungs a host has (bundled, PATH). Passing a
+ * `cwd` additionally probes that workspace's `node_modules/.bin`, since a server can be
+ * present in one project and absent from another. Optional rather than removed because
+ * older clients still send it.
+ *
+ * COMPAT(lspHostServers): `cwd` became optional in v0.7.3; gate lives in
+ * features.lspHostServers.
+ */
+export declare const LspServersListRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"lsp.servers.list.request">;
+    cwd: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/** Stop one running server, so a user who suspects it of hogging memory can kill it. */
+export declare const LspServerStopRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"lsp.server.stop.request">;
+    rootPath: z.ZodString;
+    serverId: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Which workspaces currently have a language server starting up or indexing. Sent as
+ * the whole busy set rather than per-workspace transitions: the only consumer is a
+ * spinner, so an idempotent snapshot cannot drift out of sync the way a missed
+ * transition would.
+ *
+ * Separate from the workspace status bucket on purpose - indexing is not the workspace
+ * "working", and folding it in would mislabel a quiet workspace as busy with agent work.
+ */
+export declare const LspActivityChangedStatusPayloadSchema: z.ZodObject<{
+    status: z.ZodLiteral<"lsp_activity_changed">;
+    busyRoots: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * Diagnostics for one open document, pushed unsolicited.
+ *
+ * This is the one part of code intelligence that is not request/response:
+ * `textDocument/publishDiagnostics` arrives whenever the server has recomputed, which is
+ * whenever it feels like it. So it is a status broadcast, and the payload is the document's
+ * **whole** current set - never a delta. A missed delta would leave a stale squiggle on a
+ * line the user already fixed, and an idempotent snapshot cannot drift.
+ *
+ * Only documents a client has synced produce these. A server may know about every file in
+ * the project; pushing all of it would be unbounded, and nothing can render a marker in a
+ * file that is not open.
+ */
+export declare const LspDiagnosticsChangedStatusPayloadSchema: z.ZodObject<{
+    status: z.ZodLiteral<"lsp_diagnostics_changed">;
+    cwd: z.ZodString;
+    path: z.ZodString;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+        endLine: z.ZodNumber;
+        endColumn: z.ZodNumber;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+            hint: "hint";
+        }>;
+        message: z.ZodString;
+        source: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+        codeHref: z.ZodOptional<z.ZodString>;
+        serverId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export declare const LspLanguageStateSchema: z.ZodObject<{
+    id: z.ZodString;
+    enabled: z.ZodBoolean;
+    installed: z.ZodBoolean;
+    running: z.ZodBoolean;
+    rung: z.ZodNullable<z.ZodString>;
+    bin: z.ZodString;
+    discovery: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    extensions: z.ZodArray<z.ZodString>;
+    indexCost: z.ZodString;
+    install: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        steps: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+            display: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        url: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const LspRunningServerSchema: z.ZodObject<{
+    rootPath: z.ZodString;
+    serverId: z.ZodString;
+    uptimeMs: z.ZodNumber;
+    lastUsedAt: z.ZodNumber;
+}, z.core.$strip>;
+export declare const LspServersListResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"lsp.servers.list.response">;
+    payload: z.ZodObject<{
+        cwd: z.ZodString;
+        languages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            enabled: z.ZodBoolean;
+            installed: z.ZodBoolean;
+            running: z.ZodBoolean;
+            rung: z.ZodNullable<z.ZodString>;
+            bin: z.ZodString;
+            discovery: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            extensions: z.ZodArray<z.ZodString>;
+            indexCost: z.ZodString;
+            install: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                steps: z.ZodArray<z.ZodObject<{
+                    command: z.ZodString;
+                    args: z.ZodArray<z.ZodString>;
+                    display: z.ZodString;
+                    note: z.ZodNullable<z.ZodString>;
+                }, z.core.$strip>>;
+                url: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        running: z.ZodArray<z.ZodObject<{
+            rootPath: z.ZodString;
+            serverId: z.ZodString;
+            uptimeMs: z.ZodNumber;
+            lastUsedAt: z.ZodNumber;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const LspServerStopResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"lsp.server.stop.response">;
+    payload: z.ZodObject<{
+        rootPath: z.ZodString;
+        serverId: z.ZodString;
+        ok: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type LspServersListRequest = z.infer<typeof LspServersListRequestSchema>;
+export type LspServersListResponse = z.infer<typeof LspServersListResponseSchema>;
+export type LspServerStopRequest = z.infer<typeof LspServerStopRequestSchema>;
+export type LspServerStopResponse = z.infer<typeof LspServerStopResponseSchema>;
+export type LspLanguageState = z.infer<typeof LspLanguageStateSchema>;
+export type LspRunningServer = z.infer<typeof LspRunningServerSchema>;
+export type LspActivityChangedStatusPayload = z.infer<typeof LspActivityChangedStatusPayloadSchema>;
+export type LspDiagnosticsChangedStatusPayload = z.infer<typeof LspDiagnosticsChangedStatusPayloadSchema>;
+//# sourceMappingURL=code-intelligence.d.ts.map