@semiont/core 0.5.2 → 0.5.4

package/dist/types.d.ts

@@ -0,0 +1,3517 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/api/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Health Check
+         * @description Check if the API is operational and database is connected
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Health status of the API */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["HealthResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/password": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Password Authentication
+         * @description Authenticate with email and password for users with password provider
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["PasswordAuthRequest"];
+                };
+            };
+            responses: {
+                /** @description Authentication successful */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AuthResponse"];
+                    };
+                };
+                /** @description Bad request - invalid input or OAuth user attempting password auth */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Unauthorized - invalid credentials */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - account not active */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/google": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Google OAuth Authentication
+         * @description Authenticate with Google OAuth access token
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["GoogleAuthRequest"];
+                };
+            };
+            responses: {
+                /** @description Successful authentication */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AuthResponse"];
+                    };
+                };
+                /** @description Invalid request or authentication failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/refresh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Refresh Access Token
+         * @description Exchange a refresh token for a new access token
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["TokenRefreshRequest"];
+                };
+            };
+            responses: {
+                /** @description New access token generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TokenRefreshResponse"];
+                    };
+                };
+                /** @description Invalid or expired refresh token */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/mcp-generate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate MCP Token
+         * @description Generate a short-lived token for MCP server
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description MCP token generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MCPGenerateResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/media": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate Media Token
+         * @description Generate a short-lived, resource-scoped media token for use as a ?token= query parameter on binary resource URLs (images, PDFs). Requires session authentication.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["MediaTokenRequest"];
+                };
+            };
+            responses: {
+                /** @description Media token generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MediaTokenResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/agent": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Software-Agent Token Exchange
+         * @description Exchange the shared secret plus an inference (provider, model) pair for a bearer JWT issued for that agent identity. Used by worker processes that emit on behalf of one or more software peers.
+         *
+         *     The issued JWT carries the agent's DID (shape `did:web:<host>:agents:<provider>:<model>`); the bus stamps that DID onto `_userId` so events the agent emits attribute to the agent rather than to a generic worker pool.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @description The shared secret (SEMIONT_WORKER_SECRET) */
+                        secret: string;
+                        /** @description Inference provider (e.g. ollama, anthropic) */
+                        provider: string;
+                        /** @description Model identifier (e.g. gemma2:27b, claude-3-5-sonnet) */
+                        model: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Token issued */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description Bearer JWT for subsequent authenticated requests */
+                            token: string;
+                            /** @description DID of the software-agent identity the token is acting as */
+                            did: string;
+                        };
+                    };
+                };
+                /** @description Missing or invalid request fields */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Invalid agent secret */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Agent authentication not configured */
+                503: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/users/me": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Current User
+         * @description Get information about the authenticated user
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description User information */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UserResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/users/accept-terms": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Accept Terms
+         * @description Mark terms as accepted for the current user
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Terms accepted successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AcceptTermsResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/users/logout": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Logout
+         * @description Logout the current user
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Logged out successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AcceptTermsResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Service Status
+         * @description Get service status and feature availability
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Service status information */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["StatusResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List All Users
+         * @description Get a list of all users (admin only)
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description List of users */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AdminUsersListResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Admin access required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/users/stats": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * User Statistics
+         * @description Get user statistics (admin only)
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description User statistics */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AdminUserStatsResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Admin access required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/users/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Delete User
+         * @description Delete a user account (admin only, cannot delete own account)
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description User deleted successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AcceptTermsResponse"];
+                    };
+                };
+                /** @description Cannot delete own account */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Admin access required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description User not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        /**
+         * Update User
+         * @description Update user properties (admin only)
+         */
+        patch: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["UpdateUserRequest"];
+                };
+            };
+            responses: {
+                /** @description User updated successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AdminUpdateUserResponse"];
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Admin access required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description User not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        trace?: never;
+    };
+    "/api/admin/oauth/config": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get OAuth Configuration
+         * @description Get OAuth provider configuration (admin only, read-only)
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OAuth configuration */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["OAuthConfigResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Admin access required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/exchange/backup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Backup Knowledge Base
+         * @description Create a lossless backup of the knowledge base as a streaming tar.gz archive
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Streaming backup archive */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/gzip": string;
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Admin access required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/admin/exchange/restore": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Restore Knowledge Base
+         * @description Restore knowledge base from a backup archive. Returns SSE progress events.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "multipart/form-data": {
+                        /**
+                         * Format: binary
+                         * @description Backup archive (.tar.gz)
+                         */
+                        file: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description SSE stream of restore progress events */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": string;
+                    };
+                };
+                /** @description Invalid file format */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Admin access required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/moderate/exchange/export": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Export Knowledge Base as JSON-LD
+         * @description Export the knowledge base as a JSON-LD Linked Data tar.gz archive
+         */
+        post: {
+            parameters: {
+                query?: {
+                    /** @description Include archived resources in export */
+                    includeArchived?: boolean;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Streaming JSON-LD archive */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/gzip": string;
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - moderator or admin role required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/moderate/exchange/import": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Import Knowledge Base from JSON-LD
+         * @description Import resources from a JSON-LD Linked Data archive. Returns SSE progress events.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "multipart/form-data": {
+                        /**
+                         * Format: binary
+                         * @description JSON-LD archive (.tar.gz)
+                         */
+                        file: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description SSE stream of import progress events */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": string;
+                    };
+                };
+                /** @description Invalid file format */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - moderator or admin role required */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/cookies/consent": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get cookie consent preferences
+         * @description Returns the current user's cookie consent preferences.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Current consent preferences */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CookieConsentResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Update cookie consent preferences
+         * @description Update the current user's cookie consent preferences. The `necessary` flag must be true — necessary cookies cannot be disabled.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["CookieConsentRequest"];
+                };
+            };
+            responses: {
+                /** @description Consent updated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CookieConsentResponse"];
+                    };
+                };
+                /** @description Invalid consent data (non-boolean fields, missing fields, or necessary=false) */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CookieConsentResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/cookies/export": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Export cookie data (GDPR)
+         * @description Export the current user's cookie-related data as a downloadable JSON file. Response sets `Content-Disposition: attachment; filename="cookie-data-export-<timestamp>.json"`.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description User cookie data as attachment */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CookieExportResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/mcp-setup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * MCP Setup (browser-driven CLI handoff)
+         * @description Browser flow that generates a long-lived (30 day) MCP refresh token for the authenticated user and redirects to a localhost callback URL with the token as a query parameter. Used by CLI tooling (similar to Google's OAuth CLI flow).
+         *
+         *     The callback URL must match one of the localhost patterns (`http://localhost:<port>/...`, `http://127.0.0.1:<port>/...`, or `http://[::1]:<port>/...`).
+         */
+        get: {
+            parameters: {
+                query: {
+                    /** @description Localhost URL to redirect to with `?token=<refresh-token>` on success. */
+                    callback: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Redirect to the callback URL with the newly-issued refresh token appended as a `?token=` query parameter. */
+                302: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Missing or non-localhost callback URL */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Failed to generate refresh token */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/bus/subscribe": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Subscribe to the Semiont event bus (SSE)
+         * @description Opens a long-lived Server-Sent Events stream over which the bus delivers events matching the requested channels and scopes.
+         *
+         *     Each SSE frame has `event: bus-event`, a JSON-encoded `data` of the form `{ channel, payload, scope? }`, and an `id` (either a persisted event id, `scope:seq`, for domain events; or an ephemeral id for job-lifecycle / result channels).
+         *
+         *     Pass the last-received id as `Last-Event-ID` to resume — the server replays missed persisted events and emits a `bus:resume-gap` synthetic event when the gap exceeds the replay window.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Unscoped channels to subscribe to. Repeat the parameter for multiple channels. At least one of `channel` or `scoped` is required. */
+                    channel?: string[];
+                    /** @description Resource-scoped channels to subscribe to (requires `scope`). Repeat for multiple. */
+                    scoped?: string[];
+                    /** @description Resource scope for scoped channels (typically a resourceId). */
+                    scope?: string;
+                };
+                header?: {
+                    /** @description Id of the last event the client received. On reconnect, the server replays persisted events after this id and emits `bus:resume-gap` if the gap exceeds the replay cap. */
+                    "Last-Event-ID"?: string;
+                };
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description SSE stream opened */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+                /** @description No channels requested (at least one `channel` or `scoped` parameter required) */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/bus/emit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Emit an event on the Semiont bus
+         * @description Publishes an event to the bus. The channel name must be registered in `bus-protocol.ts` (`EventMap`); the payload is validated against the channel's schema in `CHANNEL_SCHEMAS` when one is registered.
+         *
+         *     When `scope` is set, the event publishes on `eventBus.scope(scope)` rather than the global bus, routing it to per-resource SSE subscribers only. The authenticated user's DID is attached to the payload as `_userId` automatically.
+         *
+         *     Returns 202 Accepted — the event is delivered to in-memory subscribers synchronously, but downstream persistence (Stower) and materialization happen asynchronously.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["BusEmitRequest"];
+                };
+            };
+            responses: {
+                /** @description Event accepted and published to subscribers */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Missing/invalid channel, payload, or scope; or payload failed schema validation for the channel */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create a resource
+         * @description Upload binary content + metadata as multipart/form-data. The backend writes content to disk, then emits yield:create on the bus; Stower persists it and returns a 202 with the new resourceId. Full reconciliation happens via SSE domain events (yield:created).
+         *
+         *     Generation workers and the /know/compose page both hit this route — bytes always travel on the HTTP wire, never on the bus.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "multipart/form-data": {
+                        /** @description Human-readable resource name */
+                        name: string;
+                        /**
+                         * Format: binary
+                         * @description Binary content
+                         */
+                        file: string;
+                        /** @description Media type of the content (e.g. text/plain, text/markdown, image/png) */
+                        format: string;
+                        /** @description Where the content has been / should be placed (file://... for local). If omitted, derived from name + format. */
+                        storageUri?: string;
+                        /** @description ISO 639-1 language code */
+                        language?: string;
+                        /** @description JSON-stringified array of entity type names */
+                        entityTypes?: string;
+                        /** @description For AI-generated resources: the annotation that triggered generation. Nested into generatedFrom.annotationId on the persisted event. */
+                        sourceAnnotationId?: string;
+                        /** @description For AI-generated resources: the source resource the generating annotation lives on. Nested into generatedFrom.resourceId on the persisted event. */
+                        sourceResourceId?: string;
+                        /** @description For AI-generated resources: the prompt that drove generation */
+                        generationPrompt?: string;
+                        /** @description For AI-generated resources: JSON-stringified Agent (single object or array), capturing which model/worker produced the content */
+                        generator?: string;
+                        /** @description 'true' or 'false' — whether the resource is a draft */
+                        isDraft?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Resource accepted for creation */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CreateResourceResponse"];
+                    };
+                };
+                /** @description Missing required fields (name, file, or format) */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a resource (content-negotiated)
+         * @description Content negotiation via the Accept header:
+         *     - application/ld+json (default) — returns JSON-LD metadata including all annotations + inbound entity references
+         *     - text/* or image/* or application/pdf — returns the raw representation bytes
+         *
+         *     Binary payloads flow directly from the content store; metadata payloads go through the bus gateway.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description application/ld+json for metadata, or a text/image/pdf media type for raw content */
+                    Accept?: string;
+                };
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Resource content or metadata, depending on Accept */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/ld+json": components["schemas"]["GetResourceResponse"];
+                        "text/plain": string;
+                        "text/markdown": string;
+                        "text/html": string;
+                        "image/*": string;
+                        "application/pdf": string;
+                    };
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Failed to retrieve resource */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Request timed out (bus gateway) */
+                504: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/resources/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get raw resource content (browser-friendly alias)
+         * @description Browser-friendly alternative to GET /resources/{id} that always returns the raw representation, never JSON-LD. Used by `<img>` / PDF.js / `<video>` tags and anywhere an httpOnly cookie is the only feasible auth vector. Behaves like GET /resources/{id} with JSON-LD stripped from the Accept header before content negotiation.
+         *
+         *     Sets long-lived immutable Cache-Control (content is addressed by checksum upstream, so bytes never change for a given resource id).
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Raw representation bytes with appropriate Content-Type */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/plain": string;
+                        "text/markdown": string;
+                        "text/html": string;
+                        "image/*": string;
+                        "application/pdf": string;
+                    };
+                };
+                /** @description Resource or representation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Failed to retrieve resource */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        AcceptTermsResponse: {
+            success: boolean;
+            message: string;
+        };
+        AdminUpdateUserResponse: {
+            success: boolean;
+            user: {
+                id: string;
+                email: string;
+                name: string | null;
+                image: string | null;
+                domain: string;
+                provider: string;
+                isAdmin: boolean;
+                isActive: boolean;
+                lastLogin: string | null;
+                created: string;
+                updatedAt: string;
+            };
+        };
+        AdminUsersListResponse: {
+            success: boolean;
+            users: {
+                id: string;
+                email: string;
+                name: string | null;
+                image: string | null;
+                domain: string;
+                provider: string;
+                isAdmin: boolean;
+                isActive: boolean;
+                lastLogin: string | null;
+                created: string;
+                updatedAt: string;
+            }[];
+        };
+        AdminUserStatsResponse: {
+            success: boolean;
+            stats: {
+                totalUsers: number;
+                activeUsers: number;
+                adminUsers: number;
+                regularUsers: number;
+                domainBreakdown: {
+                    domain: string;
+                    count: number;
+                }[];
+                recentSignups: {
+                    id: string;
+                    email: string;
+                    name: string | null;
+                    created: string;
+                }[];
+            };
+        };
+        /** @description Web Annotation / W3C PROV Agent. Discriminated by @type — Person, Organization, or Software. Each branch carries fields appropriate to its kind. Software peers are first-class participants, not a sub-class of Person. */
+        Agent: ({
+            /** @constant */
+            "@type": "Person";
+            /**
+             * Format: uri
+             * @description DID-shaped identifier (e.g. did:web:host:users:email%40host)
+             */
+            "@id"?: string;
+            /** @description Display name */
+            name: string;
+            nickname?: string;
+            email?: string;
+            email_sha1?: string;
+            homepage?: string;
+        } & {
+            [key: string]: unknown;
+        }) | ({
+            /** @constant */
+            "@type": "Organization";
+            /** Format: uri */
+            "@id"?: string;
+            name: string;
+            homepage?: string;
+        } & {
+            [key: string]: unknown;
+        }) | ({
+            /** @constant */
+            "@type": "Software";
+            /**
+             * Format: uri
+             * @description DID-shaped identifier (e.g. did:web:host:agents:provider:model)
+             */
+            "@id"?: string;
+            /** @description Stable human-friendly label. Not parsed; UI composes display from structured fields. */
+            name: string;
+            /** @description Inference provider (e.g. ollama, anthropic) */
+            provider?: string;
+            /** @description Model identifier (e.g. gemma2:27b, claude-3-5-sonnet) */
+            model?: string;
+            /** @description Inference parameters (temperature, maxTokens, systemPrompt, etc.). Runtime metadata, not part of identity. */
+            parameters?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        });
+        Annotation: {
+            /**
+             * @description W3C Web Annotation JSON-LD context
+             * @default http://www.w3.org/ns/anno.jsonld
+             * @enum {string}
+             */
+            "@context": "http://www.w3.org/ns/anno.jsonld";
+            /**
+             * @description W3C Annotation type
+             * @default Annotation
+             * @enum {string}
+             */
+            type: "Annotation";
+            id: string;
+            motivation: components["schemas"]["Motivation"];
+            /** @description W3C Web Annotation target - can be a simple IRI string (entire resource) or an object with source and optional selector (fragment) */
+            target: string | components["schemas"]["AnnotationTarget"];
+            /** @description W3C Web Annotation body. Optional per the W3C spec — annotations whose motivation alone is meaningful (highlighting) legitimately omit it. Present values are either a single body or a non-empty array of bodies; the prior empty-array 'stub' branch has been removed (it was a naming lie shared between highlights and never-actually-emitted stub references, and the source of the #651 reference-annotation validator bug). */
+            body?: components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
+            /** @description Web Annotation creator — the entity that initiated the annotation. For human-driven work this is a Person; for autonomous-agent work this is a Software peer. */
+            creator?: components["schemas"]["Agent"];
+            created?: string;
+            modified?: string;
+            /** @description Web Annotation generator — the SoftwareAgent that produced the annotation, when software was involved. Absent for purely manual annotations. Single object is the common case; array supports pipelines that combine multiple software peers. */
+            generator?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
+            /** @description PROV-O wasAttributedTo — all parties responsible for this annotation. For human-prompted AI work this combines `creator` (the Person) and `generator` (the Software). For purely manual annotations it equals `[creator]`; for autonomous-agent work it equals `[generator]` (and `creator` may be the same Software). */
+            wasAttributedTo?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
+        };
+        /** @description Phase 2: Body can be TextualBody (for entity tags, descriptions) or SpecificResource (for links) */
+        AnnotationBody: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+        AnnotationContextResponse: {
+            annotation: components["schemas"]["Annotation"];
+            context: {
+                before?: string;
+                selected: string;
+                after?: string;
+            };
+            resource: components["schemas"]["ResourceDescriptor"];
+        };
+        AnnotationLLMContextResponse: {
+            annotation: components["schemas"]["Annotation"];
+            sourceResource: components["schemas"]["ResourceDescriptor"];
+            targetResource?: components["schemas"]["ResourceDescriptor"] | null;
+            /** @description Gathered context for this annotation */
+            context?: components["schemas"]["GatheredContext"];
+            /** @description DEPRECATED: Use 'context' instead. Legacy source context format. */
+            sourceContext?: {
+                before: string;
+                selected: string;
+                after: string;
+            };
+            targetContext?: {
+                content: string;
+                summary?: string;
+            };
+            suggestedResolution?: {
+                resourceId: string;
+                resourceName: string;
+                confidence: number;
+                reasoning: string;
+            };
+        };
+        /** @description W3C Web Annotation target object - source is required, selector is optional */
+        AnnotationTarget: {
+            /** @description IRI of the resource being annotated */
+            source: string;
+            /** @description Optional selector to identify a specific segment of the source resource */
+            selector?: components["schemas"]["TextPositionSelector"] | components["schemas"]["TextQuoteSelector"] | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"] | (components["schemas"]["TextPositionSelector"] | components["schemas"]["TextQuoteSelector"] | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"])[];
+        };
+        AuthResponse: {
+            success: boolean;
+            user: {
+                id: string;
+                email: string;
+                name: string | null;
+                image: string | null;
+                domain: string;
+                isAdmin: boolean;
+            };
+            /** @description Short-lived access token (1 hour). Use as Authorization: Bearer header on API calls. */
+            token: string;
+            /** @description Long-lived refresh token (30 days). Exchange via POST /api/tokens/refresh for a fresh access token. */
+            refreshToken: string;
+            isNewUser: boolean;
+        };
+        BrowseFilesResponse: {
+            /** @description The directory path that was listed, relative to project root */
+            path: string;
+            entries: components["schemas"]["DirectoryEntry"][];
+        };
+        /** @description Emit an event on the Semiont bus. Channel names come from bus-protocol.ts; payload shape is validated against the channel's registered schema (CHANNEL_SCHEMAS). An optional scope routes resource-scoped broadcasts (e.g. mark:added, job:complete) to per-resource subscribers via eventBus.scope(scope); leave it unset for unscoped/global events. */
+        BusEmitRequest: {
+            /** @description Channel name from bus-protocol.ts EventMap */
+            channel: string;
+            /** @description Channel-specific payload, validated against CHANNEL_SCHEMAS */
+            payload: {
+                [key: string]: unknown;
+            };
+            /** @description Optional resource scope for broadcast channels (e.g. resourceId). Publishers only — frontends must never set this. */
+            scope?: string;
+        };
+        /** @description User's cookie consent preferences. `necessary` is always true — necessary cookies cannot be disabled. Timestamps and version are stamped server-side. */
+        CookieConsent: {
+            /** @enum {boolean} */
+            necessary: true;
+            analytics: boolean;
+            marketing: boolean;
+            preferences: boolean;
+            /** Format: date-time */
+            timestamp: string;
+            version: string;
+        };
+        /** @description Request body for POST /api/cookies/consent. All four preference fields must be booleans; `necessary` must be true. */
+        CookieConsentRequest: {
+            /** @enum {boolean} */
+            necessary: true;
+            analytics: boolean;
+            marketing: boolean;
+            preferences: boolean;
+        };
+        /** @description Standard envelope for cookie consent endpoints. On success `success: true` and `consent` carries the current preferences; on error `success: false` and `error` carries a human-readable message. */
+        CookieConsentResponse: {
+            success: boolean;
+            consent?: components["schemas"]["CookieConsent"];
+            error?: string;
+        };
+        /** @description GDPR data export of a user's cookie-related data. The response is returned as a file download (Content-Disposition: attachment). */
+        CookieExportResponse: {
+            user: {
+                id: string;
+                email: string;
+            };
+            consent: components["schemas"]["CookieConsent"];
+            /** Format: date-time */
+            exportDate: string;
+            dataRetentionPolicy: string;
+        };
+        DirectoryEntry: components["schemas"]["FileEntry"] | components["schemas"]["DirEntry"];
+        FileEntry: {
+            /** @enum {string} */
+            type: "file";
+            /** @description Entry name (basename) */
+            name: string;
+            /** @description Path relative to project root */
+            path: string;
+            /** @description File size in bytes */
+            size: number;
+            /**
+             * Format: date-time
+             * @description Last modified time (ISO 8601)
+             */
+            mtime: string;
+            /** @description True if this file is a tracked resource in the Knowledge Base */
+            tracked: boolean;
+            /** @description Resource ID (only when tracked is true) */
+            resourceId?: string;
+            /** @description Entity types assigned to this resource (only when tracked is true) */
+            entityTypes?: string[];
+            /** @description Number of annotations on this resource (only when tracked is true) */
+            annotationCount?: number;
+            /** @description DID of the user who created the resource (only when tracked is true) */
+            creator?: string;
+        };
+        DirEntry: {
+            /** @enum {string} */
+            type: "dir";
+            /** @description Entry name (basename) */
+            name: string;
+            /** @description Path relative to project root */
+            path: string;
+            /**
+             * Format: date-time
+             * @description Last modified time (ISO 8601)
+             */
+            mtime: string;
+        };
+        BodyOperationAdd: {
+            /** @enum {string} */
+            op: "add";
+            item: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+        };
+        BodyOperationRemove: {
+            /** @enum {string} */
+            op: "remove";
+            item: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+        };
+        BodyOperationReplace: {
+            /** @enum {string} */
+            op: "replace";
+            oldItem: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+            newItem: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+        };
+        CloneResourceWithTokenResponse: {
+            /** @description Generated clone token */
+            token: string;
+            /** @description ISO 8601 timestamp when token expires */
+            expiresAt: string;
+            resource: components["schemas"]["ResourceDescriptor"];
+        };
+        /** @description Error response for failed bus commands. Replaces native Error objects on the EventBus so payloads are serializable and OpenAPI-typed. */
+        CommandError: {
+            /** @description Optional correlation id echoed from the originating command. When present, the failure event can be matched back to the specific command that failed. */
+            correlationId?: string;
+            /** @description Human-readable error message */
+            message: string;
+            /** @description Optional additional context (stack trace, field name, etc.) */
+            details?: string;
+        };
+        /**
+         * @description Content format as MIME type, optionally with charset parameter. Values include: text/plain, text/plain; charset=utf-8, text/plain; charset=iso-8859-1, text/markdown, text/markdown; charset=windows-1252, image/png, image/jpeg, application/pdf
+         * @example text/plain; charset=utf-8
+         */
+        ContentFormat: string;
+        ContextualSummaryResponse: {
+            summary: string;
+            relevantFields: {
+                [key: string]: unknown;
+            };
+            context: {
+                before?: string;
+                selected: string;
+                after?: string;
+            };
+        };
+        CreateAnnotationRequest: {
+            motivation: components["schemas"]["Motivation"];
+            target: {
+                source: string;
+                selector: components["schemas"]["TextPositionSelector"] | {
+                    /** @enum {string} */
+                    type: "TextQuoteSelector";
+                    exact: string;
+                    prefix?: string;
+                    suffix?: string;
+                } | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"] | (components["schemas"]["TextPositionSelector"] | {
+                    /** @enum {string} */
+                    type: "TextQuoteSelector";
+                    exact: string;
+                    prefix?: string;
+                    suffix?: string;
+                } | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"])[];
+            };
+            /** @description Optional body. Omit for annotations whose motivation alone is meaningful (highlighting) or whose user-supplied content is empty. Shape matches Annotation.body. */
+            body?: components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
+        };
+        /** @description Response body for POST /resources (202 Accepted). Resource creation is asynchronous — the backend writes content to disk, emits yield:create on the bus, and returns the newly-minted resourceId immediately. Consumers watch SSE domain events (yield:created) to observe the fully-persisted state. */
+        CreateResourceResponse: {
+            /** @description The id of the newly-created resource. Assigned by Stower when it persists yield:create. */
+            resourceId: string;
+        };
+        DeleteUserResponse: {
+            success: boolean;
+            message: string;
+        };
+        /** @description Progress payload emitted on gather:annotation-progress and gather:progress SSE channels during LLM context gathering. */
+        GatherProgress: {
+            message?: string;
+            percentage?: number;
+        };
+        /** @description Completion payload emitted on gather:annotation-finished SSE channel. */
+        GatherAnnotationFinished: {
+            correlationId: string;
+            annotationId: string;
+            response: components["schemas"]["AnnotationLLMContextResponse"];
+        };
+        /** @description Completion payload emitted on gather:finished SSE channel for resource-level context gathering. */
+        GatherFinished: {
+            correlationId: string;
+            resourceId: string;
+            response: components["schemas"]["ResourceLLMContextResponse"];
+        };
+        /** @description Search results payload emitted on match:search-results SSE channel. */
+        MatchSearchResult: {
+            correlationId: string;
+            referenceId: string;
+            response: (components["schemas"]["ResourceDescriptor"] & {
+                /** @description Relevance score */
+                score?: number;
+                /** @description Human-readable reason for the match */
+                matchReason?: string;
+            })[];
+        };
+        /** @description Error payload emitted on match:search-failed SSE channel. */
+        MatchSearchFailed: {
+            correlationId: string;
+            referenceId: string;
+            error: string;
+        };
+        /** @description Metadata added at persistence time. Part of every StoredEvent. Integrity is provided by git at the commit level (when gitSync is enabled), not by in-event metadata fields. */
+        EventMetadata: {
+            /** @description Monotonic position in the event log (ordering authority) */
+            sequenceNumber: number;
+            /** @description Byte offset in the JSONL file */
+            streamPosition: number;
+            /** @description Optional correlation id propagated from a command. Lets clients match command-result events back to the POST that initiated them. Set by EventStore.appendEvent's options when a route handler passes one through. */
+            correlationId?: string;
+        };
+        /** @description Selection data for user-initiated annotations. Captures the text range and optional selector information from a user's highlight in the UI. */
+        SelectionData: {
+            /** @description The exact selected text */
+            exact: string;
+            /** @description Start character offset */
+            start: number;
+            /** @description End character offset */
+            end: number;
+            /** @description SVG selector for non-text selections (e.g. PDF regions) */
+            svgSelector?: string;
+            /** @description Fragment selector (e.g. page=2) */
+            fragmentSelector?: string;
+            /** @description Specification the fragment selector conforms to */
+            conformsTo?: string;
+            /** @description Text before the selection (for disambiguation) */
+            prefix?: string;
+            /** @description Text after the selection (for disambiguation) */
+            suffix?: string;
+        };
+        /** @description A persisted domain event with metadata. Flat shape — event fields and metadata are peers. */
+        StoredEventResponse: {
+            /** @description Unique event ID (UUID) */
+            id: string;
+            /** @description Event type (flow verb name, e.g. mark:added) */
+            type: string;
+            /**
+             * Format: date-time
+             * @description When the event occurred
+             */
+            timestamp: string;
+            /** @description DID of the user who triggered the event */
+            userId: string;
+            /** @description Resource this event affects (absent for system events) */
+            resourceId?: string;
+            /** @description Event schema version */
+            version: number;
+            /** @description Event-type-specific payload */
+            payload: {
+                [key: string]: unknown;
+            };
+            metadata: components["schemas"]["EventMetadata"];
+        };
+        /** @description Wire format emitted by GET /resources/:id/events/stream. Extends StoredEventResponse with optional enrichment fields populated from the materialized view at SSE-write time. Subscribers can read the enrichment fields directly to update local caches without an additional fetch. */
+        EnrichedResourceEvent: components["schemas"]["StoredEventResponse"] & {
+            /** @description Populated for events that mutate an annotation (mark:added, mark:body-updated, mark:removed). Carries the post-materialization annotation as it exists in the view, so subscribers can update local caches in-place without refetching. Absent for events that don't touch annotations. */
+            annotation?: components["schemas"]["Annotation"];
+        };
+        /** @description Payload for yield:created domain event */
+        ResourceCreatedPayload: {
+            name: string;
+            format: components["schemas"]["ContentFormat"];
+            /** @description SHA-256 of content */
+            contentChecksum: string;
+            contentByteSize?: number;
+            entityTypes?: string[];
+            /** @description Working-tree URI (e.g. file://docs/overview.md) */
+            storageUri?: string;
+            language?: string;
+            isDraft?: boolean;
+            generatedFrom?: {
+                resourceId: string;
+                annotationId: string;
+            };
+            generationPrompt?: string;
+            generator?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
+        };
+        /** @description Payload for yield:cloned domain event */
+        ResourceClonedPayload: {
+            name: string;
+            format: components["schemas"]["ContentFormat"];
+            contentChecksum: string;
+            contentByteSize?: number;
+            parentResourceId: string;
+            entityTypes?: string[];
+            language?: string;
+        };
+        /** @description Payload for yield:updated domain event */
+        ResourceUpdatedPayload: {
+            /** @description SHA-256 of new content */
+            contentChecksum: string;
+            contentByteSize?: number;
+        };
+        /** @description Payload for yield:moved domain event */
+        ResourceMovedPayload: {
+            /** @description Previous file:// URI */
+            fromUri: string;
+            /** @description New file:// URI */
+            toUri: string;
+        };
+        /** @description Payload for mark:archived domain event */
+        ResourceArchivedPayload: {
+            reason?: string;
+        };
+        /** @description Payload for mark:unarchived domain event (empty payload) */
+        ResourceUnarchivedPayload: Record<string, never>;
+        /** @description Payload for yield:representation-added domain event */
+        RepresentationAddedPayload: {
+            representation: components["schemas"]["Representation"];
+        };
+        /** @description Payload for yield:representation-removed domain event */
+        RepresentationRemovedPayload: {
+            /** @description Checksum of the representation to remove */
+            checksum: string;
+        };
+        /** @description Payload for mark:added domain event */
+        AnnotationAddedPayload: {
+            annotation: components["schemas"]["Annotation"];
+            /** @description SHA-256 of resource content at annotation time */
+            contentChecksum?: string;
+        };
+        /** @description Payload for mark:removed domain event */
+        AnnotationRemovedPayload: {
+            annotationId: string;
+        };
+        /** @description Payload for mark:body-updated domain event */
+        AnnotationBodyUpdatedPayload: {
+            annotationId: string;
+            operations: (components["schemas"]["BodyOperationAdd"] | components["schemas"]["BodyOperationRemove"] | components["schemas"]["BodyOperationReplace"])[];
+        };
+        /** @description Payload for frame:entity-type-added domain event (system-level, no resourceId — fan-out is global) */
+        EntityTypeAddedPayload: {
+            entityType: string;
+        };
+        /** @description Payload for frame:tag-schema-added domain event (system-level, no resourceId — fan-out is global to the KB). */
+        TagSchemaAddedPayload: {
+            schema: components["schemas"]["TagSchema"];
+        };
+        /** @description Payload for mark:entity-tag-added and mark:entity-tag-removed domain events */
+        EntityTagChangedPayload: {
+            entityType: string;
+        };
+        /**
+         * @description Type of background job
+         * @enum {string}
+         */
+        JobType: "reference-annotation" | "generation" | "highlight-annotation" | "assessment-annotation" | "comment-annotation" | "tag-annotation";
+        /** @description Payload for job:started domain event */
+        JobStartedPayload: {
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job is attached to, when applicable */
+            annotationId?: string;
+            totalSteps?: number;
+        };
+        /** @description Payload for job:progress domain event */
+        JobProgressPayload: {
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            percentage: number;
+            /** @description Human-readable current step */
+            currentStep?: string;
+            processedSteps?: number;
+            totalSteps?: number;
+            /** @description For detection: entities found so far */
+            foundCount?: number;
+            message?: string;
+            /** @description Full progress object for extensibility */
+            progress?: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description Payload for job:completed domain event */
+        JobCompletedPayload: {
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job was attached to, when applicable */
+            annotationId?: string;
+            totalSteps?: number;
+            /** @description For detection: total entities found */
+            foundCount?: number;
+            /** @description For generation: ID of generated resource */
+            resultResourceId?: string;
+            /** @description For generation: URI of annotation that triggered generation */
+            annotationUri?: string;
+            message?: string;
+            /** @description Full result object for extensibility */
+            result?: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description Payload for job:failed domain event */
+        JobFailedPayload: {
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job was attached to, when applicable */
+            annotationId?: string;
+            error: string;
+            details?: string;
+        };
+        ErrorResponse: {
+            error: string;
+            code?: string;
+            details?: unknown;
+        };
+        EventStreamResponse: {
+            event: string;
+            data: string;
+            id?: string;
+        };
+        GetAnnotationHistoryResponse: {
+            events: components["schemas"]["StoredEventResponse"][];
+            total: number;
+            annotationId: string;
+            resourceId: string;
+        };
+        GetAnnotationResponse: {
+            annotation: components["schemas"]["Annotation"];
+            resource: components["schemas"]["ResourceDescriptor"] | null;
+            resolvedResource: components["schemas"]["ResourceDescriptor"] | null;
+        };
+        GetAnnotationsResponse: {
+            annotations: components["schemas"]["Annotation"][];
+            /** @description Total number of annotations */
+            total: number;
+            /** @description Motivation filter applied (if any) */
+            motivation?: components["schemas"]["Motivation"] | null;
+        };
+        GetEntityTypesResponse: {
+            entityTypes: string[];
+        };
+        GetEventsResponse: {
+            events: components["schemas"]["StoredEventResponse"][];
+            total: number;
+            resourceId: string;
+        };
+        GetReferencedByResponse: {
+            referencedBy: {
+                /** @description Reference annotation ID */
+                id: string;
+                /** @description Name of resource containing the reference */
+                resourceName: string;
+                target: {
+                    /** @description ID of resource containing the reference */
+                    source: string;
+                    selector: {
+                        /** @description The selected text that references this resource */
+                        exact: string;
+                    };
+                };
+            }[];
+        };
+        GetResourceByTokenResponse: {
+            sourceResource: components["schemas"]["ResourceDescriptor"];
+            /** @description ISO 8601 timestamp when token expires */
+            expiresAt: string;
+        };
+        GetResourceResponse: {
+            resource: components["schemas"]["ResourceDescriptor"];
+            /** @description All annotations for the resource (highlights, references, assessments, etc.) */
+            annotations: components["schemas"]["Annotation"][];
+            /** @description Annotations that reference this resource from other resources */
+            entityReferences: components["schemas"]["Annotation"][];
+        };
+        GetTagSchemasResponse: {
+            tagSchemas: components["schemas"]["TagSchema"][];
+        };
+        GoogleAuthRequest: {
+            access_token: string;
+        };
+        HealthResponse: {
+            status: string;
+            message: string;
+            version: string;
+            timestamp: string;
+            /** @enum {string} */
+            database: "connected" | "disconnected" | "unknown";
+            environment: string;
+        };
+        JobStatusResponse: {
+            jobId: string;
+            /** @enum {string} */
+            type: "reference-annotation" | "generation" | "highlight-annotation" | "assessment-annotation" | "comment-annotation" | "tag-annotation";
+            /** @enum {string} */
+            status: "pending" | "running" | "complete" | "failed" | "cancelled";
+            userId: string;
+            created: string;
+            startedAt?: string;
+            completedAt?: string;
+            error?: string;
+            progress?: unknown;
+            result?: unknown;
+        };
+        ListResourcesResponse: {
+            resources: components["schemas"]["ResourceDescriptor"][];
+            total: number;
+            offset: number;
+            limit: number;
+        };
+        PasswordAuthRequest: {
+            /**
+             * Format: email
+             * @description User email address
+             */
+            email: string;
+            /** @description User password (minimum 8 characters) */
+            password: string;
+        };
+        MCPGenerateResponse: {
+            refresh_token: string;
+        };
+        /**
+         * @description Semiont-supported W3C Web Annotation motivations - https://www.w3.org/TR/annotation-vocab/#motivation
+         * @enum {string}
+         */
+        Motivation: "assessing" | "commenting" | "highlighting" | "linking" | "tagging";
+        OAuthConfigResponse: {
+            providers: {
+                name: string;
+                isConfigured: boolean;
+                clientId: string;
+            }[];
+            allowedDomains: string[];
+        };
+        /** @description A specific, byte-addressable rendition of a resource (file/asset/variant). */
+        Representation: {
+            /**
+             * Format: uri
+             * @description Stable ID for this representation.
+             */
+            "@id"?: string;
+            /** @description Type(s), e.g., schema:MediaObject. */
+            "@type"?: string | string[];
+            /** @description MIME/media type (e.g., text/markdown, image/png). */
+            mediaType: string;
+            /** @description Working-tree URI identifying where the bytes live. Only file:// is supported (e.g. file://docs/overview.md). */
+            storageUri?: string;
+            filename?: string;
+            /** @description Size of the payload in bytes. */
+            byteSize?: number;
+            /** @description Integrity hash (e.g., sha256:abcd…). */
+            checksum?: string;
+            /** @description Compression/transfer encoding if applicable. */
+            encoding?: string;
+            /** @description IETF BCP 47 language tag (e.g., en, es-ES). */
+            language?: string;
+            /** @description Pixels (images/video). */
+            width?: number;
+            /** @description Pixels (images/video). */
+            height?: number;
+            /** @description Seconds (audio/video). */
+            duration?: number;
+            /** Format: date-time */
+            created?: string;
+            /** Format: date-time */
+            modified?: string;
+            /** @description Profile/shape the bytes conform to (e.g., a JSON profile or SVG profile). */
+            conformsTo?: string | string[];
+            tags?: string[];
+            /**
+             * @description Semantics of this rendition relative to the resource (e.g., original, thumbnail, preview, derived).
+             * @enum {string}
+             */
+            rel?: "original" | "thumbnail" | "preview" | "optimized" | "derived" | "other";
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Metadata about a resource (1:1 with its URI). JSON-LD subject is @id. Link to concrete bytes via representations. */
+        ResourceDescriptor: {
+            /** @description JSON-LD context; URI, object, or array of these. */
+            "@context": string | {
+                [key: string]: unknown;
+            } | (string | {
+                [key: string]: unknown;
+            })[];
+            /** @description Canonical URI/URN of the resource being described. */
+            "@id": string;
+            /** @description Type(s) of the resource (IRIs/CURIEs via @context). */
+            "@type"?: string | string[];
+            name: string;
+            description?: string;
+            /** @description Persistent identifiers (e.g., DOI, URN). */
+            identifier?: string | string[] | ({
+                /** Format: uri */
+                "@id"?: string;
+                value?: string;
+                scheme?: string;
+            } & {
+                [key: string]: unknown;
+            });
+            /** @description Topics (IRIs or strings). */
+            about?: string | string[];
+            /** @description Equivalent/authoritative references. */
+            sameAs?: string[];
+            isPartOf?: string[];
+            hasPart?: string[];
+            /** Format: uri */
+            license?: string;
+            version?: string;
+            /** Format: date-time */
+            dateCreated?: string;
+            /** Format: date-time */
+            dateModified?: string;
+            /** @description W3C PROV - source resources this was derived from */
+            wasDerivedFrom?: string | string[];
+            /** @description W3C PROV - agents responsible for this resource */
+            wasAttributedTo?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
+            /** @description Software agent that produced or processed this resource (W3C Web Annotation model) */
+            generator?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
+            /** @description Profile/shape URI this resource description conforms to. */
+            conformsTo?: string | string[];
+            /** @description Convenience set summarizing media types across representations. */
+            availableFormats?: string[];
+            /** @description Managed or referenced byte-level renditions of this resource. */
+            representations: components["schemas"]["Representation"] | components["schemas"]["Representation"][];
+            /** @description Application-specific: Whether this resource is archived */
+            archived?: boolean;
+            /** @description Application-specific: Entity types for this resource */
+            entityTypes?: string[];
+            /** @description Application-specific: Whether this resource is a draft */
+            isDraft?: boolean;
+            /** @description Application-specific: ID of annotation that triggered generation */
+            sourceAnnotationId?: string;
+            /** @description Application-specific: ID of source resource for clones/derivatives */
+            sourceResourceId?: string;
+            /**
+             * Format: uri
+             * @description Original URI from a source knowledge base when this resource was imported
+             */
+            originatedFrom?: string;
+            /** @description Working-tree URI for this resource (e.g. file://docs/overview.md). Stable across updates and moves. */
+            storageUri?: string;
+            /** @description SHA-256 hex hash of the current content. Updated on resource.created, resource.updated, resource.cloned events. */
+            currentChecksum?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        SemanticMatch: {
+            /** @description The chunk text that matched */
+            text: string;
+            /** @description Source resource ID */
+            resourceId: string;
+            /** @description Source annotation ID, if the match is from an annotation */
+            annotationId?: string;
+            /** @description Cosine similarity score (0-1) */
+            score: number;
+            /** @description Entity types on the matched passage */
+            entityTypes?: string[];
+        };
+        ResourceLLMContextResponse: {
+            mainResource: components["schemas"]["ResourceDescriptor"];
+            relatedResources: components["schemas"]["ResourceDescriptor"][];
+            annotations: components["schemas"]["Annotation"][];
+            graph: {
+                nodes: {
+                    id: string;
+                    type: string;
+                    label: string;
+                    metadata: {
+                        [key: string]: unknown;
+                    };
+                }[];
+                edges: {
+                    source: string;
+                    target: string;
+                    type: string;
+                    metadata: {
+                        [key: string]: unknown;
+                    };
+                }[];
+            };
+            summary?: string;
+            suggestedReferences?: string[];
+            /** @description The content of the main resource (included if includeContent=true) */
+            mainResourceContent?: string;
+            /** @description Map of resource IDs to their content (included if includeContent=true) */
+            relatedResourcesContent?: {
+                [key: string]: string;
+            };
+        };
+        SpecificResource: {
+            /** @enum {string} */
+            type: "SpecificResource";
+            /** @description IRI of the target resource */
+            source: string;
+            /** @description Why this body is included */
+            purpose?: components["schemas"]["BodyPurpose"];
+        };
+        StatusResponse: {
+            status: string;
+            version: string;
+            features: {
+                semanticContent: string;
+                collaboration: string;
+                rbac: string;
+            };
+            message: string;
+            authenticatedAs?: string;
+            /** @description Name of the knowledge base project */
+            projectName?: string;
+            /** @description Current git branch of the knowledge base repository */
+            gitBranch?: string;
+        };
+        TextPositionSelector: {
+            /** @enum {string} */
+            type: "TextPositionSelector";
+            /** @description Character offset from resource start */
+            start: number;
+            /** @description Character offset from resource start */
+            end: number;
+        };
+        TextQuoteSelector: {
+            /** @enum {string} */
+            type: "TextQuoteSelector";
+            exact: string;
+            prefix?: string;
+            suffix?: string;
+        };
+        TextualBody: {
+            /** @enum {string} */
+            type: "TextualBody";
+            /** @description The text content (e.g., entity type name) */
+            value: string;
+            /** @description Why this body is included */
+            purpose?: components["schemas"]["BodyPurpose"];
+            /** @description MIME type (defaults to text/plain) */
+            format?: string;
+            /** @description BCP 47 language tag */
+            language?: string;
+        };
+        TokenRefreshRequest: {
+            /**
+             * @description Refresh token obtained during login
+             * @example eyJhbGciOiJIUzI1NiIs...
+             */
+            refreshToken: string;
+        };
+        TokenRefreshResponse: {
+            access_token: string;
+        };
+        UpdateAnnotationBodyRequest: {
+            /** @description Resource ID containing the annotation (required for O(1) Layer 3 lookup) */
+            resourceId: string;
+            /** @description Array of body modification operations to apply */
+            operations: (components["schemas"]["BodyOperationAdd"] | components["schemas"]["BodyOperationRemove"] | components["schemas"]["BodyOperationReplace"])[];
+        };
+        UpdateUserRequest: {
+            isAdmin?: boolean;
+            isActive?: boolean;
+            name?: string;
+        };
+        UpdateUserResponse: {
+            success: boolean;
+            user: {
+                id: string;
+                email: string;
+                name?: string | null;
+                image?: string | null;
+                domain: string;
+                provider: string;
+                isAdmin: boolean;
+                isActive: boolean;
+                lastLogin?: string | null;
+                created: string;
+                updatedAt: string;
+            };
+        };
+        UserResponse: {
+            id: string;
+            email: string;
+            name: string | null;
+            image: string | null;
+            domain: string;
+            provider: string;
+            isAdmin: boolean;
+            isModerator: boolean;
+            isActive: boolean;
+            termsAcceptedAt: string | null;
+            lastLogin: string | null;
+            created: string;
+            /** @description The validated JWT token string for the current session */
+            token: string;
+        };
+        /** @description Emitted when an annotation receives focus for beckoning */
+        BeckonFocusEvent: {
+            annotationId?: string;
+            resourceId?: string;
+        };
+        /** @description Emitted when an annotation is hovered over for beckoning */
+        BeckonHoverEvent: {
+            annotationId: string | null;
+        };
+        /** @description Emitted when a sparkle effect is triggered on an annotation */
+        BeckonSparkleEvent: {
+            annotationId: string;
+        };
+        /** @description Success result emitted on the bind:body-updated bus channel after bind:update-body has been applied. */
+        BindBodyUpdated: {
+            /** @description Correlation ID echoed from the originating bind:update-body command */
+            correlationId: string;
+            /** @description Branded AnnotationId of the annotation whose body was updated */
+            annotationId: string;
+        };
+        /** @description Command payload sent on the bind:initiate bus channel to start a bind flow. */
+        BindInitiateCommand: {
+            /** @description Branded AnnotationId of the annotation being bound */
+            annotationId: string;
+            /** @description Branded ResourceId of the resource being bound to */
+            resourceId: string;
+            /** @description Default title for the bound annotation */
+            defaultTitle: string;
+            /** @description Entity types to associate with the annotation */
+            entityTypes: string[];
+        };
+        /** @description Command payload sent on the bind:update-body bus channel to modify annotation bodies. */
+        BindUpdateBodyCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            /** @description Client-supplied id used to match this command to its result event(s) on the events-stream. Generated by the route handler if absent. */
+            correlationId: string;
+            /** @description Branded AnnotationId of the annotation whose body is being updated */
+            annotationId: string;
+            /** @description Branded ResourceId of the resource the annotation belongs to */
+            resourceId: string;
+            /** @description List of body mutation operations to apply */
+            operations: {
+                /**
+                 * @description The type of body operation
+                 * @enum {string}
+                 */
+                op: "add" | "remove" | "replace";
+                /** @description Body item for add operations */
+                item?: components["schemas"]["AnnotationBody"];
+                /** @description Previous body item for replace operations */
+                oldItem?: components["schemas"]["AnnotationBody"];
+                /** @description Replacement body item for replace operations */
+                newItem?: components["schemas"]["AnnotationBody"];
+            }[];
+        };
+        /**
+         * @description W3C Web Annotation body purpose vocabulary - https://www.w3.org/TR/annotation-vocab/#motivation
+         * @enum {string}
+         */
+        BodyPurpose: "assessing" | "bookmarking" | "classifying" | "commenting" | "describing" | "editing" | "highlighting" | "identifying" | "linking" | "moderating" | "questioning" | "replying" | "tagging";
+        /** @description Request to browse the history of an annotation */
+        BrowseAnnotationHistoryRequest: {
+            correlationId: string;
+            resourceId: string;
+            annotationId: string;
+        };
+        /** @description Result of browsing annotation history */
+        BrowseAnnotationHistoryResult: {
+            correlationId: string;
+            response: components["schemas"]["GetAnnotationHistoryResponse"];
+        };
+        /** @description Request to browse a single annotation */
+        BrowseAnnotationRequest: {
+            correlationId: string;
+            resourceId: string;
+            annotationId: string;
+        };
+        /** @description Result of browsing a single annotation */
+        BrowseAnnotationResult: {
+            correlationId: string;
+            response: components["schemas"]["GetAnnotationResponse"];
+        };
+        /** @description Request to get contextual text around an annotation */
+        BrowseAnnotationContextRequest: {
+            correlationId: string;
+            annotationId: string;
+            resourceId: string;
+            contextBefore?: number;
+            contextAfter?: number;
+        };
+        /** @description Request to browse annotations for a resource */
+        BrowseAnnotationsRequest: {
+            correlationId: string;
+            resourceId: string;
+        };
+        /** @description Result of browsing annotations for a resource */
+        BrowseAnnotationsResult: {
+            correlationId: string;
+            response: components["schemas"]["GetAnnotationsResponse"];
+        };
+        /** @description Emitted when an annotation is clicked in the browse panel */
+        BrowseClickEvent: {
+            annotationId: string;
+            motivation: components["schemas"]["Motivation"];
+        };
+        /** @description Request to browse a directory listing */
+        BrowseDirectoryRequest: {
+            correlationId: string;
+            path: string;
+            /** @enum {string} */
+            sort?: "name" | "mtime" | "annotationCount";
+        };
+        /** @description Result of browsing a directory listing */
+        BrowseDirectoryResult: {
+            correlationId: string;
+            response: {
+                path: string;
+                entries: components["schemas"]["DirectoryEntry"][];
+            };
+        };
+        /** @description Emitted when an entity type is clicked in the browse panel */
+        BrowseEntityTypeClickedEvent: {
+            entityType: string;
+        };
+        /** @description Request to browse available entity types */
+        BrowseEntityTypesRequest: {
+            correlationId: string;
+        };
+        /** @description Result of browsing entity types */
+        BrowseEntityTypesResult: {
+            correlationId: string;
+            response: components["schemas"]["GetEntityTypesResponse"];
+        };
+        /** @description Request to browse events for a resource */
+        BrowseEventsRequest: {
+            correlationId: string;
+            resourceId: string;
+            type?: string;
+            userId?: string;
+            limit?: number;
+        };
+        /** @description Result of browsing events for a resource */
+        BrowseEventsResult: {
+            correlationId: string;
+            response: components["schemas"]["GetEventsResponse"];
+        };
+        /** @description Emitted when navigation to an external URL is requested */
+        BrowseExternalNavigateEvent: {
+            url: string;
+            resourceId?: string;
+        };
+        /** @description Emitted when a link is clicked in the browse panel */
+        BrowseLinkClickedEvent: {
+            href: string;
+            label?: string;
+        };
+        /** @description Emitted when a browse panel is opened */
+        BrowsePanelOpenEvent: {
+            panel: string;
+            scrollToAnnotationId?: string;
+            motivation?: string;
+        };
+        /** @description Emitted when a browse panel is toggled */
+        BrowsePanelToggleEvent: {
+            panel: string;
+        };
+        /** @description Request to browse annotations that reference a resource */
+        BrowseReferencedByRequest: {
+            correlationId: string;
+            resourceId: string;
+            motivation?: string;
+        };
+        /** @description Result of browsing annotations that reference a resource */
+        BrowseReferencedByResult: {
+            correlationId: string;
+            response: components["schemas"]["GetReferencedByResponse"];
+        };
+        /** @description Emitted when navigation to a reference resource is requested */
+        BrowseReferenceNavigateEvent: {
+            resourceId: string;
+        };
+        /** @description Emitted when a resource is closed in the browse panel */
+        BrowseResourceCloseEvent: {
+            resourceId: string;
+        };
+        /** @description Emitted when resources are reordered in the browse panel */
+        BrowseResourceReorderEvent: {
+            oldIndex: number;
+            newIndex: number;
+        };
+        /** @description Request to browse a single resource */
+        BrowseResourceRequest: {
+            correlationId: string;
+            resourceId: string;
+        };
+        /** @description Result of browsing a single resource */
+        BrowseResourceResult: {
+            correlationId: string;
+            response: components["schemas"]["GetResourceResponse"];
+        };
+        /** @description Request to browse resources with optional filtering and pagination */
+        BrowseResourcesRequest: {
+            correlationId: string;
+            search?: string;
+            archived?: boolean;
+            entityType?: string;
+            offset?: number;
+            limit?: number;
+        };
+        /** @description Result of browsing resources */
+        BrowseResourcesResult: {
+            correlationId: string;
+            response: components["schemas"]["ListResourcesResponse"];
+        };
+        /** @description Emitted when the browse panel requests a router navigation */
+        BrowseRouterPushEvent: {
+            path: string;
+            reason?: string;
+        };
+        /** @description Request to browse registered tag schemas */
+        BrowseTagSchemasRequest: {
+            correlationId: string;
+        };
+        /** @description Result of browsing tag schemas */
+        BrowseTagSchemasResult: {
+            correlationId: string;
+            response: components["schemas"]["GetTagSchemasResponse"];
+        };
+        /** @description W3C Web Annotation FragmentSelector for media fragment identifiers (RFC 3778 for PDFs) */
+        FragmentSelector: {
+            /** @enum {string} */
+            type: "FragmentSelector";
+            /**
+             * @description Media fragment identifier (e.g., 'page=1&viewrect=100,200,50,30' for PDF)
+             * @example page=1&viewrect=100,200,50,30
+             */
+            value: string;
+            /**
+             * @description URI identifying the fragment syntax specification
+             * @example http://tools.ietf.org/rfc/rfc3778
+             */
+            conformsTo?: string;
+        };
+        /** @description Completion payload emitted on the gather:annotation-complete bus channel when annotation context gathering finishes. */
+        GatherAnnotationComplete: {
+            /** @description Client-generated correlation ID to thread the response back to the originating request */
+            correlationId: string;
+            /** @description Branded AnnotationId of the annotation whose context was gathered */
+            annotationId: string;
+            /** @description The gathered annotation context */
+            response: components["schemas"]["AnnotationLLMContextResponse"];
+        };
+        /** @description Request payload sent on the gather:requested bus channel to gather context for an annotation. */
+        GatherAnnotationRequest: {
+            /** @description Client-generated correlation ID to thread the response back to the originating request */
+            correlationId: string;
+            /** @description Branded AnnotationId of the annotation to gather context for */
+            annotationId: string;
+            /** @description Branded ResourceId of the resource the annotation belongs to */
+            resourceId: string;
+            /** @description Optional gathering configuration */
+            options?: {
+                /** @description Whether to include source context in the gathered result */
+                includeSourceContext?: boolean;
+                /** @description Whether to include target context in the gathered result */
+                includeTargetContext?: boolean;
+                /** @description Characters of surrounding text context to include */
+                contextWindow?: number;
+            };
+        };
+        /** @description Context gathered for an annotation. Includes source document excerpts, metadata, and graph-derived context. Used by both Find (bind) and Generate (yield) flows. */
+        GatheredContext: {
+            /** @description The annotation this context was gathered for */
+            annotation: components["schemas"]["Annotation"];
+            /** @description The resource containing the annotation */
+            sourceResource: components["schemas"]["ResourceDescriptor"];
+            /** @description Text context from the source document */
+            sourceContext?: {
+                /** @description Text appearing before the selected passage */
+                before?: string;
+                /** @description The selected text passage (the annotation target) */
+                selected: string;
+                /** @description Text appearing after the selected passage */
+                after?: string;
+            };
+            /** @description Context metadata about the annotation and its source */
+            metadata?: {
+                /** @description Type of source resource (e.g., 'document', 'image', 'video') */
+                resourceType?: string;
+                /** @description BCP 47 language tag of source content */
+                language?: string;
+                /** @description Entity types associated with the annotation */
+                entityTypes?: string[];
+            };
+            /** @description User-provided textual hint to supplement or replace the selected text for search and generation */
+            userHint?: string;
+            /** @description Graph-derived context from the knowledge base */
+            graphContext?: {
+                /** @description Resources connected to the source resource via annotations */
+                connections?: {
+                    /** @description ID of the connected resource */
+                    resourceId: string;
+                    /** @description Name of the connected resource */
+                    resourceName: string;
+                    /** @description Entity types on the connected resource */
+                    entityTypes?: string[];
+                    /** @description Whether the connection goes both ways */
+                    bidirectional: boolean;
+                }[];
+                /** @description Number of other resources that reference the source resource */
+                citedByCount?: number;
+                /** @description Resources that reference the source resource */
+                citedBy?: {
+                    resourceId: string;
+                    resourceName: string;
+                }[];
+                /** @description Entity types from other annotations on the same resource */
+                siblingEntityTypes?: string[];
+                /** @description Global frequency counts for entity types (for IDF-like weighting) */
+                entityTypeFrequencies?: {
+                    [key: string]: number;
+                };
+                /** @description LLM-generated summary of the annotation's relationships in the knowledge graph */
+                inferredRelationshipSummary?: string;
+            };
+            /** @description Semantically similar passages from across the knowledge base, found via vector search */
+            semanticContext?: {
+                /** @description Passages ranked by cosine similarity to the focal text */
+                similar: components["schemas"]["SemanticMatch"][];
+            };
+        };
+        /** @description Completion payload emitted on the gather:resource-complete bus channel when resource context gathering finishes. */
+        GatherResourceComplete: {
+            /** @description Client-generated correlation ID to thread the response back to the originating request */
+            correlationId: string;
+            /** @description Branded ResourceId of the resource whose context was gathered */
+            resourceId: string;
+            /** @description The gathered resource context */
+            response: components["schemas"]["ResourceLLMContextResponse"];
+        };
+        /** @description Request payload sent on the gather:resource-requested bus channel to gather context for a resource. */
+        GatherResourceRequest: {
+            /** @description Client-generated correlation ID to thread the response back to the originating request */
+            correlationId: string;
+            /** @description Branded ResourceId of the resource to gather context for */
+            resourceId: string;
+            /** @description Gathering configuration */
+            options: {
+                /** @description Depth of resource graph traversal */
+                depth: number;
+                /** @description Maximum number of related resources to include */
+                maxResources: number;
+                /** @description Whether to include resource content in the gathered result */
+                includeContent: boolean;
+                /** @description Whether to include resource summaries in the gathered result */
+                includeSummary: boolean;
+            };
+        };
+        /** @description Request to generate an AI summary of an annotation */
+        GatherSummaryRequest: {
+            correlationId: string;
+            annotationId: string;
+            resourceId: string;
+        };
+        /** @description Result of a completed assessment-annotation job. */
+        JobAssessmentAnnotationResult: {
+            assessmentsFound: number;
+            assessmentsCreated: number;
+        };
+        /** @description Request to cancel a job */
+        JobCancelRequest: {
+            /** @enum {string} */
+            jobType: "annotation" | "generation";
+        };
+        /** @description Command to claim a pending job (atomic CAS: pending → running) */
+        JobClaimCommand: {
+            correlationId: string;
+            jobId: string;
+        };
+        /** @description Command to create a new job via the event bus */
+        JobCreateCommand: {
+            correlationId: string;
+            /** @enum {string} */
+            jobType: "reference-annotation" | "highlight-annotation" | "assessment-annotation" | "comment-annotation" | "tag-annotation" | "generation";
+            resourceId: string;
+            params: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description Result of a job:create command */
+        JobCreatedResult: {
+            correlationId: string;
+            response: {
+                jobId: string;
+            };
+        };
+        /** @description Result of a completed comment-annotation job. */
+        JobCommentAnnotationResult: {
+            commentsFound: number;
+            commentsCreated: number;
+        };
+        /** @description Command to mark a job as complete */
+        JobCompleteCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job is attached to, when applicable. Lets the UI route completion feedback (toast, resolve state) to a specific annotation. */
+            annotationId?: string;
+            result?: components["schemas"]["JobResult"];
+        };
+        /** @description Command to mark a job as failed */
+        JobFailCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job is attached to, when applicable. Lets the UI route failure feedback (error toast, revert state) to a specific annotation. */
+            annotationId?: string;
+            error: string;
+        };
+        /** @description Result of a completed generation job. resourceId is assigned by Stower when yield:create is processed; the worker emits job:complete with only resourceName, and Stower populates resourceId on the persisted payload. */
+        JobGenerationResult: {
+            /** @description ID of the generated resource (populated by Stower, not by the worker) */
+            resourceId?: string;
+            /** @description Name of the generated resource */
+            resourceName: string;
+        };
+        /** @description Result of a completed highlight-annotation job. */
+        JobHighlightAnnotationResult: {
+            highlightsFound: number;
+            highlightsCreated: number;
+        };
+        /** @description Progress report from a running job. Common fields are stage/percentage/message; job-type-specific fields may also be present. This is the single progress shape for every job type — annotation workers and generation alike. */
+        JobProgress: {
+            /** @description Current processing stage (e.g. 'analyzing', 'creating', 'complete', 'error') */
+            stage: string;
+            /** @description Completion percentage (0-100) */
+            percentage: number;
+            /** @description Human-readable progress message */
+            message: string;
+            /** @description Annotation this job is attached to, when applicable. Echoed inside JobProgress (in addition to the outer command envelope) so consumers that only see the inner progress object (e.g. client.yield.fromAnnotation's Observable) can still route visual feedback to a specific annotation. */
+            annotationId?: string;
+            /** @description Total entity types to process (reference-annotation) */
+            totalEntityTypes?: number;
+            /** @description Entity types processed so far (reference-annotation) */
+            processedEntityTypes?: number;
+            /** @description Entities found so far (reference-annotation) */
+            entitiesFound?: number;
+            /** @description Annotations emitted so far (reference-annotation) */
+            entitiesEmitted?: number;
+            /** @description Entity type currently being processed */
+            currentEntityType?: string;
+            /** @description Reference annotation: completed entity types with per-type counts, for UI progress display */
+            completedEntityTypes?: {
+                entityType: string;
+                foundCount: number;
+            }[];
+            /** @description Categories processed (tag-annotation) */
+            processedCategories?: number;
+            /** @description Total categories (tag-annotation) */
+            totalCategories?: number;
+            /** @description Category currently being processed (tag-annotation) */
+            currentCategory?: string;
+            /** @description Echoed job parameters for display in the progress UI (e.g. entity types or categories the user asked to detect) */
+            requestParams?: {
+                label: string;
+                value: string;
+            }[];
+        };
+        /** @description Event indicating a job has been queued */
+        JobQueuedEvent: {
+            jobId: string;
+            jobType: string;
+            resourceId: string;
+            /** @description DID of the user who initiated the job (audit). */
+            userId: string;
+        };
+        /** @description Result of a completed reference-annotation job. */
+        JobReferenceAnnotationResult: {
+            /** @description Total entities found */
+            totalFound: number;
+            /** @description Total annotations emitted */
+            totalEmitted: number;
+            /** @description Number of errors encountered */
+            errors: number;
+        };
+        /** @description Command to report progress on a job */
+        JobReportProgressCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job is attached to, when applicable. Lets the UI attach progress visuals to a specific annotation (e.g. a reference whose generation is running). */
+            annotationId?: string;
+            percentage: number;
+            progress?: components["schemas"]["JobProgress"];
+        };
+        /** @description Discriminated union of all job result types. */
+        JobResult: components["schemas"]["JobGenerationResult"] | components["schemas"]["JobReferenceAnnotationResult"] | components["schemas"]["JobHighlightAnnotationResult"] | components["schemas"]["JobAssessmentAnnotationResult"] | components["schemas"]["JobCommentAnnotationResult"] | components["schemas"]["JobTagAnnotationResult"];
+        /** @description Command to start a job */
+        JobStartCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job is attached to, when applicable. Set for annotation-scoped jobs like generation (from a specific reference). Unset for resource-scoped jobs like bulk reference/tag/highlight detection. */
+            annotationId?: string;
+        };
+        /** @description Request to check the status of a job */
+        JobStatusRequest: {
+            correlationId: string;
+            jobId: string;
+        };
+        /** @description Result of a job status request */
+        JobStatusResult: {
+            correlationId: string;
+            response: components["schemas"]["JobStatusResponse"];
+        };
+        /** @description Result of a completed tag-annotation job. */
+        JobTagAnnotationResult: {
+            tagsFound: number;
+            tagsCreated: number;
+            /** @description Count of tags created per category */
+            byCategory: {
+                [key: string]: number;
+            };
+        };
+        /** @description Bus command to add a new entity type to the KB's vocabulary. Carried on the `frame:add-entity-type` channel — Frame is the schema-layer flow that owns vocabulary writes. */
+        FrameAddEntityTypeCommand: {
+            tag: string;
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+        };
+        /** @description Bus command to register a tag schema with the KB's runtime registry. Carried on the `frame:add-tag-schema` channel — Frame is the schema-layer flow that owns vocabulary writes. Most-recent registration of a given `schema.id` wins; the projection reflects the latest content. Identical re-registrations are silent; differing content overwrites and logs a warning. */
+        FrameAddTagSchemaCommand: {
+            schema: components["schemas"]["TagSchema"];
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+        };
+        /** @description Bus command to archive a resource and optionally remove its file. */
+        MarkArchiveCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            storageUri?: string;
+            keepFile?: boolean;
+            noGit?: boolean;
+        };
+        /** @description Emitted when the user requests AI assistance for a mark */
+        MarkAssistRequestEvent: {
+            /** @description Client-supplied id used to match this command to its result event(s) on the events-stream. Generated by the route handler if absent. */
+            correlationId?: string;
+            motivation: components["schemas"]["Motivation"];
+            options: {
+                instructions?: string;
+                /** @enum {string} */
+                tone?: "scholarly" | "explanatory" | "conversational" | "technical" | "analytical" | "critical" | "balanced" | "constructive";
+                density?: number;
+                language?: string;
+                entityTypes?: string[];
+                includeDescriptiveReferences?: boolean;
+                schemaId?: string;
+                categories?: string[];
+            };
+        };
+        /** @description Emitted when the mark click action changes */
+        MarkClickChangedEvent: {
+            action: string;
+        };
+        /** @description Bus command to create an annotation on a resource. */
+        MarkCreateCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            /** @description Optional correlation id threaded from the originating mark:create-request. Propagated into event metadata by Stower so annotation-assembly can emit mark:create-ok after persistence completes. */
+            correlationId?: string;
+            annotation: components["schemas"]["Annotation"];
+            resourceId: string;
+        };
+        /** @description Success response after creating an annotation. */
+        MarkCreateOk: {
+            annotationId: string;
+        };
+        /** @description Raw annotation creation intent — bus handler assembles the W3C annotation */
+        MarkCreateRequest: {
+            correlationId: string;
+            resourceId: string;
+            request: components["schemas"]["CreateAnnotationRequest"];
+        };
+        /** @description Bus command to delete an annotation. */
+        MarkDeleteCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            annotationId: string;
+            resourceId?: string;
+        };
+        /** @description Success response after deleting an annotation. */
+        MarkDeleteOk: {
+            annotationId: string;
+        };
+        /** @description Emitted when the user requests a new mark (annotation) on a resource */
+        MarkRequestedEvent: {
+            /** @description One or more W3C selectors */
+            selector: components["schemas"]["TextPositionSelector"] | components["schemas"]["TextQuoteSelector"] | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"] | (components["schemas"]["TextPositionSelector"] | components["schemas"]["TextQuoteSelector"] | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"])[];
+            motivation: components["schemas"]["Motivation"];
+        };
+        /** @description Emitted when the active mark selection changes */
+        MarkSelectionChangedEvent: {
+            motivation: string | null;
+        };
+        /** @description Emitted when the mark shape changes */
+        MarkShapeChangedEvent: {
+            shape: string;
+        };
+        /** @description Emitted when a mark is submitted with its annotation body */
+        MarkSubmitEvent: {
+            motivation: components["schemas"]["Motivation"];
+            /** @description One or more W3C selectors */
+            selector: components["schemas"]["TextPositionSelector"] | components["schemas"]["TextQuoteSelector"] | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"] | (components["schemas"]["TextPositionSelector"] | components["schemas"]["TextQuoteSelector"] | components["schemas"]["SvgSelector"] | components["schemas"]["FragmentSelector"])[];
+            /** @description Optional body. Omit for annotations whose motivation alone is meaningful (e.g. highlighting) or whose user-supplied content is empty (e.g. an assessing annotation saved without comment text). Shape matches Annotation.body. */
+            body?: components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
+        };
+        /** @description Bus command to unarchive a previously archived resource. */
+        MarkUnarchiveCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            storageUri?: string;
+        };
+        /** @description Bus command to update an annotation's body with patch operations. */
+        MarkUpdateBodyCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            /** @description Correlation id threaded from the originating route through to event metadata. Lets the events-stream deliver matched results to the client that initiated the bind. */
+            correlationId?: string;
+            annotationId: string;
+            resourceId: string;
+            operations: (components["schemas"]["BodyOperationAdd"] | components["schemas"]["BodyOperationRemove"] | components["schemas"]["BodyOperationReplace"])[];
+        };
+        /** @description Bus command to replace the entity types on a resource. */
+        MarkUpdateEntityTypesCommand: {
+            resourceId: string;
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            currentEntityTypes: string[];
+            updatedEntityTypes: string[];
+        };
+        /** @description Request payload sent on the match:search-request bus channel to find candidate matches. */
+        MatchSearchRequest: {
+            /** @description Client-generated correlation ID to thread the response back to the originating request */
+            correlationId: string;
+            /** @description Resource ID the reference annotation belongs to. Used to scope result events on the EventBus so the events-stream delivers them to participants viewing this resource. */
+            resourceId: string;
+            /** @description Annotation ID of the reference to search candidates for */
+            referenceId: string;
+            /** @description Gathered context for the reference annotation */
+            context: components["schemas"]["GatheredContext"];
+            /** @description Maximum number of candidate results to return */
+            limit?: number;
+            /** @description Enable semantic similarity scoring in addition to keyword matching */
+            useSemanticScoring?: boolean;
+        };
+        MediaTokenRequest: {
+            /** @description The resource ID to generate a media token for */
+            resourceId: string;
+        };
+        MediaTokenResponse: {
+            /** @description Short-lived media token for use as ?token= query parameter on resource URLs */
+            token: string;
+        };
+        /** @description Emitted when the hover delay setting changes */
+        SettingsHoverDelayChangedEvent: {
+            hoverDelayMs: number;
+        };
+        /** @description Emitted when the UI locale setting changes */
+        SettingsLocaleChangedEvent: {
+            locale: string;
+        };
+        /** @description Emitted when the UI theme setting changes */
+        SettingsThemeChangedEvent: {
+            /** @enum {string} */
+            theme: "light" | "dark" | "system";
+        };
+        SvgSelector: {
+            /** @enum {string} */
+            type: "SvgSelector";
+            /** @description SVG markup defining the region (must include xmlns attribute) */
+            value: string;
+        };
+        /** @description A single category within a tag schema (e.g. 'Issue' in IRAC, 'distinguished' in legal-citation-treatment). Each category carries methodology-bound semantics: a name, a description, and examples used in the LLM prompt. */
+        TagCategory: {
+            name: string;
+            description: string;
+            examples: string[];
+        };
+        /** @description A structural-analysis schema (e.g. legal-irac, scientific-imrad, argument-toulmin). Defines a methodology framework as an id, name, description, domain hint, and an ordered list of categories. KBs and their skills register schemas with the runtime registry via `frame.addTagSchema(...)` at session start. */
+        TagSchema: {
+            id: string;
+            name: string;
+            description: string;
+            /** @description Free-form domain hint (e.g. 'legal', 'scientific', 'general'). Used in the LLM prompt to tune the model's analysis voice. KB authors choose. */
+            domain: string;
+            tags: components["schemas"]["TagCategory"][];
+        };
+        /** @description Bus command to create a cloned resource from a clone token. */
+        YieldCloneCreateCommand: {
+            correlationId: string;
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            token: string;
+            name: string;
+            content: string;
+            archiveOriginal?: boolean;
+        };
+        /** @description Success response after creating a cloned resource. */
+        YieldCloneCreated: {
+            correlationId: string;
+            response: {
+                resourceId?: string;
+            };
+        };
+        /** @description Bus command to request cloning a resource using a clone token. */
+        YieldCloneResourceRequest: {
+            correlationId: string;
+            token: string;
+        };
+        /** @description Bus command to request a clone token for a resource. */
+        YieldCloneTokenRequest: {
+            correlationId: string;
+            resourceId: string;
+        };
+        /** @description Bus command to create a yielded resource in the knowledge base. */
+        YieldCreateCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            name: string;
+            storageUri: string;
+            contentChecksum: string;
+            byteSize: number;
+            format: components["schemas"]["ContentFormat"];
+            language?: string;
+            entityTypes?: string[];
+            isDraft?: boolean;
+            generatedFrom?: {
+                resourceId?: string;
+                annotationId?: string;
+            };
+            generationPrompt?: string;
+            generator?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
+            noGit?: boolean;
+        };
+        /** @description Success response after creating a yielded resource. */
+        YieldCreateOk: {
+            resourceId: string;
+            resource: components["schemas"]["ResourceDescriptor"];
+        };
+        /** @description Success response after moving a yielded resource. */
+        YieldMoveOk: {
+            resourceId: string;
+        };
+        /** @description Bus command to move (rename) a yielded resource. */
+        YieldMvCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            fromUri: string;
+            toUri: string;
+            noGit?: boolean;
+        };
+        /** @description Bus command to update a yielded resource's storage content. */
+        YieldUpdateCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            storageUri: string;
+            contentChecksum: string;
+            byteSize: number;
+            noGit?: boolean;
+        };
+        /** @description Success response after updating a yielded resource. */
+        YieldUpdateOk: {
+            resourceId: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;
+//# sourceMappingURL=types.d.ts.map