cameleer-server/ui/src/api/schema.d.ts

/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/config/{application}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get application config
         * @description Returns the current configuration for an application. Returns defaults if none stored.
         */
        get: operations["getConfig"];
        /**
         * Update application config
         * @description Saves config and pushes CONFIG_UPDATE to all LIVE agents of this application
         */
        put: operations["updateConfig"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/users/{userId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get user by ID with RBAC detail */
        get: operations["getUser"];
        /** Update user display name or email */
        put: operations["updateUser"];
        post?: never;
        /** Delete user */
        delete: operations["deleteUser"];
        options?: never;
        head?: never;
        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/roles/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get role by ID with effective principals */
        get: operations["getRole"];
        /** Update a custom role */
        put: operations["updateRole"];
        post?: never;
        /** Delete a custom role */
        delete: operations["deleteRole"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/oidc": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get OIDC configuration */
        get: operations["getConfig_1"];
        /** Save OIDC configuration */
        put: operations["saveConfig"];
        post?: never;
        /** Delete OIDC configuration */
        delete: operations["deleteConfig"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/groups/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get group by ID with effective roles */
        get: operations["getGroup"];
        /** Update group name or parent */
        put: operations["updateGroup"];
        post?: never;
        /** Delete group */
        delete: operations["deleteGroup"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/app-settings/{appId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get settings for a specific application (returns defaults if not configured) */
        get: operations["getByAppId"];
        /** Create or update settings for an application */
        put: operations["update"];
        post?: never;
        /** Delete application settings (reverts to defaults) */
        delete: operations["delete"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/executions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search executions with basic filters */
        get: operations["searchGet"];
        put?: never;
        /** Advanced search with all filters */
        post: operations["searchPost"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/data/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Ingest agent metrics
         * @description Accepts an array of MetricsSnapshot objects
         */
        post: operations["ingestMetrics"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/data/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Ingest application log entries
         * @description Accepts a batch of log entries from an agent. Entries are buffered and flushed periodically.
         */
        post: operations["ingestLogs"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/data/executions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Ingest execution chunk */
        post: operations["ingestChunks"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/data/events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Ingest agent events */
        post: operations["ingestEvents"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/data/diagrams": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Ingest route diagram data
         * @description Accepts a single RouteGraph or an array of RouteGraphs
         */
        post: operations["ingestDiagrams"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/{application}/test-expression": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Test a tap expression against sample data via a live agent */
        post: operations["testExpression"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/refresh": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Refresh access token */
        post: operations["refresh"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/oidc/callback": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Exchange OIDC authorization code for JWTs */
        post: operations["callback"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/login": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Login with local credentials */
        post: operations["login"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{id}/replay": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Replay an exchange on a specific agent (synchronous)
         * @description Sends a replay command and waits for the agent to complete the replay. Returns the replay result including status, replayExchangeId, and duration.
         */
        post: operations["replayExchange"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{id}/refresh": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Refresh access token
         * @description Issues a new access JWT from a valid refresh token
         */
        post: operations["refresh_1"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{id}/heartbeat": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Agent heartbeat ping
         * @description Updates the agent's last heartbeat timestamp. Auto-registers the agent if not in registry (e.g. after server restart).
         */
        post: operations["heartbeat"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{id}/deregister": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Deregister agent
         * @description Removes the agent from the registry. Called by agents during graceful shutdown.
         */
        post: operations["deregister"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{id}/commands": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send command to a specific agent
         * @description Sends a command to the specified agent via SSE
         */
        post: operations["sendCommand"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{id}/commands/{commandId}/ack": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Acknowledge command receipt
         * @description Agent acknowledges that it has received and processed a command, with result status and message
         */
        post: operations["acknowledgeCommand"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/register": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Register an agent
         * @description Registers a new agent or re-registers an existing one. Requires bootstrap token in Authorization header.
         */
        post: operations["register"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/groups/{group}/commands": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send command to all agents in a group
         * @description Sends a command to all LIVE agents in the specified group and waits for responses
         */
        post: operations["sendGroupCommand"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/commands": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Broadcast command to all live agents
         * @description Sends a command to all agents currently in LIVE state
         */
        post: operations["broadcastCommand"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/users": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all users with RBAC detail */
        get: operations["listUsers"];
        put?: never;
        /** Create a local user */
        post: operations["createUser"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/users/{userId}/roles/{roleId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Assign a role to a user */
        post: operations["assignRoleToUser"];
        /** Remove a role from a user */
        delete: operations["removeRoleFromUser"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/users/{userId}/password": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Reset user password */
        post: operations["resetPassword"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/users/{userId}/groups/{groupId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Add a user to a group */
        post: operations["addUserToGroup"];
        /** Remove a user from a group */
        delete: operations["removeUserFromGroup"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/roles": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all roles (system and custom) */
        get: operations["listRoles"];
        put?: never;
        /** Create a custom role */
        post: operations["createRole"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/oidc/test": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Test OIDC provider connectivity */
        post: operations["testConnection"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/groups": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all groups with hierarchy and effective roles */
        get: operations["listGroups"];
        put?: never;
        /** Create a new group */
        post: operations["createGroup"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/groups/{id}/roles/{roleId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Assign a role to a group */
        post: operations["assignRoleToGroup"];
        /** Remove a role from a group */
        delete: operations["removeRoleFromGroup"];
        options?: never;
        head?: never;
        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;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Aggregate execution stats (P99 latency, active count, SLA compliance) */
        get: operations["stats"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/stats/timeseries": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Bucketed time-series stats over a time window */
        get: operations["timeseries"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/stats/timeseries/by-route": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Timeseries grouped by route for an application */
        get: operations["timeseriesByRoute"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/stats/timeseries/by-app": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Timeseries grouped by application */
        get: operations["timeseriesByApp"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/stats/punchcard": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Transaction punchcard: weekday x hour grid (rolling 7 days) */
        get: operations["punchcard"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/errors/top": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Top N errors with velocity trend */
        get: operations["topErrors"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/attributes/keys": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Distinct attribute key names across all executions */
        get: operations["attributeKeys"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/routes/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get route metrics
         * @description Returns aggregated performance metrics per route for the given time window
         */
        get: operations["getMetrics"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/routes/metrics/processors": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get processor metrics
         * @description Returns aggregated performance metrics per processor for the given route and time window
         */
        get: operations["getProcessorMetrics"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/routes/catalog": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get route catalog
         * @description Returns all applications with their routes, agents, and health status
         */
        get: operations["getCatalog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search application log entries
         * @description Returns log entries with cursor-based pagination and level count aggregation. Supports free-text search, multi-level filtering, and optional application scoping.
         */
        get: operations["searchLogs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/executions/{executionId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get execution detail with nested processor tree */
        get: operations["getDetail"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/executions/{executionId}/processors/{index}/snapshot": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get exchange snapshot for a specific processor by index */
        get: operations["getProcessorSnapshot"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/executions/{executionId}/processors/by-seq/{seq}/snapshot": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get exchange snapshot for a processor by seq number */
        get: operations["processorSnapshotBySeq"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/executions/{executionId}/processors/by-id/{processorId}/snapshot": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get exchange snapshot for a specific processor by processorId */
        get: operations["processorSnapshotById"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/diagrams": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Find diagram by application and route ID
         * @description Resolves application to agent IDs and finds the latest diagram for the route
         */
        get: operations["findByApplicationAndRoute"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/diagrams/{contentHash}/render": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Render a route diagram
         * @description Returns SVG (default) or JSON layout based on Accept header
         */
        get: operations["renderDiagram"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all application configs
         * @description Returns stored configurations for all applications
         */
        get: operations["listConfigs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/{application}/processor-routes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get processor to route mapping
         * @description Returns a map of processorId → routeId for all processors seen in this application
         */
        get: operations["getProcessorRouteMapping"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/oidc/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get OIDC config for SPA login flow */
        get: operations["getConfig_2"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all agents
         * @description Returns all registered agents with runtime metrics, optionally filtered by status and/or application
         */
        get: operations["listAgents"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{id}/events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Open SSE event stream
         * @description Opens a Server-Sent Events stream for the specified agent. Commands (config-update, deep-trace, replay) are pushed as events. Ping keepalive comments sent every 15 seconds.
         */
        get: operations["events"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/{agentId}/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["getMetrics_1"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agents/events-log": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Query agent events
         * @description Returns agent lifecycle events, optionally filtered by app and/or agent ID
         */
        get: operations["getEvents"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/usage": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Query usage statistics
         * @description Returns aggregated API usage stats grouped by endpoint, user, or hour
         */
        get: operations["getUsage"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/rbac/stats": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get RBAC statistics for the dashboard */
        get: operations["getStats"];
        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"];
        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/clickhouse/tables": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List ClickHouse tables with sizes */
        get: operations["getTables_1"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/clickhouse/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** ClickHouse cluster status */
        get: operations["getStatus_1"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/clickhouse/queries": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Active ClickHouse queries */
        get: operations["getQueries_1"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/clickhouse/pipeline": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search indexer pipeline statistics */
        get: operations["getPipeline"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/clickhouse/performance": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** ClickHouse storage and performance metrics */
        get: operations["getPerformance"];
        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/app-settings": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all application settings */
        get: operations["getAll"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        ApplicationConfig: {
            application?: string;
            /** Format: int32 */
            version?: number;
            /** Format: date-time */
            updatedAt?: string;
            engineLevel?: string;
            payloadCaptureMode?: string;
            metricsEnabled?: boolean;
            /** Format: double */
            samplingRate?: number;
            tracedProcessors?: {
                [key: string]: string;
            };
            applicationLogLevel?: string;
            taps?: components["schemas"]["TapDefinition"][];
            /** Format: int32 */
            tapVersion?: number;
            routeRecording?: {
                [key: string]: boolean;
            };
            compressSuccess?: boolean;
            agentLogLevel?: string;
            routeSamplingRates?: {
                [key: string]: number;
            };
        };
        TapDefinition: {
            tapId?: string;
            processorId?: string;
            target?: string;
            expression?: string;
            language?: string;
            attributeName?: string;
            attributeType?: string;
            enabled?: boolean;
            /** Format: int32 */
            version?: number;
        };
        AgentResponse: {
            agentId?: string;
            status?: string;
            message?: string;
        };
        CommandGroupResponse: {
            success?: boolean;
            /** Format: int32 */
            total?: number;
            /** Format: int32 */
            responded?: number;
            responses?: components["schemas"]["AgentResponse"][];
            timedOut?: string[];
        };
        ConfigUpdateResponse: {
            config?: components["schemas"]["ApplicationConfig"];
            pushResult?: components["schemas"]["CommandGroupResponse"];
        };
        UpdateUserRequest: {
            displayName?: string;
            email?: 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 Threshold configuration for admin monitoring */
        ThresholdConfigRequest: {
            database: components["schemas"]["DatabaseThresholdsRequest"];
        };
        DatabaseThresholds: {
            /** Format: int32 */
            connectionPoolWarning?: number;
            /** Format: int32 */
            connectionPoolCritical?: number;
            /** Format: double */
            queryDurationWarning?: number;
            /** Format: double */
            queryDurationCritical?: number;
        };
        ThresholdConfig: {
            database?: components["schemas"]["DatabaseThresholds"];
        };
        UpdateRoleRequest: {
            name?: string;
            description?: string;
            scope?: string;
        };
        /** @description OIDC configuration update request */
        OidcAdminConfigRequest: {
            enabled?: boolean;
            issuerUri?: string;
            clientId?: string;
            clientSecret?: string;
            rolesClaim?: string;
            defaultRoles?: string[];
            autoSignup?: boolean;
            displayNameClaim?: string;
            userIdClaim?: string;
            audience?: string;
            additionalScopes?: string[];
        };
        /** @description Error response */
        ErrorResponse: {
            message: string;
        };
        /** @description OIDC configuration for admin management */
        OidcAdminConfigResponse: {
            configured?: boolean;
            enabled?: boolean;
            issuerUri?: string;
            clientId?: string;
            clientSecretSet?: boolean;
            rolesClaim?: string;
            defaultRoles?: string[];
            autoSignup?: boolean;
            displayNameClaim?: string;
            userIdClaim?: string;
            audience?: string;
            additionalScopes?: string[];
        };
        UpdateGroupRequest: {
            name?: string;
            /** Format: uuid */
            parentGroupId?: string;
        };
        /** @description Per-application dashboard settings */
        AppSettingsRequest: {
            /**
             * Format: int32
             * @description SLA duration threshold in milliseconds
             */
            slaThresholdMs: number;
            /**
             * Format: double
             * @description Error rate % threshold for warning (yellow) health dot
             */
            healthErrorWarn: number;
            /**
             * Format: double
             * @description Error rate % threshold for critical (red) health dot
             */
            healthErrorCrit: number;
            /**
             * Format: double
             * @description SLA compliance % threshold for warning (yellow) health dot
             */
            healthSlaWarn: number;
            /**
             * Format: double
             * @description SLA compliance % threshold for critical (red) health dot
             */
            healthSlaCrit: number;
        };
        AppSettings: {
            applicationId?: string;
            /** Format: int32 */
            slaThresholdMs?: number;
            /** Format: double */
            healthErrorWarn?: number;
            /** Format: double */
            healthErrorCrit?: number;
            /** Format: double */
            healthSlaWarn?: number;
            /** Format: double */
            healthSlaCrit?: number;
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            updatedAt?: string;
        };
        SearchRequest: {
            status?: string;
            /** Format: date-time */
            timeFrom?: string;
            /** Format: date-time */
            timeTo?: string;
            /** Format: int64 */
            durationMin?: number;
            /** Format: int64 */
            durationMax?: number;
            correlationId?: string;
            text?: string;
            textInBody?: string;
            textInHeaders?: string;
            textInErrors?: string;
            routeId?: string;
            instanceId?: string;
            processorType?: string;
            applicationId?: string;
            instanceIds?: string[];
            /** Format: int32 */
            offset?: number;
            /** Format: int32 */
            limit?: number;
            sortField?: string;
            sortDir?: string;
            environment?: string;
        };
        ExecutionSummary: {
            executionId: string;
            routeId: string;
            instanceId: string;
            applicationId: string;
            status: string;
            /** Format: date-time */
            startTime: string;
            /** Format: date-time */
            endTime: string;
            /** Format: int64 */
            durationMs: number;
            correlationId: string;
            errorMessage: string;
            diagramContentHash: string;
            highlight: string;
            attributes: {
                [key: string]: string;
            };
            hasTraceData: boolean;
            isReplay: boolean;
        };
        SearchResultExecutionSummary: {
            data: components["schemas"]["ExecutionSummary"][];
            /** Format: int64 */
            total: number;
            /** Format: int32 */
            offset: number;
            /** Format: int32 */
            limit: number;
        };
        LogBatch: {
            entries?: components["schemas"]["LogEntry"][];
        };
        LogEntry: {
            /** Format: date-time */
            timestamp?: string;
            level?: string;
            loggerName?: string;
            message?: string;
            threadName?: string;
            stackTrace?: string;
            mdc?: {
                [key: string]: string;
            };
        };
        TestExpressionRequest: {
            expression?: string;
            language?: string;
            body?: string;
            target?: string;
        };
        TestExpressionResponse: {
            result?: string;
            error?: string;
        };
        RefreshRequest: {
            refreshToken?: string;
        };
        /** @description JWT token pair */
        AuthTokenResponse: {
            accessToken: string;
            refreshToken: string;
            displayName: string;
            /** @description OIDC id_token for end-session logout (only present after OIDC login) */
            idToken?: string;
        };
        CallbackRequest: {
            code?: string;
            redirectUri?: string;
        };
        LoginRequest: {
            username?: string;
            password?: string;
        };
        /** @description Request to replay an exchange on an agent */
        ReplayRequest: {
            /** @description Camel route ID to replay on */
            routeId: string;
            /** @description Message body for the replayed exchange */
            body?: string;
            /** @description Message headers for the replayed exchange */
            headers?: {
                [key: string]: string;
            };
            /** @description Exchange ID of the original execution being replayed (for audit trail) */
            originalExchangeId?: string;
        };
        /** @description Result of a replay command */
        ReplayResponse: {
            /** @description Replay outcome: SUCCESS or FAILURE */
            status?: string;
            /** @description Human-readable result message */
            message?: string;
            /** @description Structured result data from the agent (JSON) */
            data?: string;
        };
        /** @description Agent token refresh request */
        AgentRefreshRequest: {
            refreshToken: string;
        };
        /** @description Refreshed access and refresh tokens */
        AgentRefreshResponse: {
            accessToken: string;
            refreshToken: string;
        };
        HeartbeatRequest: {
            routeStates?: {
                [key: string]: string;
            };
            capabilities?: {
                [key: string]: Record<string, never>;
            };
            environmentId?: string;
        };
        /** @description Command to send to agent(s) */
        CommandRequest: {
            /** @description Command type: config-update, deep-trace, or replay */
            type: string;
            /** @description Command payload JSON */
            payload?: Record<string, never>;
        };
        /** @description Result of sending a command to a single agent */
        CommandSingleResponse: {
            commandId: string;
            status: string;
        };
        CommandAckRequest: {
            status?: string;
            message?: string;
            data?: string;
        };
        /** @description Agent registration payload */
        AgentRegistrationRequest: {
            instanceId: string;
            displayName: string;
            /** @default default */
            applicationId: string;
            /** @default default */
            environmentId: string;
            version?: string;
            routeIds?: string[];
            capabilities?: {
                [key: string]: Record<string, never>;
            };
        };
        /** @description Agent registration result with JWT tokens and SSE endpoint */
        AgentRegistrationResponse: {
            instanceId: string;
            sseEndpoint: string;
            /** Format: int64 */
            heartbeatIntervalMs?: number;
            serverPublicKey: string;
            accessToken: string;
            refreshToken: string;
        };
        /** @description Result of broadcasting a command to multiple agents */
        CommandBroadcastResponse: {
            commandIds: string[];
            /** Format: int32 */
            targetCount?: number;
        };
        CreateUserRequest: {
            username?: string;
            displayName?: string;
            email?: string;
            password?: string;
        };
        GroupSummary: {
            /** Format: uuid */
            id?: string;
            name?: string;
        };
        RoleSummary: {
            /** Format: uuid */
            id?: string;
            name?: string;
            system?: boolean;
            source?: string;
        };
        UserDetail: {
            userId?: string;
            provider?: string;
            email?: string;
            displayName?: string;
            /** Format: date-time */
            createdAt?: string;
            directRoles?: components["schemas"]["RoleSummary"][];
            directGroups?: components["schemas"]["GroupSummary"][];
            effectiveRoles?: components["schemas"]["RoleSummary"][];
            effectiveGroups?: components["schemas"]["GroupSummary"][];
        };
        SetPasswordRequest: {
            password?: string;
        };
        CreateRoleRequest: {
            name?: string;
            description?: string;
            scope?: string;
        };
        /** @description OIDC provider connectivity test result */
        OidcTestResult: {
            status: string;
            authorizationEndpoint: string;
        };
        CreateGroupRequest: {
            name?: string;
            /** Format: uuid */
            parentGroupId?: string;
        };
        ExecutionStats: {
            /** Format: int64 */
            totalCount: number;
            /** Format: int64 */
            failedCount: number;
            /** Format: int64 */
            avgDurationMs: number;
            /** Format: int64 */
            p99LatencyMs: number;
            /** Format: int64 */
            activeCount: number;
            /** Format: int64 */
            totalToday: number;
            /** Format: int64 */
            prevTotalCount: number;
            /** Format: int64 */
            prevFailedCount: number;
            /** Format: int64 */
            prevAvgDurationMs: number;
            /** Format: int64 */
            prevP99LatencyMs: number;
            /** Format: double */
            slaCompliance: number;
        };
        StatsTimeseries: {
            buckets: components["schemas"]["TimeseriesBucket"][];
        };
        TimeseriesBucket: {
            /** Format: date-time */
            time: string;
            /** Format: int64 */
            totalCount: number;
            /** Format: int64 */
            failedCount: number;
            /** Format: int64 */
            avgDurationMs: number;
            /** Format: int64 */
            p99DurationMs: number;
            /** Format: int64 */
            activeCount: number;
        };
        PunchcardCell: {
            /** Format: int32 */
            weekday?: number;
            /** Format: int32 */
            hour?: number;
            /** Format: int64 */
            totalCount?: number;
            /** Format: int64 */
            failedCount?: number;
        };
        TopError: {
            errorType?: string;
            routeId?: string;
            processorId?: string;
            /** Format: int64 */
            count?: number;
            /** Format: double */
            velocity?: number;
            trend?: string;
            /** Format: date-time */
            lastSeen?: string;
        };
        /** @description Aggregated route performance metrics */
        RouteMetrics: {
            routeId: string;
            appId: string;
            /** Format: int64 */
            exchangeCount: number;
            /** Format: double */
            successRate: number;
            /** Format: double */
            avgDurationMs: number;
            /** Format: double */
            p99DurationMs: number;
            /** Format: double */
            errorRate: number;
            /** Format: double */
            throughputPerSec: number;
            sparkline: number[];
            /** Format: double */
            slaCompliance: number;
        };
        ProcessorMetrics: {
            processorId: string;
            processorType: string;
            routeId: string;
            appId: string;
            /** Format: int64 */
            totalCount: number;
            /** Format: int64 */
            failedCount: number;
            /** Format: double */
            avgDurationMs: number;
            /** Format: double */
            p99DurationMs: number;
            /** Format: double */
            errorRate: number;
        };
        /** @description Summary of an agent instance for sidebar display */
        AgentSummary: {
            id: string;
            name: string;
            status: string;
            /** Format: double */
            tps: number;
        };
        /** @description Application catalog entry with routes and agents */
        AppCatalogEntry: {
            appId: string;
            routes: components["schemas"]["RouteSummary"][];
            agents: components["schemas"]["AgentSummary"][];
            /** Format: int32 */
            agentCount: number;
            health: string;
            /** Format: int64 */
            exchangeCount: number;
        };
        /** @description Summary of a route within an application */
        RouteSummary: {
            routeId: string;
            /** Format: int64 */
            exchangeCount: number;
            /** Format: date-time */
            lastSeen: string;
            /** @description The from() endpoint URI, e.g. 'direct:processOrder' */
            fromEndpointUri: string;
            /** @description Operational state of the route: stopped, suspended, or null (started/default) */
            routeState: string;
        };
        /** @description Application log entry */
        LogEntryResponse: {
            /** @description Log timestamp (ISO-8601) */
            timestamp?: string;
            /** @description Log level (INFO, WARN, ERROR, DEBUG, TRACE) */
            level?: string;
            /** @description Logger name */
            loggerName?: string;
            /** @description Log message */
            message?: string;
            /** @description Thread name */
            threadName?: string;
            /** @description Stack trace (if present) */
            stackTrace?: string;
            /** @description Camel exchange ID (if present) */
            exchangeId?: string;
            /** @description Agent instance ID */
            instanceId?: string;
            /** @description Application ID */
            application?: string;
            /** @description MDC context map */
            mdc?: {
                [key: string]: string;
            };
        };
        /** @description Log search response with cursor pagination and level counts */
        LogSearchPageResponse: {
            /** @description Log entries for the current page */
            data?: components["schemas"]["LogEntryResponse"][];
            /** @description Cursor for next page (null if no more results) */
            nextCursor?: string;
            /** @description Whether more results exist beyond this page */
            hasMore?: boolean;
            /** @description Count of logs per level (unaffected by level filter) */
            levelCounts?: {
                [key: string]: number;
            };
        };
        ExecutionDetail: {
            executionId: string;
            routeId: string;
            instanceId: string;
            applicationId: string;
            status: string;
            /** Format: date-time */
            startTime: string;
            /** Format: date-time */
            endTime: string;
            /** Format: int64 */
            durationMs: number;
            correlationId: string;
            exchangeId: string;
            errorMessage: string;
            errorStackTrace: string;
            diagramContentHash: string;
            processors: components["schemas"]["ProcessorNode"][];
            inputBody: string;
            outputBody: string;
            inputHeaders: string;
            outputHeaders: string;
            inputProperties: string;
            outputProperties: string;
            attributes: {
                [key: string]: string;
            };
            errorType: string;
            errorCategory: string;
            rootCauseType: string;
            rootCauseMessage: string;
            traceId: string;
            spanId: string;
        };
        ProcessorNode: {
            processorId: string;
            processorType: string;
            status: string;
            /** Format: date-time */
            startTime: string;
            /** Format: date-time */
            endTime: string;
            /** Format: int64 */
            durationMs: number;
            errorMessage: string;
            errorStackTrace: string;
            attributes: {
                [key: string]: string;
            };
            /** Format: int32 */
            iteration: number;
            /** Format: int32 */
            iterationSize: number;
            /** Format: int32 */
            loopIndex: number;
            /** Format: int32 */
            loopSize: number;
            /** Format: int32 */
            splitIndex: number;
            /** Format: int32 */
            splitSize: number;
            /** Format: int32 */
            multicastIndex: number;
            resolvedEndpointUri: string;
            errorType: string;
            errorCategory: string;
            rootCauseType: string;
            rootCauseMessage: string;
            errorHandlerType: string;
            circuitBreakerState: string;
            fallbackTriggered: boolean;
            filterMatched: boolean;
            duplicateMessage: boolean;
            hasTraceData: boolean;
            children: components["schemas"]["ProcessorNode"][];
        };
        DiagramLayout: {
            /** Format: double */
            width?: number;
            /** Format: double */
            height?: number;
            nodes?: components["schemas"]["PositionedNode"][];
            edges?: components["schemas"]["PositionedEdge"][];
        };
        PositionedEdge: {
            sourceId?: string;
            targetId?: string;
            label?: string;
            points?: number[][];
        };
        PositionedNode: {
            id?: string;
            label?: string;
            type?: string;
            /** Format: double */
            x?: number;
            /** Format: double */
            y?: number;
            /** Format: double */
            width?: number;
            /** Format: double */
            height?: number;
            endpointUri?: string;
        };
        /** @description OIDC configuration for SPA login flow */
        OidcPublicConfigResponse: {
            issuer: string;
            clientId: string;
            authorizationEndpoint: string;
            /** @description Present if the provider supports RP-initiated logout */
            endSessionEndpoint?: string;
            /** @description RFC 8707 resource indicator for the authorization request */
            resource?: string;
            /** @description Additional scopes to request beyond openid email profile */
            additionalScopes?: string[];
        };
        /** @description Agent instance summary with runtime metrics */
        AgentInstanceResponse: {
            instanceId: string;
            displayName: string;
            applicationId: string;
            environmentId: string;
            status: string;
            routeIds: string[];
            /** Format: date-time */
            registeredAt: string;
            /** Format: date-time */
            lastHeartbeat: string;
            version: string;
            capabilities: {
                [key: string]: Record<string, never>;
            };
            /** Format: double */
            tps: number;
            /** Format: double */
            errorRate: number;
            /** Format: int32 */
            activeRoutes: number;
            /** Format: int32 */
            totalRoutes: number;
            /** Format: int64 */
            uptimeSeconds: number;
            /** Format: double */
            cpuUsage: number;
        };
        SseEmitter: {
            /** Format: int64 */
            timeout?: number;
        };
        AgentMetricsResponse: {
            metrics: {
                [key: string]: components["schemas"]["MetricBucket"][];
            };
        };
        MetricBucket: {
            /** Format: date-time */
            time: string;
            /** Format: double */
            value: number;
        };
        /** @description Agent lifecycle event */
        AgentEventResponse: {
            /** Format: int64 */
            id: number;
            instanceId: string;
            applicationId: string;
            eventType: string;
            detail: string;
            /** Format: date-time */
            timestamp: string;
        };
        UsageStats: {
            key?: string;
            /** Format: int64 */
            count?: number;
            /** Format: int64 */
            avgDurationMs?: number;
        };
        RoleDetail: {
            /** Format: uuid */
            id?: string;
            name?: string;
            description?: string;
            scope?: string;
            system?: boolean;
            /** Format: date-time */
            createdAt?: string;
            assignedGroups?: components["schemas"]["GroupSummary"][];
            directUsers?: components["schemas"]["UserSummary"][];
            effectivePrincipals?: components["schemas"]["UserSummary"][];
        };
        UserSummary: {
            userId?: string;
            displayName?: string;
            provider?: string;
        };
        RbacStats: {
            /** Format: int32 */
            userCount?: number;
            /** Format: int32 */
            activeUserCount?: number;
            /** Format: int32 */
            groupCount?: number;
            /** Format: int32 */
            maxGroupDepth?: number;
            /** Format: int32 */
            roleCount?: number;
        };
        GroupDetail: {
            /** Format: uuid */
            id?: string;
            name?: string;
            /** Format: uuid */
            parentGroupId?: string;
            /** Format: date-time */
            createdAt?: string;
            directRoles?: components["schemas"]["RoleSummary"][];
            effectiveRoles?: components["schemas"]["RoleSummary"][];
            members?: components["schemas"]["UserSummary"][];
            childGroups?: components["schemas"]["GroupSummary"][];
        };
        /** @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 */
            schema?: string;
        };
        /** @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 ClickHouse table information */
        ClickHouseTableInfo: {
            name?: string;
            engine?: string;
            /** Format: int64 */
            rowCount?: number;
            dataSize?: string;
            /** Format: int64 */
            dataSizeBytes?: number;
            /** Format: int32 */
            partitionCount?: number;
        };
        /** @description ClickHouse cluster status */
        ClickHouseStatusResponse: {
            reachable?: boolean;
            version?: string;
            uptime?: string;
            host?: string;
        };
        /** @description Active ClickHouse query information */
        ClickHouseQueryInfo: {
            queryId?: string;
            /** Format: double */
            elapsedSeconds?: number;
            memory?: string;
            /** Format: int64 */
            readRows?: number;
            query?: string;
        };
        /** @description Search indexer pipeline statistics */
        IndexerPipelineResponse: {
            /** Format: int32 */
            queueDepth?: number;
            /** Format: int32 */
            maxQueueSize?: number;
            /** Format: int64 */
            failedCount?: number;
            /** Format: int64 */
            indexedCount?: number;
            /** Format: int64 */
            debounceMs?: number;
            /** Format: double */
            indexingRate?: number;
            /** Format: date-time */
            lastIndexedAt?: string;
        };
        /** @description ClickHouse storage and performance metrics */
        ClickHousePerformanceResponse: {
            diskSize?: string;
            uncompressedSize?: string;
            /** Format: double */
            compressionRatio?: number;
            /** Format: int64 */
            totalRows?: number;
            /** Format: int32 */
            partCount?: number;
            memoryUsage?: string;
            /** Format: int32 */
            currentQueries?: 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" | "RBAC" | "AGENT";
            target?: string;
            detail?: {
                [key: string]: Record<string, never>;
            };
            /** @enum {string} */
            result?: "SUCCESS" | "FAILURE";
            ipAddress?: string;
            userAgent?: string;
        };
    };
    responses: never;
    parameters: never;
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    getConfig: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                application: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Config returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ApplicationConfig"];
                };
            };
        };
    };
    updateConfig: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                application: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ApplicationConfig"];
            };
        };
        responses: {
            /** @description Config saved and pushed */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ConfigUpdateResponse"];
                };
            };
        };
    };
    getUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description User found */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UserDetail"];
                };
            };
            /** @description User not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UserDetail"];
                };
            };
        };
    };
    updateUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateUserRequest"];
            };
        };
        responses: {
            /** @description User updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description User not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    deleteUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description User deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    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"];
                };
            };
        };
    };
    getRole: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Role found */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["RoleDetail"];
                };
            };
            /** @description Role not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["RoleDetail"];
                };
            };
        };
    };
    updateRole: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateRoleRequest"];
            };
        };
        responses: {
            /** @description Role updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Cannot modify system role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Role not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    deleteRole: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Role deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Cannot delete system role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Role not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getConfig_1: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current OIDC configuration (client_secret masked) */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OidcAdminConfigResponse"];
                };
            };
        };
    };
    saveConfig: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["OidcAdminConfigRequest"];
            };
        };
        responses: {
            /** @description Configuration saved */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OidcAdminConfigResponse"];
                };
            };
            /** @description Invalid configuration */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
        };
    };
    deleteConfig: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Configuration deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getGroup: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Group found */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["GroupDetail"];
                };
            };
            /** @description Group not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["GroupDetail"];
                };
            };
        };
    };
    updateGroup: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateGroupRequest"];
            };
        };
        responses: {
            /** @description Group updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Group not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Cycle detected in group hierarchy */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    deleteGroup: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Group deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Group not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getByAppId: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                appId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppSettings"];
                };
            };
        };
    };
    update: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                appId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AppSettingsRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppSettings"];
                };
            };
        };
    };
    delete: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                appId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    searchGet: {
        parameters: {
            query?: {
                status?: string;
                timeFrom?: string;
                timeTo?: string;
                correlationId?: string;
                text?: string;
                routeId?: string;
                agentId?: string;
                processorType?: string;
                application?: string;
                environment?: string;
                offset?: number;
                limit?: number;
                sortField?: string;
                sortDir?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["SearchResultExecutionSummary"];
                };
            };
        };
    };
    searchPost: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SearchRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["SearchResultExecutionSummary"];
                };
            };
        };
    };
    ingestMetrics: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": string;
            };
        };
        responses: {
            /** @description Data accepted for processing */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Invalid payload */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Buffer full, retry later */
            503: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    ingestLogs: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["LogBatch"];
            };
        };
        responses: {
            /** @description Logs accepted for indexing */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    ingestChunks: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": string;
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    ingestEvents: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": string;
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    ingestDiagrams: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": string;
            };
        };
        responses: {
            /** @description Data accepted for processing */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    testExpression: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                application: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TestExpressionRequest"];
            };
        };
        responses: {
            /** @description Expression evaluated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["TestExpressionResponse"];
                };
            };
            /** @description No live agent available for this application */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["TestExpressionResponse"];
                };
            };
            /** @description Agent did not respond in time */
            504: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["TestExpressionResponse"];
                };
            };
        };
    };
    refresh: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RefreshRequest"];
            };
        };
        responses: {
            /** @description Token refreshed */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AuthTokenResponse"];
                };
            };
            /** @description Invalid refresh token */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
        };
    };
    callback: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CallbackRequest"];
            };
        };
        responses: {
            /** @description Authentication successful */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AuthTokenResponse"];
                };
            };
            /** @description OIDC authentication failed */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
            /** @description Account not provisioned */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
            /** @description OIDC not configured or disabled */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AuthTokenResponse"];
                };
            };
        };
    };
    login: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["LoginRequest"];
            };
        };
        responses: {
            /** @description Login successful */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AuthTokenResponse"];
                };
            };
            /** @description Invalid credentials */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
        };
    };
    replayExchange: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ReplayRequest"];
            };
        };
        responses: {
            /** @description Replay completed (check status for success/failure) */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ReplayResponse"];
                };
            };
            /** @description Agent not found or not connected */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ReplayResponse"];
                };
            };
            /** @description Agent did not respond in time */
            504: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ReplayResponse"];
                };
            };
        };
    };
    refresh_1: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AgentRefreshRequest"];
            };
        };
        responses: {
            /** @description New access token issued */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentRefreshResponse"];
                };
            };
            /** @description Invalid or expired refresh token */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentRefreshResponse"];
                };
            };
            /** @description Agent not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentRefreshResponse"];
                };
            };
        };
    };
    heartbeat: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["HeartbeatRequest"];
            };
        };
        responses: {
            /** @description Heartbeat accepted */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    deregister: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Agent deregistered */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Agent not registered */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    sendCommand: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CommandRequest"];
            };
        };
        responses: {
            /** @description Command accepted */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CommandSingleResponse"];
                };
            };
            /** @description Invalid command payload */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CommandSingleResponse"];
                };
            };
            /** @description Agent not registered */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CommandSingleResponse"];
                };
            };
        };
    };
    acknowledgeCommand: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                commandId: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["CommandAckRequest"];
            };
        };
        responses: {
            /** @description Command acknowledged */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Command not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    register: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AgentRegistrationRequest"];
            };
        };
        responses: {
            /** @description Agent registered successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentRegistrationResponse"];
                };
            };
            /** @description Invalid registration payload */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
            /** @description Missing or invalid bootstrap token */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentRegistrationResponse"];
                };
            };
        };
    };
    sendGroupCommand: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                group: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CommandRequest"];
            };
        };
        responses: {
            /** @description Commands dispatched and responses collected */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CommandGroupResponse"];
                };
            };
            /** @description Invalid command payload */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CommandGroupResponse"];
                };
            };
        };
    };
    broadcastCommand: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CommandRequest"];
            };
        };
        responses: {
            /** @description Commands accepted */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CommandBroadcastResponse"];
                };
            };
            /** @description Invalid command payload */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CommandBroadcastResponse"];
                };
            };
        };
    };
    listUsers: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description User list returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UserDetail"][];
                };
            };
        };
    };
    createUser: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateUserRequest"];
            };
        };
        responses: {
            /** @description User created */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UserDetail"];
                };
            };
        };
    };
    assignRoleToUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
                roleId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Role assigned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description User or role not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    removeRoleFromUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
                roleId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Role removed */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    resetPassword: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SetPasswordRequest"];
            };
        };
        responses: {
            /** @description Password reset */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    addUserToGroup: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
                groupId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description User added to group */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    removeUserFromGroup: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                userId: string;
                groupId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description User removed from group */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    listRoles: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Role list returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["RoleDetail"][];
                };
            };
        };
    };
    createRole: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateRoleRequest"];
            };
        };
        responses: {
            /** @description Role created */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
        };
    };
    testConnection: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Provider reachable */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OidcTestResult"];
                };
            };
            /** @description Provider unreachable or misconfigured */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
        };
    };
    listGroups: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Group list returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["GroupDetail"][];
                };
            };
        };
    };
    createGroup: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateGroupRequest"];
            };
        };
        responses: {
            /** @description Group created */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
        };
    };
    assignRoleToGroup: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                roleId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Role assigned to group */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Group not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    removeRoleFromGroup: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
                roleId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Role removed from group */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Group not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    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: {
                from: string;
                to?: string;
                routeId?: string;
                application?: string;
                environment?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ExecutionStats"];
                };
            };
        };
    };
    timeseries: {
        parameters: {
            query: {
                from: string;
                to?: string;
                buckets?: number;
                routeId?: string;
                application?: string;
                environment?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["StatsTimeseries"];
                };
            };
        };
    };
    timeseriesByRoute: {
        parameters: {
            query: {
                from: string;
                to?: string;
                buckets?: number;
                application: string;
                environment?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: components["schemas"]["StatsTimeseries"];
                    };
                };
            };
        };
    };
    timeseriesByApp: {
        parameters: {
            query: {
                from: string;
                to?: string;
                buckets?: number;
                environment?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: components["schemas"]["StatsTimeseries"];
                    };
                };
            };
        };
    };
    punchcard: {
        parameters: {
            query?: {
                application?: string;
                environment?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["PunchcardCell"][];
                };
            };
        };
    };
    topErrors: {
        parameters: {
            query: {
                from: string;
                to?: string;
                application?: string;
                routeId?: string;
                environment?: string;
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["TopError"][];
                };
            };
        };
    };
    attributeKeys: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": string[];
                };
            };
        };
    };
    getMetrics: {
        parameters: {
            query?: {
                from?: string;
                to?: string;
                appId?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Metrics returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["RouteMetrics"][];
                };
            };
        };
    };
    getProcessorMetrics: {
        parameters: {
            query: {
                routeId: string;
                appId?: string;
                from?: string;
                to?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Metrics returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ProcessorMetrics"][];
                };
            };
        };
    };
    getCatalog: {
        parameters: {
            query?: {
                from?: string;
                to?: string;
                environment?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Catalog returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppCatalogEntry"][];
                };
            };
        };
    };
    searchLogs: {
        parameters: {
            query?: {
                q?: string;
                query?: string;
                level?: string;
                application?: string;
                agentId?: string;
                exchangeId?: string;
                logger?: string;
                environment?: string;
                from?: string;
                to?: string;
                cursor?: string;
                limit?: number;
                sort?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["LogSearchPageResponse"];
                };
            };
        };
    };
    getDetail: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                executionId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Execution detail found */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ExecutionDetail"];
                };
            };
            /** @description Execution not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ExecutionDetail"];
                };
            };
        };
    };
    getProcessorSnapshot: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                executionId: string;
                index: number;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Snapshot data */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
            /** @description Snapshot not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
        };
    };
    processorSnapshotBySeq: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                executionId: string;
                seq: number;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Snapshot data */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
            /** @description Snapshot not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
        };
    };
    processorSnapshotById: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                executionId: string;
                processorId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Snapshot data */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
            /** @description Snapshot not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
        };
    };
    findByApplicationAndRoute: {
        parameters: {
            query: {
                application: string;
                routeId: string;
                direction?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Diagram layout returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["DiagramLayout"];
                };
            };
            /** @description No diagram found for the given application and route */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["DiagramLayout"];
                };
            };
        };
    };
    renderDiagram: {
        parameters: {
            query?: {
                direction?: string;
            };
            header?: never;
            path: {
                contentHash: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Diagram rendered successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "image/svg+xml": string;
                    "application/json": components["schemas"]["DiagramLayout"];
                };
            };
            /** @description Diagram not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    listConfigs: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Configs returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ApplicationConfig"][];
                };
            };
        };
    };
    getProcessorRouteMapping: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                application: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Mapping returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
        };
    };
    getConfig_2: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OIDC configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OidcPublicConfigResponse"];
                };
            };
            /** @description OIDC not configured or disabled */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OidcPublicConfigResponse"];
                };
            };
            /** @description Failed to retrieve OIDC provider metadata */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
        };
    };
    listAgents: {
        parameters: {
            query?: {
                status?: string;
                application?: string;
                environment?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Agent list returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentInstanceResponse"][];
                };
            };
            /** @description Invalid status filter */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ErrorResponse"];
                };
            };
        };
    };
    events: {
        parameters: {
            query?: never;
            header?: {
                /** @description Last received event ID (no replay, acknowledged only) */
                "Last-Event-ID"?: string;
            };
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description SSE stream opened */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": components["schemas"]["SseEmitter"];
                };
            };
            /** @description Agent not registered and cannot be auto-registered */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": components["schemas"]["SseEmitter"];
                };
            };
        };
    };
    getMetrics_1: {
        parameters: {
            query: {
                names: string;
                from?: string;
                to?: string;
                buckets?: number;
            };
            header?: never;
            path: {
                agentId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentMetricsResponse"];
                };
            };
        };
    };
    getEvents: {
        parameters: {
            query?: {
                appId?: string;
                agentId?: string;
                from?: string;
                to?: string;
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Events returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentEventResponse"][];
                };
            };
        };
    };
    getUsage: {
        parameters: {
            query?: {
                from?: string;
                to?: string;
                username?: string;
                groupBy?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UsageStats"][];
                };
            };
        };
    };
    getStats: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description RBAC stats returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["RbacStats"];
                };
            };
        };
    };
    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: {
        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"];
                };
            };
        };
    };
    getTables_1: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClickHouseTableInfo"][];
                };
            };
        };
    };
    getStatus_1: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClickHouseStatusResponse"];
                };
            };
        };
    };
    getQueries_1: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClickHouseQueryInfo"][];
                };
            };
        };
    };
    getPipeline: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["IndexerPipelineResponse"];
                };
            };
        };
    };
    getPerformance: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClickHousePerformanceResponse"];
                };
            };
        };
    };
    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"];
                };
            };
        };
    };
    getAll: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppSettings"][];
                };
            };
        };
    };
}