@semiont/api-client 0.1.0-build.6

package/dist/types.d.ts

@@ -0,0 +1,3177 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+    "/resources/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Resource by URI (W3C Content Negotiation)
+         * @description W3C-compliant globally resolvable resource URI with content negotiation. Returns JSON-LD metadata (Accept: application/ld+json), raw representation (Accept: text/plain, text/markdown, etc.), or redirects to frontend (?view=semiont). Requires authentication.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Optional view parameter. If set to 'semiont', redirects to frontend viewer. */
+                    view?: "semiont";
+                };
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Resource metadata (JSON-LD) or raw representation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/ld+json": components["schemas"]["GetResourceResponse"];
+                        "text/plain": string;
+                        "text/markdown": string;
+                    };
+                };
+                /** @description Redirect to frontend viewer (when ?view=semiont) */
+                302: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Update Resource
+         * @description Update resource metadata (append-only operations - name and content are immutable)
+         */
+        patch: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["UpdateResourceRequest"];
+                };
+            };
+            responses: {
+                /** @description Resource updated successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetResourceResponse"];
+                    };
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        trace?: never;
+    };
+    "/annotations/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Annotation by URI (W3C Content Negotiation)
+         * @description W3C-compliant globally resolvable annotation URI with content negotiation. Returns JSON-LD for API clients (Accept: application/ld+json or application/json). Redirects to frontend for browsers (Accept: text/html or browser User-Agent). Requires authentication and resourceId query parameter.
+         */
+        get: {
+            parameters: {
+                query: {
+                    /** @description Resource ID or URI containing the annotation */
+                    resourceId: string;
+                };
+                header?: never;
+                path: {
+                    /** @description Annotation ID */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Annotation representation (JSON-LD) */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/ld+json": components["schemas"]["GetAnnotationResponse"];
+                    };
+                };
+                /** @description Redirect to frontend (for browsers) */
+                302: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Missing resourceId parameter */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Annotation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/annotations/{id}/context": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Annotation Context
+         * @description Get the text context around an annotation with configurable before/after window
+         */
+        get: {
+            parameters: {
+                query: {
+                    /** @description Resource ID containing the annotation */
+                    resourceId: string;
+                    /** @description Number of characters before the selection */
+                    contextBefore?: number;
+                    /** @description Number of characters after the selection */
+                    contextAfter?: number;
+                };
+                header?: never;
+                path: {
+                    /** @description Annotation ID */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Annotation context */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AnnotationContextResponse"];
+                    };
+                };
+                /** @description Invalid query parameters */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Annotation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/annotations/{id}/summary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Annotation Summary
+         * @description Get an AI-generated summary of the annotation in context
+         */
+        get: {
+            parameters: {
+                query: {
+                    /** @description Resource ID containing the annotation */
+                    resourceId: string;
+                };
+                header?: never;
+                path: {
+                    /** @description Annotation ID */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description AI-generated annotation summary */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ContextualSummaryResponse"];
+                    };
+                };
+                /** @description Missing resourceId parameter */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Annotation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/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"]["GoogleAuthRequest"];
+                    };
+                };
+                /** @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/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;
+    };
+    "/resources": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List Resources
+         * @description List all resources with optional filters
+         */
+        get: {
+            parameters: {
+                query?: {
+                    offset?: number | null;
+                    limit?: number | null;
+                    entityType?: string;
+                    archived?: "true" | "false" | boolean;
+                    search?: string;
+                    /** @description Search query */
+                    q?: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Resources listed successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ListResourcesResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Create Resource
+         * @description Create a new resource
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "multipart/form-data": {
+                        /** @description Resource name */
+                        name: string;
+                        /**
+                         * Format: binary
+                         * @description Binary content of the resource
+                         */
+                        file: string;
+                        /** @description MIME type (e.g., text/markdown, image/png) */
+                        format: string;
+                        /** @description JSON-encoded array of entity types */
+                        entityTypes?: string;
+                        /** @description ISO 639-1 language code */
+                        language?: string;
+                        /** @description How the resource was created */
+                        creationMethod?: string;
+                        /** @description Source annotation ID (for generated resources) */
+                        sourceAnnotationId?: string;
+                        /** @description Source resource ID (for cloned resources) */
+                        sourceResourceId?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Resource created successfully */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CreateResourceResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/detect-annotations-stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Detect Annotations with Progress (SSE)
+         * @description Stream real-time entity detection progress via Server-Sent Events
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["GetEntityTypesResponse"];
+                };
+            };
+            responses: {
+                /** @description SSE stream opened successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/detect-highlights-stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Detect Highlights with Progress (SSE)
+         * @description Stream real-time highlight detection progress via Server-Sent Events
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["DetectHighlightsStreamRequest"];
+                };
+            };
+            responses: {
+                /** @description SSE stream opened successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/detect-assessments-stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Detect Assessments with Progress (SSE)
+         * @description Stream real-time assessment detection progress via Server-Sent Events
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["DetectAssessmentsStreamRequest"];
+                };
+            };
+            responses: {
+                /** @description SSE stream opened successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/detect-comments-stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Detect Comments with Progress (SSE)
+         * @description Stream real-time comment detection progress via Server-Sent Events
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["DetectCommentsStreamRequest"];
+                };
+            };
+            responses: {
+                /** @description SSE stream opened successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/detect-tags-stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Detect Tags with Progress (SSE)
+         * @description Stream real-time tag detection progress via Server-Sent Events. Identifies passages serving specific structural roles (IRAC, IMRAD, Toulmin frameworks).
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["DetectTagsStreamRequest"];
+                };
+            };
+            responses: {
+                /** @description SSE stream opened successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/llm-context": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Resource LLM Context
+         * @description Get resource with full context for LLM processing
+         */
+        get: {
+            parameters: {
+                query?: {
+                    depth?: number;
+                    maxResources?: number;
+                    includeContent?: "true" | "false" | boolean;
+                    includeSummary?: "true" | "false" | boolean;
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description LLM context */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ResourceLLMContextResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{resourceId}/annotations/{annotationId}/llm-context": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Annotation LLM Context
+         * @description Get annotation with full context for LLM processing
+         */
+        get: {
+            parameters: {
+                query?: {
+                    includeSourceContext?: "true" | "false" | boolean;
+                    includeTargetContext?: "true" | "false" | boolean;
+                    contextWindow?: number;
+                };
+                header?: never;
+                path: {
+                    resourceId: string;
+                    annotationId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Annotation LLM context */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AnnotationLLMContextResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/referenced-by": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Referenced By
+         * @description Get resources that reference this resource
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Filter incoming references by W3C motivation type (e.g., 'linking', 'commenting', 'highlighting') */
+                    motivation?: components["schemas"]["Motivation"];
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Resources that reference this resource */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetReferencedByResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/resources/token/{token}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Resource by Clone Token
+         * @description Retrieve a resource using a clone token
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    token: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Resource retrieved successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetResourceByTokenResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/resources/create-from-token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create Resource from Clone Token
+         * @description Create a new resource using a clone token
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["CreateResourceFromTokenRequest"];
+                };
+            };
+            responses: {
+                /** @description Resource created successfully */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CreateResourceResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/clone-with-token": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Clone Resource with Token
+         * @description Generate a temporary token for cloning a resource
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Clone token generated successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CloneResourceWithTokenResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/annotations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Resource Annotations
+         * @description Get all annotations (both highlights and references) in a resource
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Resource annotations */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CreateResourceResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Create Annotation
+         * @description Create a new annotation/reference in a resource
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["CreateAnnotationRequest"];
+                };
+            };
+            responses: {
+                /** @description Annotation created successfully */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CreateAnnotationResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Resource Event History
+         * @description Get full event history for a resource with optional filtering
+         */
+        get: {
+            parameters: {
+                query?: {
+                    type?: "resource.created" | "resource.cloned" | "resource.archived" | "resource.unarchived" | "annotation.added" | "annotation.removed" | "annotation.body.updated" | "entitytag.added" | "entitytag.removed" | "entitytype.added";
+                    userId?: string;
+                    limit?: number;
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Events retrieved successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetEventsResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/events/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Subscribe to Resource Events (SSE)
+         * @description Open a Server-Sent Events stream to receive real-time resource events
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description SSE stream opened successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{resourceId}/annotations/{annotationId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Annotation
+         * @description Get a specific annotation from a resource using nested path
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    resourceId: string;
+                    /** @description Annotation ID */
+                    annotationId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Annotation retrieved successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetAnnotationResponse"];
+                    };
+                };
+                /** @description Annotation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        /**
+         * Delete Annotation
+         * @description Delete an annotation from a resource
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    resourceId: string;
+                    /** @description Annotation ID */
+                    annotationId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Annotation deleted successfully */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Annotation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{resourceId}/annotations/{annotationId}/body": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Update Annotation Body
+         * @description Apply fine-grained operations to modify annotation body items (add, remove, or replace TextualBody and SpecificResource items)
+         */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    resourceId: string;
+                    /** @description Annotation ID */
+                    annotationId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["UpdateAnnotationBodyRequest"];
+                };
+            };
+            responses: {
+                /** @description Annotation body updated successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["UpdateAnnotationBodyResponse"];
+                    };
+                };
+            };
+        };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{resourceId}/annotations/{annotationId}/generate-resource-stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate Resource (SSE Stream)
+         * @description Stream real-time resource generation progress via Server-Sent Events
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    resourceId: string;
+                    /** @description Annotation ID */
+                    annotationId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["GenerateResourceStreamRequest"];
+                };
+            };
+            responses: {
+                /** @description SSE stream opened successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": components["schemas"]["EventStreamResponse"];
+                    };
+                };
+                /** @description Authentication required */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Annotation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{resourceId}/annotations/{annotationId}/history": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Annotation History
+         * @description Get full event history for a specific annotation (highlight or reference)
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    resourceId: string;
+                    annotationId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Annotation history retrieved successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetAnnotationHistoryResponse"];
+                    };
+                };
+                /** @description Annotation not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/entity-types": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Entity Types
+         * @description Get list of available entity types for references
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Entity types retrieved successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetEntityTypesResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Add Entity Type
+         * @description Add a new entity type to the collection (append-only, requires moderator/admin)
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["AddEntityTypeRequest"];
+                };
+            };
+            responses: {
+                /** @description Entity type added successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AddEntityTypeResponse"];
+                    };
+                };
+                /** @description Forbidden - Moderator or 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/entity-types/bulk": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Bulk Add Entity Types
+         * @description Add multiple entity types to the collection (append-only, requires moderator/admin)
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["BulkAddEntityTypesRequest"];
+                };
+            };
+            responses: {
+                /** @description Entity types added successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AddEntityTypeResponse"];
+                    };
+                };
+                /** @description Forbidden - Moderator or 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/jobs/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Job Status
+         * @description Get the current status and progress of an async job
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Job status retrieved successfully */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["JobStatusResponse"];
+                    };
+                };
+                /** @description Job not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        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;
+        };
+        AddEntityTypeRequest: {
+            tag: string;
+        };
+        AddEntityTypeResponse: {
+            success: boolean;
+            entityTypes: 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 Minimal Person/Organization for attribution (W3C PROV compatible) */
+        Agent: {
+            /**
+             * Format: uri
+             * @description Unique identifier for the agent
+             */
+            "@id"?: string;
+            /** @description Type(s) of agent (Person, Organization, Software) */
+            "@type"?: string | string[];
+            name: string;
+            nickname?: string;
+            email?: string;
+            email_sha1?: string;
+            homepage?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        Annotation: {
+            /**
+             * @description W3C Web Annotation JSON-LD context
+             * @default http://www.w3.org/ns/anno.jsonld
+             * @constant
+             */
+            "@context": "http://www.w3.org/ns/anno.jsonld";
+            /**
+             * @description W3C Annotation type
+             * @default Annotation
+             * @constant
+             */
+            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 - can be empty array, single body, or array of bodies */
+            body: components["schemas"]["AnnotationBody"][] | components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
+            creator?: components["schemas"]["Agent"];
+            created?: string;
+            modified?: string;
+            generator?: 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 Generation context for this annotation */
+            context?: components["schemas"]["GenerationContext"];
+            /** @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"]["TextPositionSelector"] | components["schemas"]["TextQuoteSelector"] | components["schemas"]["SvgSelector"])[];
+        };
+        AsyncJobResponse: {
+            jobId: string;
+            /** @enum {string} */
+            status: "pending" | "running" | "complete" | "failed" | "cancelled";
+            /** @enum {string} */
+            type: "detection" | "generation";
+            created: string;
+        };
+        AuthResponse: {
+            success: boolean;
+            user: {
+                id: string;
+                email: string;
+                name: string | null;
+                image: string | null;
+                domain: string;
+                isAdmin: boolean;
+            };
+            token: string;
+            isNewUser: boolean;
+        };
+        BodyOperationAdd: {
+            /** @constant */
+            op: "add";
+            item: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+        };
+        BodyOperationRemove: {
+            /** @constant */
+            op: "remove";
+            item: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+        };
+        BodyOperationReplace: {
+            /** @constant */
+            op: "replace";
+            oldItem: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+            newItem: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
+        };
+        /**
+         * @description Annotation body type - TextualBody for textual content, SpecificResource for resource links
+         * @enum {string}
+         */
+        BodyType: "TextualBody" | "SpecificResource";
+        BulkAddEntityTypesRequest: {
+            tags: string[];
+        };
+        CloneResourceWithTokenResponse: {
+            /** @description Generated clone token */
+            token: string;
+            /** @description ISO 8601 timestamp when token expires */
+            expiresAt: string;
+            resource: components["schemas"]["ResourceDescriptor"];
+        };
+        /**
+         * @description Content format as MIME type, optionally with charset parameter (e.g., 'text/plain', 'text/plain; charset=iso-8859-1')
+         * @example text/plain
+         * @example text/plain; charset=utf-8
+         * @example text/plain; charset=iso-8859-1
+         * @example text/markdown
+         * @example text/markdown; charset=windows-1252
+         * @example image/png
+         * @example image/jpeg
+         */
+        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"]["TextPositionSelector"] | {
+                    /** @enum {string} */
+                    type: "TextQuoteSelector";
+                    exact: string;
+                    prefix?: string;
+                    suffix?: string;
+                } | components["schemas"]["SvgSelector"])[];
+            };
+            body: unknown[] | components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
+        };
+        CreateAnnotationResponse: {
+            annotation: components["schemas"]["Annotation"];
+        };
+        CreateFromAnnotationRequest: {
+            /** @description ID of the resource containing the annotation */
+            resourceId: string;
+            name: string;
+            content: string;
+            format: components["schemas"]["ContentFormat"];
+        };
+        CreateFromAnnotationResponse: {
+            resource: components["schemas"]["ResourceDescriptor"];
+            annotations: components["schemas"]["Annotation"][];
+        };
+        CreateJobResponse: {
+            jobId: string;
+            /** @enum {string} */
+            type: "detection" | "generation";
+            /** @enum {string} */
+            status: "pending" | "running" | "complete" | "failed" | "cancelled";
+            created: string;
+            resourceId?: string;
+        };
+        CreateResourceFromAnnotationResponse: {
+            resource: components["schemas"]["ResourceDescriptor"];
+            annotation: components["schemas"]["Annotation"];
+        };
+        CreateResourceFromSelectionRequest: {
+            /** @description ID of the resource containing the annotation */
+            resourceId: string;
+            content: string;
+            name: string;
+            format: components["schemas"]["ContentFormat"];
+            entityTypes?: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
+            prompt?: string;
+            language?: string;
+        };
+        CreateResourceFromSelectionResponse: {
+            resource: components["schemas"]["ResourceDescriptor"];
+            annotation: components["schemas"]["Annotation"];
+        };
+        CreateResourceFromTokenRequest: {
+            /** @description Clone token */
+            token: string;
+            /** @description Name for the new resource */
+            name: string;
+            /** @description Content for the new resource */
+            content: string;
+            /** @description Whether to archive the original resource */
+            archiveOriginal?: boolean;
+        };
+        CreateResourceFromTokenResponse: {
+            resource: components["schemas"]["ResourceDescriptor"];
+            annotations: components["schemas"]["Annotation"][];
+        };
+        CreateResourceRequest: {
+            name: string;
+            content: string;
+            format: components["schemas"]["ContentFormat"];
+            entityTypes: string[];
+            language?: string;
+            creationMethod?: string;
+            sourceAnnotationId?: string;
+            sourceResourceId?: string;
+        };
+        CreateResourceResponse: {
+            resource: components["schemas"]["ResourceDescriptor"];
+            annotations: components["schemas"]["Annotation"][];
+        };
+        DeleteAnnotationRequest: {
+            /**
+             * Format: uri
+             * @description Resource URI containing the annotation (required for O(1) Layer 3 lookup)
+             */
+            resourceId: string;
+        };
+        DeleteUserResponse: {
+            success: boolean;
+            message: string;
+        };
+        DetectAnnotationsStreamRequest: {
+            /** @description Entity types to detect (e.g., 'Person', 'Organization', 'Location') */
+            entityTypes: string[];
+            /** @description Include anaphoric/cataphoric references (e.g., 'the CEO', 'the tech giant') in addition to direct mentions */
+            includeDescriptiveReferences?: boolean;
+        };
+        DetectHighlightsStreamRequest: {
+            /** @description Optional instructions to guide AI highlight detection */
+            instructions?: string;
+            /** @description Optional density: desired number of highlights per 2000 words of text (1-15) */
+            density?: number;
+        };
+        DetectAssessmentsStreamRequest: {
+            /** @description Optional instructions to guide AI assessment detection */
+            instructions?: string;
+            /**
+             * @description Optional tone/style for generated assessments
+             * @enum {string}
+             */
+            tone?: "analytical" | "critical" | "balanced" | "constructive";
+            /** @description Optional density: desired number of assessments per 2000 words of text (1-10) */
+            density?: number;
+        };
+        DetectCommentsStreamRequest: {
+            /** @description Optional instructions to guide AI comment detection */
+            instructions?: string;
+            /**
+             * @description Optional tone/style for generated comments
+             * @enum {string}
+             */
+            tone?: "scholarly" | "explanatory" | "conversational" | "technical";
+            /** @description Optional density: desired number of comments per 2000 words of text (2-12) */
+            density?: number;
+        };
+        DetectTagsStreamRequest: {
+            /** @description Tag schema ID (e.g., 'legal-irac', 'scientific-imrad', 'argument-toulmin') */
+            schemaId: string;
+            /** @description Categories to detect from the selected schema (e.g., ['Issue', 'Rule', 'Application', 'Conclusion']) */
+            categories: string[];
+        };
+        ErrorResponse: {
+            error: string;
+            code?: string;
+            details?: unknown;
+        };
+        EventStreamResponse: {
+            event: string;
+            data: string;
+            id?: string;
+        };
+        GenerateResourceFromAnnotationRequest: {
+            /** @description Optional name for the generated resource */
+            name?: string;
+            /** @description Entity types for the generated resource */
+            entityTypes?: string[];
+            /** @description Optional AI prompt for generation */
+            prompt?: string;
+            /** @description Language code (e.g., 'en', 'es') */
+            language?: string;
+        };
+        GenerateResourceFromAnnotationResponse: {
+            resource: components["schemas"]["ResourceDescriptor"];
+            annotation: components["schemas"]["Annotation"];
+            generated: boolean;
+        };
+        GenerateResourceRequest: {
+            /** @description Resource ID containing the annotation */
+            resourceId: string;
+            /** @description Custom title for generated resource */
+            title?: string;
+            /** @description Custom prompt for content generation */
+            prompt?: string;
+            /** @description Language locale (e.g., "es", "fr", "ja") */
+            language?: string;
+        };
+        GenerateResourceStreamRequest: {
+            /** @description Custom title for generated resource */
+            title?: string;
+            /** @description Custom prompt for content generation */
+            prompt?: string;
+            /** @description Language locale for generated content (e.g., "es", "fr", "ja") */
+            language?: string;
+            /** @description Generation context including source document excerpts and metadata */
+            context: components["schemas"]["GenerationContext"];
+            /** @description Inference temperature (0.0 = focused, 1.0 = creative) */
+            temperature?: number;
+            /** @description Maximum tokens to generate */
+            maxTokens?: number;
+        };
+        GetAnnotationHistoryResponse: {
+            events: {
+                id: string;
+                type: string;
+                timestamp: string;
+                userId: string;
+                resourceId: string;
+                payload: {
+                    name: string;
+                    format: components["schemas"]["ContentFormat"];
+                    contentChecksum: string;
+                    /** @enum {string} */
+                    creationMethod: "api" | "upload" | "ui" | "reference" | "clone" | "generated";
+                    entityTypes?: string[];
+                    metadata?: {
+                        [key: string]: unknown;
+                    };
+                } | {
+                    name: string;
+                    format: components["schemas"]["ContentFormat"];
+                    contentChecksum: string;
+                    parentResourceId: string;
+                    /** @enum {string} */
+                    creationMethod: "api" | "upload" | "ui" | "reference" | "clone" | "generated";
+                    entityTypes?: string[];
+                    metadata?: {
+                        [key: string]: unknown;
+                    };
+                } | {
+                    reason?: string;
+                } | Record<string, never> | {
+                    /** @description W3C Annotation (creator/created fields are optional in events - they're derived from event userId/timestamp) */
+                    annotation: components["schemas"]["Annotation"];
+                } | {
+                    /** @description Unified annotation ID */
+                    annotationId: string;
+                } | {
+                    /** @description Unified annotation ID */
+                    annotationId: string;
+                    /** @description For linking motivation */
+                    targetResourceId: string;
+                } | {
+                    entityType: string;
+                } | {
+                    entityType: string;
+                };
+                metadata: {
+                    sequenceNumber: number;
+                    prevEventHash?: string;
+                    checksum?: string;
+                };
+            }[];
+            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: {
+                event: {
+                    id: string;
+                    type: string;
+                    timestamp: string;
+                    userId: string;
+                    resourceId: string;
+                    payload?: unknown;
+                };
+                metadata: {
+                    sequenceNumber: number;
+                    prevEventHash?: string;
+                    checksum?: string;
+                };
+            }[];
+            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"][];
+        };
+        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: "detection" | "generation" | "highlight-detection" | "assessment-detection" | "comment-detection" | "tag-detection";
+            /** @enum {string} */
+            status: "pending" | "running" | "complete" | "failed" | "cancelled";
+            userId: string;
+            created: string;
+            startedAt?: string;
+            completedAt?: string;
+            error?: string;
+            progress?: unknown;
+            result?: unknown;
+        };
+        ListAnnotationsResponse: {
+            annotations: components["schemas"]["Annotation"][];
+            total: number;
+            offset: number;
+            limit: number;
+        };
+        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 W3C Web Annotation motivation vocabulary - https://www.w3.org/TR/annotation-vocab/#motivation
+         * @enum {string}
+         */
+        Motivation: "assessing" | "bookmarking" | "classifying" | "commenting" | "describing" | "editing" | "highlighting" | "identifying" | "linking" | "moderating" | "questioning" | "replying" | "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 Where the bytes live (s3://, file://, https://, ipfs://, etc.). */
+            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;
+        };
+        ResolveAnnotationRequest: {
+            /** @description Target resource ID to resolve reference to */
+            resourceId: string;
+        };
+        ResolveAnnotationResponse: {
+            annotation: components["schemas"]["Annotation"];
+            targetResource?: components["schemas"]["ResourceDescriptor"] | null;
+        };
+        /** @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;
+            })[];
+            /**
+             * Format: uri
+             * @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 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: How this resource was created
+             * @enum {string}
+             */
+            creationMethod?: "api" | "upload" | "ui" | "reference" | "clone" | "generated";
+            /** @description Application-specific: ID of annotation that triggered generation */
+            sourceAnnotationId?: string;
+            /** @description Application-specific: ID of source resource for clones/derivatives */
+            sourceResourceId?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        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: {
+            /** @constant */
+            type: "SpecificResource";
+            /** @description IRI of the target resource */
+            source: string;
+            /**
+             * @description Why this body is included
+             * @enum {string}
+             */
+            purpose?: "linking";
+        };
+        StatusResponse: {
+            status: string;
+            version: string;
+            features: {
+                semanticContent: string;
+                collaboration: string;
+                rbac: string;
+            };
+            message: string;
+            authenticatedAs?: 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: {
+            /** @constant */
+            type: "TextualBody";
+            /** @description The text content (e.g., entity type name) */
+            value: string;
+            /**
+             * @description Why this body is included
+             * @enum {string}
+             */
+            purpose?: "tagging" | "describing" | "commenting" | "classifying";
+            /** @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"])[];
+        };
+        UpdateAnnotationBodyResponse: {
+            annotation: components["schemas"]["Annotation"];
+        };
+        UpdateResourceRequest: {
+            entityTypes?: string[];
+            archived?: boolean;
+        };
+        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;
+            isActive: boolean;
+            termsAcceptedAt: string | null;
+            lastLogin: string | null;
+            created: string;
+        };
+        SvgSelector: {
+            /** @enum {string} */
+            type: "SvgSelector";
+            /** @description SVG markup defining the region (must include xmlns attribute) */
+            value: string;
+        };
+        /** @description Context information used for AI generation. Includes source document excerpts and metadata. */
+        GenerationContext: {
+            /** @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 Additional context metadata (reserved for future use) */
+            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[];
+            };
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;