@karmaniverous/jeeves-server-core 0.4.0 → 0.5.0

package/dist/src/catalog/serverCatalog.d.ts

@@ -0,0 +1,1143 @@
+/**
+ * The jeeves-server endpoint catalog (`SERVER_CATALOG`): one Zod-described entry per machine-API route, from which the service's routes and validation, the OpenAPI document, the SDK client and the plugin's tools are derived; plus the types inferred from it. Pure.
+ *
+ * @remarks
+ * jeeves' three standard entries (`status` public; `config` and
+ * `configApply` admin), then the content, sharing, utility, event, OAuth and
+ * runner entries. Entry names are the SDK method, the plugin tool's base
+ * name (`server_` + snake_case) and the OpenAPI `operationId`. Browser
+ * routes (the SPA, sign-in, `/oauth/callback`, `/go/:slug`) are not in it.
+ *
+ * @packageDocumentation
+ */
+import { type CatalogInput, type ClientResponse } from '@karmaniverous/jeeves/catalog';
+import type { z } from 'zod';
+import { serverHealthSchema } from './statusSchemas.js';
+/** The jeeves-server endpoint catalog. */
+export declare const SERVER_CATALOG: import("@karmaniverous/jeeves/catalog").Catalog<readonly [{
+    readonly name: "status";
+    readonly method: "GET";
+    readonly path: "/status";
+    readonly description: `Get ${string} service health, version, and uptime.`;
+    readonly response: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        uptime: z.ZodNumber;
+        status: z.ZodUnion<readonly [z.ZodLiteral<"healthy">, z.ZodLiteral<"degraded">, z.ZodLiteral<"unhealthy">]>;
+        health: z.ZodObject<{
+            port: z.ZodNumber;
+            chrome: z.ZodObject<{
+                configured: z.ZodBoolean;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            auth: z.ZodObject<{
+                modes: z.ZodArray<z.ZodString>;
+                insiderCount: z.ZodNumber;
+                keyCount: z.ZodNumber;
+                googleRedirectUri: z.ZodOptional<z.ZodString>;
+                oauthRedirectUri: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            events: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                cmd: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            eventQueue: z.ZodObject<{
+                offset: z.ZodNumber;
+                size: z.ZodNumber;
+                pendingBytes: z.ZodNumber;
+                parseErrors: z.ZodNumber;
+                lastCursorReset: z.ZodOptional<z.ZodString>;
+                lastRewind: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            exports: z.ZodObject<{
+                documents: z.ZodArray<z.ZodString>;
+                directories: z.ZodArray<z.ZodString>;
+                diagrams: z.ZodArray<z.ZodString>;
+                chromeAvailable: z.ZodBoolean;
+            }, z.core.$strip>;
+            diagrams: z.ZodObject<{
+                mermaid: z.ZodBoolean;
+                plantuml: z.ZodObject<{
+                    localJar: z.ZodBoolean;
+                    servers: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            services: z.ZodObject<{
+                watcher: z.ZodObject<{
+                    url: z.ZodString;
+                    reachable: z.ZodBoolean;
+                    version: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                runner: z.ZodObject<{
+                    url: z.ZodString;
+                    reachable: z.ZodBoolean;
+                    version: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                meta: z.ZodObject<{
+                    url: z.ZodString;
+                    reachable: z.ZodBoolean;
+                    version: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                lastChecked: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            branding: z.ZodObject<{
+                name: z.ZodString;
+                emoji: z.ZodOptional<z.ZodString>;
+                theme: z.ZodOptional<z.ZodObject<{
+                    light: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    dark: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly auth: import("@karmaniverous/jeeves/catalog").AuthSpec;
+    readonly kind: "read";
+}, {
+    readonly name: "config";
+    readonly method: "GET";
+    readonly path: "/config";
+    readonly description: `Query ${string} running configuration. Optional JSONPath filter.`;
+    readonly query: z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodUnion<readonly [z.ZodObject<{
+        result: z.ZodArray<z.ZodUnknown>;
+        count: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{}, z.core.$loose>]>;
+    readonly auth: import("@karmaniverous/jeeves/catalog").AuthSpec;
+    readonly kind: "read";
+}, {
+    readonly name: "configApply";
+    readonly method: "POST";
+    readonly path: "/config/apply";
+    readonly description: `Apply a config patch to the running ${string} service.`;
+    readonly body: z.ZodObject<{
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        replace: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        applied: z.ZodLiteral<true>;
+        config: z.ZodObject<{}, z.core.$loose>;
+        warning: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: import("@karmaniverous/jeeves/catalog").AuthSpec;
+    readonly kind: "write";
+}, {
+    readonly response: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "health";
+    readonly method: "GET";
+    readonly path: "/health";
+    readonly description: "Liveness check: returns { ok: true }, with no downstream checks.";
+}, {
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        authenticated: z.ZodBoolean;
+        email: z.ZodOptional<z.ZodString>;
+        picture: z.ZodOptional<z.ZodString>;
+        isInsider: z.ZodBoolean;
+        keyCreatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        searchEnabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "authStatus";
+    readonly method: "GET";
+    readonly path: "/api/auth/status";
+    readonly description: "Check current authentication status. Returns whether authenticated, email, insider status, and key metadata.";
+}, {
+    readonly body: z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        returnTo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        verifyUrl: z.ZodString;
+    }, z.core.$strip>;
+    readonly auth: "none";
+    readonly kind: "write";
+    readonly name: "sendMagicLink";
+    readonly method: "POST";
+    readonly path: "/api/auth/magic";
+    readonly description: "Request a sign-in link by email. Always answers with a verification URL, whether or not the email belongs to an insider.";
+}, {
+    readonly query: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        path: z.ZodString;
+        key: z.ZodString;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "header";
+            readonly name: "X-API-Key";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "pathKey";
+    readonly method: "GET";
+    readonly path: "/key";
+    readonly description: "Compute the outsider path key for a path from the machine seed sent in X-API-Key.";
+}, {
+    readonly response: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "header";
+            readonly name: "X-API-Key";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "insiderKey";
+    readonly method: "GET";
+    readonly path: "/insider-key";
+    readonly description: "Compute the insider key for the machine seed sent in X-API-Key.";
+}, {
+    readonly body: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        results: z.ZodArray<z.ZodObject<{
+            filePath: z.ZodString;
+            browsePath: z.ZodString;
+            fileName: z.ZodString;
+            bestScore: z.ZodNumber;
+            domains: z.ZodArray<z.ZodUnknown>;
+            title: z.ZodOptional<z.ZodUnknown>;
+            author: z.ZodOptional<z.ZodUnknown>;
+            participants: z.ZodOptional<z.ZodUnknown>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            chunks: z.ZodArray<z.ZodObject<{
+                text: z.ZodString;
+                index: z.ZodNumber;
+                score: z.ZodNumber;
+            }, z.core.$strip>>;
+            mtime: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        metadata: z.ZodObject<{
+            domains: z.ZodArray<z.ZodUnknown>;
+            authors: z.ZodArray<z.ZodUnknown>;
+            participants: z.ZodArray<z.ZodUnknown>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "search";
+    readonly method: "POST";
+    readonly path: "/api/search";
+    readonly description: "Semantic search through jeeves-watcher, grouped by file and filtered to the scopes of the caller.";
+}, {
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "searchFacets";
+    readonly method: "GET";
+    readonly path: "/api/search/facets";
+    readonly description: "Search facets from jeeves-watcher, passed through unchanged.";
+}, {
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodArray<z.ZodObject<{
+        letter: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "drives";
+    readonly method: "GET";
+    readonly path: "/api/drives";
+    readonly description: "List available root drives/labels configured on the server.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        path: z.ZodString;
+        ext: z.ZodString;
+        size: z.ZodNumber;
+        mtime: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+            ext: z.ZodString;
+            size: z.ZodNullable<z.ZodNumber>;
+            mtime: z.ZodNullable<z.ZodString>;
+            itemCount: z.ZodNullable<z.ZodNumber>;
+            shareUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        breadcrumbs: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        isInsider: z.ZodBoolean;
+    }, z.core.$strip>]>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "browse";
+    readonly method: "GET";
+    readonly path: "/api/path/*";
+    readonly description: "Get file or directory metadata. For files: size, mtime, content type, rendered HTML availability. For directories: listing of entries.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        raw: z.ZodOptional<z.ZodString>;
+        render_diagrams: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        type: z.ZodEnum<{
+            plantuml: "plantuml";
+            text: "text";
+            markdown: "markdown";
+            mermaid: "mermaid";
+            svg: "svg";
+            csv: "csv";
+            image: "image";
+            binary: "binary";
+        }>;
+        content: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        headings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            text: z.ZodString;
+            slug: z.ZodString;
+        }, z.core.$strip>>>;
+        size: z.ZodOptional<z.ZodNumber>;
+        fileName: z.ZodString;
+        breadcrumbs: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        isInsider: z.ZodBoolean;
+        mtime: z.ZodOptional<z.ZodNumber>;
+        renderAs: z.ZodOptional<z.ZodString>;
+        matchedRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "fileContent";
+    readonly method: "GET";
+    readonly path: "/api/file/*";
+    readonly description: "Get a file with type-specific handling: Markdown, CSV and diagrams rendered to HTML, other text as is, images and binaries by name. `raw=1` skips rendering.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly body: z.ZodObject<{
+        content: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        path: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "write";
+    readonly name: "fileWrite";
+    readonly method: "PUT";
+    readonly path: "/api/file/*";
+    readonly description: "Overwrite the content of an existing file. Insider-only; the file must already exist.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly body: z.ZodObject<{
+        action: z.ZodEnum<{
+            "edit-block": "edit-block";
+            "delete-block": "delete-block";
+            "insert-block": "insert-block";
+            "edit-cell": "edit-cell";
+            "toggle-checkbox": "toggle-checkbox";
+        }>;
+        startLine: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        content: z.ZodOptional<z.ZodString>;
+        atLine: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodEnum<{
+            before: "before";
+            after: "after";
+        }>>;
+        context: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        col: z.ZodOptional<z.ZodNumber>;
+        index: z.ZodOptional<z.ZodNumber>;
+        checked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "write";
+    readonly name: "fileMutate";
+    readonly method: "POST";
+    readonly path: "/api/file/*";
+    readonly description: "Apply a structured mutation to a .md file. Insider-only. Supports: edit-block, delete-block, insert-block, edit-cell, toggle-checkbox.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        download: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "raw";
+    readonly method: "GET";
+    readonly path: "/api/raw/*";
+    readonly description: "Download a file as is, with its own content type. `download=1` always sends it as an attachment.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<{
+            pdf: "pdf";
+            docx: "docx";
+            zip: "zip";
+            tar: "tar";
+        }>>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "export";
+    readonly method: "GET";
+    readonly path: "/api/export/*";
+    readonly description: "Export a Markdown document as PDF or DOCX, or a directory as a ZIP or Tar archive (archives for insiders only).";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        cleared: z.ZodObject<{
+            exports: z.ZodNumber;
+            diagrams: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "write";
+    readonly name: "exportCacheClear";
+    readonly method: "DELETE";
+    readonly path: "/api/export-cache/*";
+    readonly description: "Clear the export and diagram caches for a given path.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "exportMermaid";
+    readonly method: "GET";
+    readonly path: "/api/mermaid-export/*";
+    readonly description: "Export a Mermaid diagram file as SVG, PNG or PDF.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "exportPlantUml";
+    readonly method: "GET";
+    readonly path: "/api/plantuml-export/*";
+    readonly description: "Export a PlantUML diagram file in one of the formats the configured renderers support (SVG, PNG, PDF, EPS).";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        exists: z.ZodBoolean;
+        isDirectory: z.ZodOptional<z.ZodBoolean>;
+        pageUrl: z.ZodOptional<z.ZodString>;
+        rawUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        downloadUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        exportLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            format: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "linkInfo";
+    readonly method: "GET";
+    readonly path: "/api/link-info/*";
+    readonly description: "Query available link types for a path (exists, page URL, raw URL, export links for PDF/DOCX/SVG/PNG).";
+}, {
+    readonly params: z.ZodObject<{
+        type: z.ZodEnum<{
+            plantuml: "plantuml";
+            mermaid: "mermaid";
+        }>;
+        hash: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "image/svg+xml";
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "diagram";
+    readonly method: "GET";
+    readonly path: "/api/diagram/:type/:hash";
+    readonly description: "Get a diagram embedded in a rendered document, as SVG, by its type and content hash.";
+}, {
+    readonly params: z.ZodObject<{
+        slug: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        type: z.ZodEnum<{
+            plantuml: "plantuml";
+            text: "text";
+            markdown: "markdown";
+            mermaid: "mermaid";
+            svg: "svg";
+            csv: "csv";
+            image: "image";
+            binary: "binary";
+        }>;
+        content: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        headings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            text: z.ZodString;
+            slug: z.ZodString;
+        }, z.core.$strip>>>;
+        size: z.ZodOptional<z.ZodNumber>;
+        fileName: z.ZodString;
+        breadcrumbs: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        isInsider: z.ZodBoolean;
+        mtime: z.ZodOptional<z.ZodNumber>;
+        renderAs: z.ZodOptional<z.ZodString>;
+        matchedRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "publicContent";
+    readonly method: "GET";
+    readonly path: "/api/public-content/:slug";
+    readonly description: "Get one of the public pages of the server (readme, privacy, terms) rendered as Markdown.";
+}, {
+    readonly body: z.ZodObject<{
+        path: z.ZodString;
+        expiry: z.ZodOptional<z.ZodString>;
+        depth: z.ZodOptional<z.ZodNumber>;
+        dirs: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        url: z.ZodString;
+        path: z.ZodString;
+        exp: z.ZodNullable<z.ZodString>;
+        depth: z.ZodNumber;
+        dirs: z.ZodBoolean;
+        isDirectory: z.ZodBoolean;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "share";
+    readonly method: "POST";
+    readonly path: "/api/share";
+    readonly description: "Sign a share link for a path: a path key, optionally expiring, or a deep share (`depth`, `dirs`). The response reports whether the path is a directory.";
+}, {
+    readonly body: z.ZodObject<{
+        path: z.ZodString;
+        insiders: z.ZodArray<z.ZodString>;
+        depth: z.ZodOptional<z.ZodNumber>;
+        dirs: z.ZodOptional<z.ZodBoolean>;
+        enforceOutsiderPolicy: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        url: z.ZodNullable<z.ZodString>;
+        type: z.ZodEnum<{
+            insider: "insider";
+            "outsider-share": "outsider-share";
+            blocked: "blocked";
+            "policy-denied": "policy-denied";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+        blocked: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        warning: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "shareFor";
+    readonly method: "POST";
+    readonly path: "/api/util/share-for";
+    readonly description: "Sign a share link for a path aimed at named insiders: an insider link when every recipient is an insider with access, else an outsider share checked against the outsider policy.";
+}, {
+    readonly params: z.ZodObject<{
+        file: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>;
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "contentLink";
+    readonly method: "GET";
+    readonly path: "/api/content-link/:file";
+    readonly description: "Pre-computed share link for one of the pinned content pages of the server (privacy, terms).";
+}, {
+    readonly response: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>;
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "readmeLink";
+    readonly method: "GET";
+    readonly path: "/api/readme-link";
+    readonly description: "Pre-computed share link for the README of the server.";
+}, {
+    readonly query: z.ZodObject<{
+        fsPath: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        browsePath: z.ZodString;
+        browseUrl: z.ZodString;
+        publicUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "resolvePath";
+    readonly method: "GET";
+    readonly path: "/api/resolve-path";
+    readonly description: "Convert an absolute filesystem path to a server browse path and optional public URL.";
+}, {
+    readonly response: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        keyCreatedAt: z.ZodString;
+        invalidates: z.ZodArray<z.ZodEnum<{
+            insiderKey: "insiderKey";
+            outsiderLinks: "outsiderLinks";
+        }>>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "destructive";
+    readonly name: "rotateKey";
+    readonly method: "POST";
+    readonly path: "/api/rotate-key";
+    readonly description: "Rotate the key of the calling insider. The old insider key and every outsider link the insider signed stop working.";
+}, {
+    readonly body: z.ZodObject<{}, z.core.$loose>;
+    readonly response: z.ZodObject<{
+        matched: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }];
+    };
+    readonly kind: "write";
+    readonly name: "receiveEvent";
+    readonly method: "POST";
+    readonly path: "/event";
+    readonly description: "Event gateway webhook receiver: matches a JSON object against the configured event schemas and queues the matching command.";
+}, {
+    readonly query: z.ZodObject<{
+        limit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodArray<z.ZodObject<{
+        ts: z.ZodString;
+        event: z.ZodNullable<z.ZodString>;
+        matched: z.ZodBoolean;
+        exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        timedOut: z.ZodOptional<z.ZodBoolean>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        bodyPreview: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        originalBytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "listEvents";
+    readonly method: "GET";
+    readonly path: "/api/events";
+    readonly description: "Recent event log entries, newest last (insiders with no scopes configured; limit capped at 100).";
+}, {
+    readonly body: z.ZodObject<{
+        provider: z.ZodString;
+        account: z.ZodString;
+        authUrl: z.ZodOptional<z.ZodString>;
+        tokenUrl: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodString;
+        clientSecret: z.ZodString;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        pkce: z.ZodOptional<z.ZodBoolean>;
+        origin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        authUrl: z.ZodString;
+        state: z.ZodString;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "write";
+    readonly name: "oauthStart";
+    readonly method: "POST";
+    readonly path: "/api/oauth/start";
+    readonly description: "Start an OAuth2 authorization code flow; returns the URL to open in a browser.";
+}, {
+    readonly query: z.ZodObject<{
+        provider: z.ZodString;
+        account: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        exists: z.ZodBoolean;
+        expired: z.ZodBoolean;
+        provider: z.ZodString;
+        account: z.ZodString;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "oauthStatus";
+    readonly method: "GET";
+    readonly path: "/api/oauth/status";
+    readonly description: "Check whether valid OAuth2 credentials exist for a provider/account.";
+}, {
+    readonly query: z.ZodObject<{
+        provider: z.ZodString;
+        account: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        access_token: z.ZodString;
+        token_type: z.ZodString;
+        expires_in_seconds: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "read";
+    readonly name: "oauthToken";
+    readonly method: "GET";
+    readonly path: "/api/oauth/token";
+    readonly description: "Get a valid access token for a provider/account, refreshing it when expired.";
+}, {
+    readonly kind: "read";
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly name: "runnerListJobs";
+    readonly method: "GET";
+    readonly path: "/api/runner/jobs";
+    readonly description: "List the jeeves-runner jobs (runner GET /jobs).";
+}, {
+    readonly kind: "read";
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly name: "runnerGetJob";
+    readonly method: "GET";
+    readonly path: "/api/runner/jobs/:id";
+    readonly description: "One jeeves-runner job (runner GET /jobs/:id).";
+}, {
+    readonly kind: "read";
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        limit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly name: "runnerListRuns";
+    readonly method: "GET";
+    readonly path: "/api/runner/jobs/:id/runs";
+    readonly description: "A jeeves-runner job's recent runs (runner GET /jobs/:id/runs).";
+}, {
+    readonly kind: "write";
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly name: "runnerRunJob";
+    readonly method: "POST";
+    readonly path: "/api/runner/jobs/:id/run";
+    readonly description: "Run a jeeves-runner job now (runner POST /jobs/:id/run).";
+}, {
+    readonly kind: "write";
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly name: "runnerEnableJob";
+    readonly method: "PATCH";
+    readonly path: "/api/runner/jobs/:id/enable";
+    readonly description: "Enable a jeeves-runner job (runner PATCH /jobs/:id/enable).";
+}, {
+    readonly kind: "write";
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly name: "runnerDisableJob";
+    readonly method: "PATCH";
+    readonly path: "/api/runner/jobs/:id/disable";
+    readonly description: "Disable a jeeves-runner job (runner PATCH /jobs/:id/disable).";
+}, {
+    readonly kind: "read";
+    readonly response: z.ZodUnknown;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly name: "runnerStatus";
+    readonly method: "GET";
+    readonly path: "/api/runner/status";
+    readonly description: "jeeves-runner status (runner GET /status).";
+}]>;
+/** The server endpoint catalog's type. */
+export type ServerCatalog = typeof SERVER_CATALOG;
+/** Name of a server catalog entry. */
+export type ServerEntryName = ServerCatalog['entries'][number]['name'];
+/** The catalog entry named `N`. */
+export type ServerEntry<N extends ServerEntryName> = Extract<ServerCatalog['entries'][number], {
+    name: N;
+}>;
+/** Request input of entry `N` (params, query and body fields, flat). */
+export type ServerInput<N extends ServerEntryName> = CatalogInput<ServerEntry<N>>;
+/** Successful response body of entry `N`. */
+export type ServerResponse<N extends ServerEntryName> = ClientResponse<ServerEntry<N>>;
+/** The server's `health` block in `GET /status`. */
+export type ServerHealth = z.output<typeof serverHealthSchema>;