chore: regenerate OpenAPI spec and TypeScript types for admin endpoints

Downloaded from deployed feature branch server. Patched PositionedNode
to include children field (missing from server-generated spec).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

ui/src/api/schema.d.ts

@@ -21,6 +21,24 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/admin/thresholds": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get current threshold configuration */
+        get: operations["getThresholds"];
+        /** Update threshold configuration */
+        put: operations["updateThresholds"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/admin/oidc": {
         parameters: {
             query?: never;
@@ -326,6 +344,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/admin/database/queries/{pid}/kill": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Terminate a query by PID */
+        post: operations["killQuery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/search/stats": {
         parameters: {
             query?: never;
@@ -526,6 +561,176 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/admin/opensearch/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get OpenSearch cluster status and version */
+        get: operations["getStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/opensearch/pipeline": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get indexing pipeline statistics */
+        get: operations["getPipeline"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/opensearch/performance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get OpenSearch performance metrics */
+        get: operations["getPerformance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/opensearch/indices": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get OpenSearch indices with pagination */
+        get: operations["getIndices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/database/tables": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get table sizes and row counts */
+        get: operations["getTables"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/database/status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get database connection status and version */
+        get: operations["getStatus_1"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/database/queries": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get active queries */
+        get: operations["getQueries"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/database/pool": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get HikariCP connection pool stats */
+        get: operations["getPool"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/audit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Search audit log entries with pagination */
+        get: operations["getAuditLog"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/admin/opensearch/indices/{name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Delete an OpenSearch index */
+        delete: operations["deleteIndex"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -533,6 +738,101 @@ export interface components {
         RolesRequest: {
             roles?: string[];
         };
+        /** @description Database monitoring thresholds */
+        DatabaseThresholdsRequest: {
+            /**
+             * Format: int32
+             * @description Connection pool usage warning threshold (percentage)
+             */
+            connectionPoolWarning?: number;
+            /**
+             * Format: int32
+             * @description Connection pool usage critical threshold (percentage)
+             */
+            connectionPoolCritical?: number;
+            /**
+             * Format: double
+             * @description Query duration warning threshold (seconds)
+             */
+            queryDurationWarning?: number;
+            /**
+             * Format: double
+             * @description Query duration critical threshold (seconds)
+             */
+            queryDurationCritical?: number;
+        };
+        /** @description OpenSearch monitoring thresholds */
+        OpenSearchThresholdsRequest: {
+            /** @description Cluster health warning threshold (GREEN, YELLOW, RED) */
+            clusterHealthWarning?: string;
+            /** @description Cluster health critical threshold (GREEN, YELLOW, RED) */
+            clusterHealthCritical?: string;
+            /**
+             * Format: int32
+             * @description Queue depth warning threshold
+             */
+            queueDepthWarning?: number;
+            /**
+             * Format: int32
+             * @description Queue depth critical threshold
+             */
+            queueDepthCritical?: number;
+            /**
+             * Format: int32
+             * @description JVM heap usage warning threshold (percentage)
+             */
+            jvmHeapWarning?: number;
+            /**
+             * Format: int32
+             * @description JVM heap usage critical threshold (percentage)
+             */
+            jvmHeapCritical?: number;
+            /**
+             * Format: int32
+             * @description Failed document count warning threshold
+             */
+            failedDocsWarning?: number;
+            /**
+             * Format: int32
+             * @description Failed document count critical threshold
+             */
+            failedDocsCritical?: number;
+        };
+        /** @description Threshold configuration for admin monitoring */
+        ThresholdConfigRequest: {
+            database: components["schemas"]["DatabaseThresholdsRequest"];
+            opensearch: components["schemas"]["OpenSearchThresholdsRequest"];
+        };
+        DatabaseThresholds: {
+            /** Format: int32 */
+            connectionPoolWarning?: number;
+            /** Format: int32 */
+            connectionPoolCritical?: number;
+            /** Format: double */
+            queryDurationWarning?: number;
+            /** Format: double */
+            queryDurationCritical?: number;
+        };
+        OpenSearchThresholds: {
+            clusterHealthWarning?: string;
+            clusterHealthCritical?: string;
+            /** Format: int32 */
+            queueDepthWarning?: number;
+            /** Format: int32 */
+            queueDepthCritical?: number;
+            /** Format: int32 */
+            jvmHeapWarning?: number;
+            /** Format: int32 */
+            jvmHeapCritical?: number;
+            /** Format: int32 */
+            failedDocsWarning?: number;
+            /** Format: int32 */
+            failedDocsCritical?: number;
+        };
+        ThresholdConfig: {
+            database?: components["schemas"]["DatabaseThresholds"];
+            opensearch?: components["schemas"]["OpenSearchThresholds"];
+        };
         /** @description OIDC configuration update request */
         OidcAdminConfigRequest: {
             enabled?: boolean;
@@ -816,6 +1116,279 @@ export interface components {
             /** Format: date-time */
             createdAt: string;
         };
+        /** @description OpenSearch cluster status */
+        OpenSearchStatusResponse: {
+            /** @description Whether the cluster is reachable */
+            reachable?: boolean;
+            /** @description Cluster health status (GREEN, YELLOW, RED) */
+            clusterHealth?: string;
+            /** @description OpenSearch version */
+            version?: string;
+            /**
+             * Format: int32
+             * @description Number of nodes in the cluster
+             */
+            nodeCount?: number;
+            /** @description OpenSearch host */
+            host?: string;
+        };
+        /** @description Search indexing pipeline statistics */
+        PipelineStatsResponse: {
+            /**
+             * Format: int32
+             * @description Current queue depth
+             */
+            queueDepth?: number;
+            /**
+             * Format: int32
+             * @description Maximum queue size
+             */
+            maxQueueSize?: number;
+            /**
+             * Format: int64
+             * @description Number of failed indexing operations
+             */
+            failedCount?: number;
+            /**
+             * Format: int64
+             * @description Number of successfully indexed documents
+             */
+            indexedCount?: number;
+            /**
+             * Format: int64
+             * @description Debounce interval in milliseconds
+             */
+            debounceMs?: number;
+            /**
+             * Format: double
+             * @description Current indexing rate (docs/sec)
+             */
+            indexingRate?: number;
+            /**
+             * Format: date-time
+             * @description Timestamp of last indexed document
+             */
+            lastIndexedAt?: string;
+        };
+        /** @description OpenSearch performance metrics */
+        PerformanceResponse: {
+            /**
+             * Format: double
+             * @description Query cache hit rate (0.0-1.0)
+             */
+            queryCacheHitRate?: number;
+            /**
+             * Format: double
+             * @description Request cache hit rate (0.0-1.0)
+             */
+            requestCacheHitRate?: number;
+            /**
+             * Format: double
+             * @description Average search latency in milliseconds
+             */
+            searchLatencyMs?: number;
+            /**
+             * Format: double
+             * @description Average indexing latency in milliseconds
+             */
+            indexingLatencyMs?: number;
+            /**
+             * Format: int64
+             * @description JVM heap used in bytes
+             */
+            jvmHeapUsedBytes?: number;
+            /**
+             * Format: int64
+             * @description JVM heap max in bytes
+             */
+            jvmHeapMaxBytes?: number;
+        };
+        /** @description OpenSearch index information */
+        IndexInfoResponse: {
+            /** @description Index name */
+            name?: string;
+            /**
+             * Format: int64
+             * @description Document count
+             */
+            docCount?: number;
+            /** @description Human-readable index size */
+            size?: string;
+            /**
+             * Format: int64
+             * @description Index size in bytes
+             */
+            sizeBytes?: number;
+            /** @description Index health status */
+            health?: string;
+            /**
+             * Format: int32
+             * @description Number of primary shards
+             */
+            primaryShards?: number;
+            /**
+             * Format: int32
+             * @description Number of replica shards
+             */
+            replicaShards?: number;
+        };
+        /** @description Paginated list of OpenSearch indices */
+        IndicesPageResponse: {
+            /** @description Index list for current page */
+            indices?: components["schemas"]["IndexInfoResponse"][];
+            /**
+             * Format: int64
+             * @description Total number of indices
+             */
+            totalIndices?: number;
+            /**
+             * Format: int64
+             * @description Total document count across all indices
+             */
+            totalDocs?: number;
+            /** @description Human-readable total size */
+            totalSize?: string;
+            /**
+             * Format: int32
+             * @description Current page number (0-based)
+             */
+            page?: number;
+            /**
+             * Format: int32
+             * @description Page size
+             */
+            pageSize?: number;
+            /**
+             * Format: int32
+             * @description Total number of pages
+             */
+            totalPages?: number;
+        };
+        /** @description Table size and row count information */
+        TableSizeResponse: {
+            /** @description Table name */
+            tableName?: string;
+            /**
+             * Format: int64
+             * @description Approximate row count
+             */
+            rowCount?: number;
+            /** @description Human-readable data size */
+            dataSize?: string;
+            /** @description Human-readable index size */
+            indexSize?: string;
+            /**
+             * Format: int64
+             * @description Data size in bytes
+             */
+            dataSizeBytes?: number;
+            /**
+             * Format: int64
+             * @description Index size in bytes
+             */
+            indexSizeBytes?: number;
+        };
+        /** @description Database connection and version status */
+        DatabaseStatusResponse: {
+            /** @description Whether the database is reachable */
+            connected?: boolean;
+            /** @description PostgreSQL version string */
+            version?: string;
+            /** @description Database host */
+            host?: string;
+            /** @description Current schema search path */
+            schema?: string;
+            /** @description Whether TimescaleDB extension is available */
+            timescaleDb?: boolean;
+        };
+        /** @description Currently running database query */
+        ActiveQueryResponse: {
+            /**
+             * Format: int32
+             * @description Backend process ID
+             */
+            pid?: number;
+            /**
+             * Format: double
+             * @description Query duration in seconds
+             */
+            durationSeconds?: number;
+            /** @description Backend state (active, idle, etc.) */
+            state?: string;
+            /** @description SQL query text */
+            query?: string;
+        };
+        /** @description HikariCP connection pool statistics */
+        ConnectionPoolResponse: {
+            /**
+             * Format: int32
+             * @description Number of currently active connections
+             */
+            activeConnections?: number;
+            /**
+             * Format: int32
+             * @description Number of idle connections
+             */
+            idleConnections?: number;
+            /**
+             * Format: int32
+             * @description Number of threads waiting for a connection
+             */
+            pendingThreads?: number;
+            /**
+             * Format: int64
+             * @description Maximum wait time in milliseconds
+             */
+            maxWaitMs?: number;
+            /**
+             * Format: int32
+             * @description Maximum pool size
+             */
+            maxPoolSize?: number;
+        };
+        /** @description Paginated audit log entries */
+        AuditLogPageResponse: {
+            /** @description Audit log entries */
+            items?: components["schemas"]["AuditRecord"][];
+            /**
+             * Format: int64
+             * @description Total number of matching entries
+             */
+            totalCount?: number;
+            /**
+             * Format: int32
+             * @description Current page number (0-based)
+             */
+            page?: number;
+            /**
+             * Format: int32
+             * @description Page size
+             */
+            pageSize?: number;
+            /**
+             * Format: int32
+             * @description Total number of pages
+             */
+            totalPages?: number;
+        };
+        AuditRecord: {
+            /** Format: int64 */
+            id?: number;
+            /** Format: date-time */
+            timestamp?: string;
+            username?: string;
+            action?: string;
+            /** @enum {string} */
+            category?: "INFRA" | "AUTH" | "USER_MGMT" | "CONFIG";
+            target?: string;
+            detail?: {
+                [key: string]: Record<string, never>;
+            };
+            /** @enum {string} */
+            result?: "SUCCESS" | "FAILURE";
+            ipAddress?: string;
+            userAgent?: string;
+        };
     };
     responses: never;
     parameters: never;
@@ -856,6 +1429,50 @@ export interface operations {
             };
         };
     };
+    getThresholds: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["ThresholdConfig"];
+                };
+            };
+        };
+    };
+    updateThresholds: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ThresholdConfigRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["ThresholdConfig"];
+                };
+            };
+        };
+    };
     getConfig: {
         parameters: {
             query?: never;
@@ -1034,13 +1651,6 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Buffer full, retry later */
-            503: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
         };
     };
     ingestDiagrams: {
@@ -1063,13 +1673,6 @@ export interface operations {
                 };
                 content?: never;
             };
-            /** @description Buffer full, retry later */
-            503: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
         };
     };
     refresh: {
@@ -1471,6 +2074,26 @@ export interface operations {
             };
         };
     };
+    killQuery: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                pid: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     stats: {
         parameters: {
             query: {
@@ -1615,7 +2238,9 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "*/*": components["schemas"]["DiagramLayout"];
+                };
             };
         };
     };
@@ -1826,4 +2451,218 @@ export interface operations {
             };
         };
     };
+    getStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["OpenSearchStatusResponse"];
+                };
+            };
+        };
+    };
+    getPipeline: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["PipelineStatsResponse"];
+                };
+            };
+        };
+    };
+    getPerformance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["PerformanceResponse"];
+                };
+            };
+        };
+    };
+    getIndices: {
+        parameters: {
+            query?: {
+                page?: number;
+                size?: number;
+                search?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["IndicesPageResponse"];
+                };
+            };
+        };
+    };
+    getTables: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["TableSizeResponse"][];
+                };
+            };
+        };
+    };
+    getStatus_1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["DatabaseStatusResponse"];
+                };
+            };
+        };
+    };
+    getQueries: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["ActiveQueryResponse"][];
+                };
+            };
+        };
+    };
+    getPool: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["ConnectionPoolResponse"];
+                };
+            };
+        };
+    };
+    getAuditLog: {
+        parameters: {
+            query?: {
+                username?: string;
+                category?: string;
+                search?: string;
+                from?: string;
+                to?: string;
+                sort?: string;
+                order?: string;
+                page?: number;
+                size?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["AuditLogPageResponse"];
+                };
+            };
+        };
+    };
+    deleteIndex: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                name: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
 }