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

export interface paths {
    "/environments/{envSlug}/apps/{appSlug}/settings": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get settings for an application in this environment (returns defaults if not configured) */
        get: operations["getByAppId"];
        /** Create or update settings for an application in this environment */
        put: operations["update"];
        post?: never;
        /** Delete application settings for this environment (reverts to defaults) */
        delete: operations["delete"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/container-config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /** Update container config for this app */
        put: operations["updateContainerConfig"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get application config for this environment
         * @description Returns stored config merged with global sensitive keys. Falls back to defaults if no row is persisted yet.
         */
        get: operations["getConfig"];
        /**
         * Update application config for this environment
         * @description Saves config. When apply=live (default), also pushes CONFIG_UPDATE to LIVE agents. When apply=staged, persists without a live push — the next successful deploy applies it.
         */
        put: operations["updateConfig"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/silences/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put: operations["update_1"];
        post?: never;
        delete: operations["delete_1"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/rules/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["get"];
        put: operations["update_2"];
        post?: never;
        delete: operations["delete_2"];
        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/sensitive-keys": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get global sensitive keys configuration */
        get: operations["getSensitiveKeys"];
        /**
         * Update global sensitive keys configuration
         * @description Saves the global sensitive keys. Optionally fans out merged keys to all live agents.
         */
        put: operations["updateSensitiveKeys"];
        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/outbound-connections/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["get_1"];
        put: operations["update_3"];
        post?: never;
        delete: operations["delete_3"];
        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/environments/{envSlug}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get environment by slug */
        get: operations["getEnvironment"];
        /**
         * Update an environment's mutable fields (displayName, production, enabled, color)
         * @description Slug is immutable after creation and cannot be changed. Any slug field in the request body is ignored. If color is null or absent, the existing color is preserved.
         */
        put: operations["updateEnvironment"];
        post?: never;
        /** Delete an environment */
        delete: operations["deleteEnvironment"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/environments/{envSlug}/jar-retention": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /** Update JAR retention policy for an environment */
        put: operations["updateJarRetention"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/environments/{envSlug}/default-container-config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /** Update default container config for an environment */
        put: operations["updateDefaultContainerConfig"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/claim-mappings/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get a claim mapping rule by ID */
        get: operations["get_2"];
        /** Update a claim mapping rule */
        put: operations["update_4"];
        post?: never;
        /** Delete a claim mapping rule */
        delete: operations["delete_4"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/executions/search": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Advanced search with all filters
         * @description Env from the path overrides any environment field in the body.
         */
        post: operations["searchPost"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List apps in this environment */
        get: operations["listApps"];
        put?: never;
        /**
         * Create a new app in this environment
         * @description Slug must match ^[a-z0-9][a-z0-9-]{0,63}$ and be unique within the environment. Slug is immutable after creation.
         */
        post: operations["createApp"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/versions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List versions for this app */
        get: operations["listVersions"];
        put?: never;
        /** Upload a JAR for a new version of this app */
        post: operations["uploadJar"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/deployments": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List deployments for this app in this environment */
        get: operations["listDeployments"];
        put?: never;
        /** Create and start a new deployment for this app in this environment */
        post: operations["deploy"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/deployments/{deploymentId}/stop": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Stop a running deployment */
        post: operations["stop"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/deployments/{deploymentId}/promote": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Promote this deployment to a different environment
         * @description Target environment is specified by slug in the request body. The same app slug must exist in the target environment (or be created separately first).
         */
        post: operations["promote"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/config/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 in this environment */
        post: operations["testExpression"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/{id}/restore": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["restore"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/{id}/read": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["read"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/{id}/ack": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["ack"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/silences": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["list"];
        put?: never;
        post: operations["create"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/rules": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["list_1"];
        put?: never;
        post: operations["create_1"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/rules/{id}/test-evaluate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["testEvaluate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/rules/{id}/render-preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["renderPreview"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/rules/{id}/enable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["enable"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/rules/{id}/disable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["disable"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/bulk-read": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["bulkRead"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/bulk-delete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["bulkDelete"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/bulk-ack": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["bulkAck"];
        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;
    };
    "/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;
    };
    "/alerts/notifications/{id}/retry": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["retry"];
        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/server-metrics/query": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Generic time-series query
         * @description Returns bucketed series for a single metric_name. Supports aggregation (avg/sum/max/min/latest), group-by-tag, filter-by-tag, counter delta mode, and a derived 'mean' statistic for timers.
         */
        post: operations["query"];
        delete?: never;
        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/outbound-connections": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["list_2"];
        put?: never;
        post: operations["create_2"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/outbound-connections/{id}/test": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["test"];
        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/license": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get current license info */
        get: operations["getCurrent"];
        put?: never;
        /** Update license token at runtime */
        post: operations["update_5"];
        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/environments": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all environments */
        get: operations["listEnvironments"];
        put?: never;
        /** Create a new environment */
        post: operations["createEnvironment"];
        delete?: never;
        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;
    };
    "/admin/claim-mappings": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all claim mapping rules */
        get: operations["list_3"];
        put?: never;
        /** Create a claim mapping rule */
        post: operations["create_3"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/claim-mappings/test": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Test claim mapping rules against a set of claims (accepts unsaved rules) */
        post: operations["test_1"];
        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;
    };
    "/environments/{envSlug}/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;
    };
    "/environments/{envSlug}/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;
    };
    "/environments/{envSlug}/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;
    };
    "/environments/{envSlug}/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;
    };
    "/environments/{envSlug}/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;
    };
    "/environments/{envSlug}/routes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get route catalog for this environment
         * @description Returns all applications with their routes, agents, and health status — filtered to this environment
         */
        get: operations["getCatalog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/routes/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get route metrics for this environment
         * @description Returns aggregated performance metrics per route for the given time window. Optional appId filter narrows to a single application.
         */
        get: operations["getMetrics"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/routes/metrics/processors": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get processor metrics for this environment
         * @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;
    };
    "/environments/{envSlug}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search application log entries in this environment
         * @description Cursor-paginated log search scoped to the env in the path. Supports free-text search, multi-level filtering, and optional application/agent scoping.
         */
        get: operations["searchLogs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/executions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search executions with basic filters (env from path) */
        get: operations["searchGet"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/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;
    };
    "/environments/{envSlug}/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List application configs in this environment */
        get: operations["listConfigs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/attributes/keys": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Distinct attribute key names for this environment */
        get: operations["attributeKeys"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get app by env + slug */
        get: operations["getApp"];
        put?: never;
        post?: never;
        /** Delete this app */
        delete: operations["deleteApp"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/routes/{routeId}/diagram": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Find the latest diagram for this app's route in this environment
         * @description Returns the most recently stored diagram for (app, env, route). Independent of the agent registry, so routes removed from the current app version still resolve.
         */
        get: operations["findByAppAndRoute"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/processor-routes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get processor to route mapping for this environment
         * @description Returns a map of processorId → routeId for all processors seen in this application + environment
         */
        get: operations["getProcessorRouteMapping"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/dirty-state": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Check whether the app's current config differs from the last successful deploy
         * @description Returns dirty=true when the desired state (current JAR + agent config + container config) would produce a changed deployment. When no successful deploy exists yet, dirty=true.
         */
        get: operations["getDirtyState"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/deployments/{deploymentId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get deployment by ID */
        get: operations["getDeployment"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/apps/{appSlug}/deployments/{deploymentId}/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get container logs for this deployment */
        get: operations["getLogs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/app-settings": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List application settings in this environment */
        get: operations["getAll"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["list_4"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["get_3"];
        put?: never;
        post?: never;
        delete: operations["delete_5"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/{alertId}/notifications": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["listForInstance"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/alerts/unread-count": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["unreadCount"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/environments/{envSlug}/agents": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all agents in this environment
         * @description Returns 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;
    };
    "/environments/{envSlug}/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;
    };
    "/environments/{envSlug}/agents/events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Query agent events in this environment
         * @description Cursor-paginated. Returns newest first. Pass nextCursor back as ?cursor= for the next page.
         */
        get: operations["getEvents"];
        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 by content hash
         * @description Returns SVG (default) or JSON layout based on Accept header. Content hashes are globally unique, so this endpoint is intentionally flat (no env).
         */
        get: operations["renderDiagram"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/catalog": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get unified catalog
         * @description Returns all applications (managed + unmanaged) with live agent data, routes, and deployment status
         */
        get: operations["getCatalog_1"];
        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;
    };
    "/auth/me": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get current user details */
        get: operations["me"];
        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/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get application config for the calling agent
         * @description Resolves (application, environment) from the agent's JWT + registry. Prefers the registry entry (heartbeat-authoritative); falls back to the JWT env claim. Returns 404 if neither identifies a valid agent.
         */
        get: operations["getConfigForAgent"];
        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/server-metrics/instances": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List server_instance_id values observed in the window
         * @description Returns first/last seen timestamps — use to partition counter-delta computations.
         */
        get: operations["instances"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/admin/server-metrics/catalog": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List metric names observed in the window
         * @description For each metric_name, returns metric_type, the set of statistics emitted, and the union of tag keys.
         */
        get: operations["catalog"];
        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/outbound-connections/{id}/usage": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["usage"];
        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/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;
    };
    "/catalog/{applicationId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /** Dismiss application and purge all data */
        delete: operations["dismissApplication"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        Environment: {
            /** Format: uuid */
            id?: string;
            slug?: string;
            displayName?: string;
            production?: boolean;
            enabled?: boolean;
            defaultContainerConfig?: {
                [key: string]: Record<string, never>;
            };
            /** Format: int32 */
            jarRetentionCount?: number;
            color?: string;
            /** Format: date-time */
            createdAt?: 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;
            environment?: 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;
        };
        ApplicationConfig: {
            application?: string;
            environment?: 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;
            };
            sensitiveKeys?: string[];
            /** Format: int32 */
            exportBatchSize?: number;
            /** Format: int32 */
            exportQueueSize?: number;
            /** Format: int64 */
            exportFlushIntervalMs?: number;
            exportOverflowMode?: string;
            /** Format: int64 */
            exportBlockTimeoutMs?: number;
            /** Format: int32 */
            flushRecordThreshold?: 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"];
        };
        AlertSilenceRequest: {
            matcher: components["schemas"]["SilenceMatcher"];
            reason?: string;
            /** Format: date-time */
            startsAt: string;
            /** Format: date-time */
            endsAt: string;
        };
        SilenceMatcher: {
            /** Format: uuid */
            ruleId?: string;
            appSlug?: string;
            routeId?: string;
            agentId?: string;
            /** @enum {string} */
            severity?: "CRITICAL" | "WARNING" | "INFO";
            wildcard?: boolean;
        };
        AlertSilenceResponse: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            environmentId?: string;
            matcher?: components["schemas"]["SilenceMatcher"];
            reason?: string;
            /** Format: date-time */
            startsAt?: string;
            /** Format: date-time */
            endsAt?: string;
            createdBy?: string;
            /** Format: date-time */
            createdAt?: string;
        };
        AgentLifecycleCondition: {
            kind: "AgentLifecycleCondition";
        } & (Omit<components["schemas"]["AlertCondition"], "kind"> & {
            scope?: components["schemas"]["AlertScope"];
            eventTypes?: ("REGISTERED" | "RE_REGISTERED" | "DEREGISTERED" | "WENT_STALE" | "WENT_DEAD" | "RECOVERED")[];
            /** Format: int32 */
            withinSeconds?: number;
            /** @enum {string} */
            readonly kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        });
        AgentStateCondition: {
            kind: "AgentStateCondition";
        } & (Omit<components["schemas"]["AlertCondition"], "kind"> & {
            scope?: components["schemas"]["AlertScope"];
            state?: string;
            /** Format: int32 */
            forSeconds?: number;
            /** @enum {string} */
            readonly kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        });
        AlertCondition: {
            /** @enum {string} */
            kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        };
        AlertRuleRequest: {
            name?: string;
            description?: string;
            /** @enum {string} */
            severity: "CRITICAL" | "WARNING" | "INFO";
            /** @enum {string} */
            conditionKind: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
            condition: components["schemas"]["AgentLifecycleCondition"] | components["schemas"]["AgentStateCondition"] | components["schemas"]["DeploymentStateCondition"] | components["schemas"]["ExchangeMatchCondition"] | components["schemas"]["JvmMetricCondition"] | components["schemas"]["LogPatternCondition"] | components["schemas"]["RouteMetricCondition"];
            /** Format: int32 */
            evaluationIntervalSeconds?: number;
            /** Format: int32 */
            forDurationSeconds?: number;
            /** Format: int32 */
            reNotifyMinutes?: number;
            notificationTitleTmpl?: string;
            notificationMessageTmpl?: string;
            webhooks?: components["schemas"]["WebhookBindingRequest"][];
            targets?: components["schemas"]["AlertRuleTarget"][];
        };
        AlertRuleTarget: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            ruleId?: string;
            /** @enum {string} */
            kind?: "USER" | "GROUP" | "ROLE";
            targetId?: string;
        };
        AlertScope: {
            appSlug?: string;
            routeId?: string;
            agentId?: string;
        };
        DeploymentStateCondition: {
            kind: "DeploymentStateCondition";
        } & (Omit<components["schemas"]["AlertCondition"], "kind"> & {
            scope?: components["schemas"]["AlertScope"];
            states?: string[];
            /** @enum {string} */
            readonly kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        });
        ExchangeFilter: {
            status?: string;
            attributes?: {
                [key: string]: string;
            };
        };
        ExchangeMatchCondition: {
            kind: "ExchangeMatchCondition";
        } & (Omit<components["schemas"]["AlertCondition"], "kind"> & {
            scope?: components["schemas"]["AlertScope"];
            filter?: components["schemas"]["ExchangeFilter"];
            /** @enum {string} */
            fireMode?: "PER_EXCHANGE" | "COUNT_IN_WINDOW";
            /** Format: int32 */
            threshold?: number;
            /** Format: int32 */
            windowSeconds?: number;
            /** @enum {string} */
            readonly kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        });
        JvmMetricCondition: {
            kind: "JvmMetricCondition";
        } & (Omit<components["schemas"]["AlertCondition"], "kind"> & {
            scope?: components["schemas"]["AlertScope"];
            metric?: string;
            /** @enum {string} */
            aggregation?: "MAX" | "MIN" | "AVG" | "LATEST";
            /** @enum {string} */
            comparator?: "GT" | "GTE" | "LT" | "LTE" | "EQ";
            /** Format: double */
            threshold?: number;
            /** Format: int32 */
            windowSeconds?: number;
            /** @enum {string} */
            readonly kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        });
        LogPatternCondition: {
            kind: "LogPatternCondition";
        } & (Omit<components["schemas"]["AlertCondition"], "kind"> & {
            scope?: components["schemas"]["AlertScope"];
            level?: string;
            pattern?: string;
            /** Format: int32 */
            threshold?: number;
            /** Format: int32 */
            windowSeconds?: number;
            /** @enum {string} */
            readonly kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        });
        RouteMetricCondition: {
            kind: "RouteMetricCondition";
        } & (Omit<components["schemas"]["AlertCondition"], "kind"> & {
            scope?: components["schemas"]["AlertScope"];
            /** @enum {string} */
            metric?: "ERROR_RATE" | "AVG_DURATION_MS" | "P99_LATENCY_MS" | "THROUGHPUT" | "ERROR_COUNT";
            /** @enum {string} */
            comparator?: "GT" | "GTE" | "LT" | "LTE" | "EQ";
            /** Format: double */
            threshold?: number;
            /** Format: int32 */
            windowSeconds?: number;
            /** @enum {string} */
            readonly kind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
        });
        WebhookBindingRequest: {
            /** Format: uuid */
            outboundConnectionId: string;
            bodyOverride?: string;
            headerOverrides?: {
                [key: string]: string;
            };
        };
        AlertRuleResponse: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            environmentId?: string;
            name?: string;
            description?: string;
            /** @enum {string} */
            severity?: "CRITICAL" | "WARNING" | "INFO";
            enabled?: boolean;
            /** @enum {string} */
            conditionKind?: "ROUTE_METRIC" | "EXCHANGE_MATCH" | "AGENT_STATE" | "AGENT_LIFECYCLE" | "DEPLOYMENT_STATE" | "LOG_PATTERN" | "JVM_METRIC";
            condition?: components["schemas"]["AgentLifecycleCondition"] | components["schemas"]["AgentStateCondition"] | components["schemas"]["DeploymentStateCondition"] | components["schemas"]["ExchangeMatchCondition"] | components["schemas"]["JvmMetricCondition"] | components["schemas"]["LogPatternCondition"] | components["schemas"]["RouteMetricCondition"];
            /** Format: int32 */
            evaluationIntervalSeconds?: number;
            /** Format: int32 */
            forDurationSeconds?: number;
            /** Format: int32 */
            reNotifyMinutes?: number;
            notificationTitleTmpl?: string;
            notificationMessageTmpl?: string;
            webhooks?: components["schemas"]["WebhookBindingResponse"][];
            targets?: components["schemas"]["AlertRuleTarget"][];
            /** Format: date-time */
            createdAt?: string;
            createdBy?: string;
            /** Format: date-time */
            updatedAt?: string;
            updatedBy?: string;
        };
        WebhookBindingResponse: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            outboundConnectionId?: string;
            bodyOverride?: string;
            headerOverrides?: {
                [key: string]: string;
            };
        };
        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"];
        };
        /** @description Global sensitive keys configuration */
        SensitiveKeysRequest: {
            /** @description List of key names or glob patterns to mask */
            keys: string[];
        };
        SensitiveKeysResponse: {
            keys?: string[];
            pushResult?: components["schemas"]["CommandGroupResponse"];
        };
        UpdateRoleRequest: {
            name?: string;
            description?: string;
            scope?: string;
        };
        Basic: components["schemas"]["OutboundAuth"] & {
            username?: string;
            passwordCiphertext?: string;
        };
        Bearer: components["schemas"]["OutboundAuth"] & {
            tokenCiphertext?: string;
        };
        None: components["schemas"]["OutboundAuth"];
        OutboundAuth: Record<string, never>;
        OutboundConnectionRequest: {
            name?: string;
            description?: string;
            url?: string;
            /** @enum {string} */
            method: "POST" | "PUT" | "PATCH";
            defaultHeaders?: {
                [key: string]: string;
            };
            defaultBodyTmpl?: string;
            /** @enum {string} */
            tlsTrustMode: "SYSTEM_DEFAULT" | "TRUST_ALL" | "TRUST_PATHS";
            tlsCaPemPaths?: string[];
            hmacSecret?: string;
            auth: components["schemas"]["Basic"] | components["schemas"]["Bearer"] | components["schemas"]["None"];
            allowedEnvironmentIds?: string[];
        };
        OutboundConnectionDto: {
            /** Format: uuid */
            id?: string;
            name?: string;
            description?: string;
            url?: string;
            /** @enum {string} */
            method?: "POST" | "PUT" | "PATCH";
            defaultHeaders?: {
                [key: string]: string;
            };
            defaultBodyTmpl?: string;
            /** @enum {string} */
            tlsTrustMode?: "SYSTEM_DEFAULT" | "TRUST_ALL" | "TRUST_PATHS";
            tlsCaPemPaths?: string[];
            hmacSecretSet?: boolean;
            /** @enum {string} */
            authKind?: "NONE" | "BEARER" | "BASIC";
            allowedEnvironmentIds?: string[];
            /** Format: date-time */
            createdAt?: string;
            createdBy?: string;
            /** Format: date-time */
            updatedAt?: string;
            updatedBy?: 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;
        };
        UpdateEnvironmentRequest: {
            displayName?: string;
            production?: boolean;
            enabled?: boolean;
            color?: string;
        };
        JarRetentionRequest: {
            /** Format: int32 */
            jarRetentionCount?: number;
        };
        CreateRuleRequest: {
            claim?: string;
            matchType?: string;
            matchValue?: string;
            action?: string;
            target?: string;
            /** Format: int32 */
            priority?: number;
        };
        ClaimMappingRule: {
            /** Format: uuid */
            id?: string;
            claim?: string;
            matchType?: string;
            matchValue?: string;
            action?: string;
            target?: string;
            /** Format: int32 */
            priority?: number;
            /** Format: date-time */
            createdAt?: string;
        };
        AttributeFilter: {
            key?: string;
            value?: string;
            keyOnly?: boolean;
            wildcard?: boolean;
        };
        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;
            afterExecutionId?: string;
            environment?: string;
            attributeFilters?: components["schemas"]["AttributeFilter"][];
        };
        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;
        };
        CreateAppRequest: {
            slug?: string;
            displayName?: string;
        };
        AppVersion: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            appId?: string;
            /** Format: int32 */
            version?: number;
            jarPath?: string;
            jarChecksum?: string;
            jarFilename?: string;
            /** Format: int64 */
            jarSizeBytes?: number;
            detectedRuntimeType?: string;
            detectedMainClass?: string;
            /** Format: date-time */
            uploadedAt?: string;
        };
        DeployRequest: {
            /** Format: uuid */
            appVersionId?: string;
        };
        Deployment: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            appId?: string;
            /** Format: uuid */
            appVersionId?: string;
            /** Format: uuid */
            environmentId?: string;
            /** @enum {string} */
            status?: "STOPPED" | "STARTING" | "RUNNING" | "DEGRADED" | "STOPPING" | "FAILED";
            targetState?: string;
            deploymentStrategy?: string;
            replicaStates?: {
                [key: string]: Record<string, never>;
            }[];
            deployStage?: string;
            containerId?: string;
            containerName?: string;
            errorMessage?: string;
            resolvedConfig?: {
                [key: string]: Record<string, never>;
            };
            deployedConfigSnapshot?: components["schemas"]["DeploymentConfigSnapshot"];
            /** Format: date-time */
            deployedAt?: string;
            /** Format: date-time */
            stoppedAt?: string;
            /** Format: date-time */
            createdAt?: string;
            createdBy?: string;
        };
        DeploymentConfigSnapshot: {
            /** Format: uuid */
            jarVersionId?: string;
            agentConfig?: components["schemas"]["ApplicationConfig"];
            containerConfig?: {
                [key: string]: Record<string, never>;
            };
            sensitiveKeys?: string[];
        };
        PromoteRequest: {
            targetEnvironment?: string;
        };
        TestExpressionRequest: {
            expression?: string;
            language?: string;
            body?: string;
            target?: string;
        };
        TestExpressionResponse: {
            result?: string;
            error?: string;
        };
        AlertDto: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            ruleId?: string;
            /** Format: uuid */
            environmentId?: string;
            /** @enum {string} */
            state?: "PENDING" | "FIRING" | "RESOLVED";
            /** @enum {string} */
            severity?: "CRITICAL" | "WARNING" | "INFO";
            title?: string;
            message?: string;
            /** Format: date-time */
            firedAt?: string;
            /** Format: date-time */
            ackedAt?: string;
            ackedBy?: string;
            /** Format: date-time */
            resolvedAt?: string;
            /** Format: date-time */
            readAt?: string;
            silenced?: boolean;
            /** Format: double */
            currentValue?: number;
            /** Format: double */
            threshold?: number;
            context?: {
                [key: string]: Record<string, never>;
            };
        };
        TestEvaluateRequest: Record<string, never>;
        TestEvaluateResponse: {
            resultKind?: string;
            detail?: string;
        };
        RenderPreviewRequest: {
            context?: {
                [key: string]: Record<string, never>;
            };
        };
        RenderPreviewResponse: {
            title?: string;
            message?: string;
        };
        BulkIdsRequest: {
            instanceIds: string[];
        };
        LogEntry: {
            /** Format: date-time */
            timestamp?: string;
            level?: string;
            loggerName?: string;
            message?: string;
            threadName?: string;
            stackTrace?: string;
            mdc?: {
                [key: string]: string;
            };
            source?: 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;
        };
        AlertNotificationDto: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            alertInstanceId?: string;
            /** Format: uuid */
            webhookId?: string;
            /** Format: uuid */
            outboundConnectionId?: string;
            /** @enum {string} */
            status?: "PENDING" | "DELIVERED" | "FAILED";
            /** Format: int32 */
            attempts?: number;
            /** Format: date-time */
            nextAttemptAt?: string;
            /** Format: int32 */
            lastResponseStatus?: number;
            lastResponseSnippet?: string;
            /** Format: date-time */
            deliveredAt?: string;
            /** Format: date-time */
            createdAt?: 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;
            /** @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;
        };
        SetPasswordRequest: {
            password?: string;
        };
        QueryBody: {
            metric?: string;
            statistic?: string;
            from?: string;
            to?: string;
            /** Format: int32 */
            stepSeconds?: number;
            groupByTags?: string[];
            filterTags?: {
                [key: string]: string;
            };
            aggregation?: string;
            mode?: string;
            serverInstanceIds?: string[];
        };
        ServerMetricPoint: {
            /** Format: date-time */
            t?: string;
            /** Format: double */
            v?: number;
        };
        ServerMetricQueryResponse: {
            metric?: string;
            statistic?: string;
            aggregation?: string;
            mode?: string;
            /** Format: int32 */
            stepSeconds?: number;
            series?: components["schemas"]["ServerMetricSeries"][];
        };
        ServerMetricSeries: {
            tags?: {
                [key: string]: string;
            };
            points?: components["schemas"]["ServerMetricPoint"][];
        };
        CreateRoleRequest: {
            name?: string;
            description?: string;
            scope?: string;
        };
        OutboundConnectionTestResult: {
            /** Format: int32 */
            status?: number;
            /** Format: int64 */
            latencyMs?: number;
            responseSnippet?: string;
            tlsProtocol?: string;
            tlsCipherSuite?: string;
            peerCertificateSubject?: string;
            /** Format: int64 */
            peerCertificateExpiresAtEpochMs?: number;
            error?: string;
        };
        /** @description OIDC provider connectivity test result */
        OidcTestResult: {
            status: string;
            authorizationEndpoint: string;
        };
        UpdateLicenseRequest: {
            token?: string;
        };
        CreateGroupRequest: {
            name?: string;
            /** Format: uuid */
            parentGroupId?: string;
        };
        CreateEnvironmentRequest: {
            slug?: string;
            displayName?: string;
            production?: boolean;
        };
        TestRequest: {
            rules?: components["schemas"]["TestRuleRequest"][];
            claims?: {
                [key: string]: Record<string, never>;
            };
        };
        TestRuleRequest: {
            id?: string;
            claim?: string;
            matchType?: string;
            matchValue?: string;
            action?: string;
            target?: string;
            /** Format: int32 */
            priority?: number;
        };
        MatchedRuleResponse: {
            ruleId?: string;
            /** Format: int32 */
            priority?: number;
            claim?: string;
            matchType?: string;
            matchValue?: string;
            action?: string;
            target?: string;
        };
        TestResponse: {
            matchedRules?: components["schemas"]["MatchedRuleResponse"][];
            effectiveRoles?: string[];
            effectiveGroups?: string[];
            fallback?: boolean;
        };
        ExecutionDetail: {
            executionId: string;
            routeId: string;
            instanceId: string;
            applicationId: string;
            environment: 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"][];
        };
        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;
        };
        /** @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 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 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 source: app or agent */
            source?: 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;
            };
        };
        TopError: {
            errorType?: string;
            routeId?: string;
            processorId?: string;
            /** Format: int64 */
            count?: number;
            /** Format: double */
            velocity?: number;
            trend?: string;
            /** Format: date-time */
            lastSeen?: string;
        };
        App: {
            /** Format: uuid */
            id?: string;
            /** Format: uuid */
            environmentId?: string;
            slug?: string;
            displayName?: string;
            containerConfig?: {
                [key: string]: Record<string, never>;
            };
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            updatedAt?: string;
        };
        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;
        };
        Difference: {
            field?: string;
            staged?: string;
            deployed?: string;
        };
        DirtyStateResponse: {
            dirty?: boolean;
            lastSuccessfulDeploymentId?: string;
            differences?: components["schemas"]["Difference"][];
        };
        AppConfigResponse: {
            config?: components["schemas"]["ApplicationConfig"];
            globalSensitiveKeys?: string[];
            mergedSensitiveKeys?: string[];
        };
        UnreadCountResponse: {
            /** Format: int64 */
            total?: number;
            bySeverity?: {
                [key: string]: number;
            };
        };
        /** @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
             * @description Recent average CPU usage (0.0–1.0), -1 if unavailable
             */
            cpuUsage: number;
        };
        AgentMetricsResponse: {
            metrics: {
                [key: string]: components["schemas"]["MetricBucket"][];
            };
        };
        MetricBucket: {
            /** Format: date-time */
            time: string;
            /** Format: double */
            value: number;
        };
        /** @description Cursor-paginated agent event list */
        AgentEventPageResponse: {
            data?: components["schemas"]["AgentEventResponse"][];
            nextCursor?: string;
            hasMore?: boolean;
        };
        /** @description Agent lifecycle event */
        AgentEventResponse: {
            /** Format: int64 */
            id: number;
            instanceId: string;
            applicationId: string;
            eventType: string;
            detail: string;
            /** Format: date-time */
            timestamp: string;
        };
        /** @description Unified catalog entry combining app records with live agent data */
        CatalogApp: {
            /** @description Application slug (universal identifier) */
            slug?: string;
            /** @description Display name */
            displayName?: string;
            /** @description True if a managed App record exists in the database */
            managed?: boolean;
            /** @description Environment slug */
            environmentSlug?: string;
            /** @description Composite health: deployment status + agent health */
            health?: string;
            /** @description Human-readable tooltip explaining the health state */
            healthTooltip?: string;
            /**
             * Format: int32
             * @description Number of connected agents
             */
            agentCount?: number;
            /** @description Live routes from agents */
            routes?: components["schemas"]["RouteSummary"][];
            /** @description Connected agent summaries */
            agents?: components["schemas"]["AgentSummary"][];
            /**
             * Format: int64
             * @description Total exchange count from ClickHouse
             */
            exchangeCount?: number;
            /** @description Active deployment info, null if no deployment */
            deployment?: components["schemas"]["DeploymentSummary"];
        };
        DeploymentSummary: {
            status?: string;
            replicas?: string;
            /** Format: int32 */
            version?: number;
        };
        /** @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[];
        };
        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"][];
        };
        SseEmitter: {
            /** Format: int64 */
            timeout?: number;
        };
        UsageStats: {
            key?: string;
            /** Format: int64 */
            count?: number;
            /** Format: int64 */
            avgDurationMs?: number;
        };
        ServerInstanceInfo: {
            serverInstanceId?: string;
            /** Format: date-time */
            firstSeen?: string;
            /** Format: date-time */
            lastSeen?: string;
        };
        ServerMetricCatalogEntry: {
            metricName?: string;
            metricType?: string;
            statistics?: string[];
            tagKeys?: string[];
        };
        SensitiveKeysConfig: {
            keys?: string[];
        };
        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;
        };
        LicenseInfo: {
            tier?: string;
            features?: ("topology" | "lineage" | "correlation" | "debugger" | "replay")[];
            limits?: {
                [key: string]: number;
            };
            /** Format: date-time */
            issuedAt?: string;
            /** Format: date-time */
            expiresAt?: string;
            expired?: boolean;
        };
        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 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" | "OUTBOUND_CONNECTION_CHANGE" | "OUTBOUND_HTTP_TRUST_CHANGE" | "ALERT_RULE_CHANGE" | "ALERT_SILENCE_CHANGE" | "DEPLOYMENT";
            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 {
    getByAppId: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppSettings"];
                };
            };
        };
    };
    update: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: 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: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    updateContainerConfig: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    [key: string]: Record<string, never>;
                };
            };
        };
        responses: {
            /** @description Container config updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Invalid configuration */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description App not found in this environment */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    getConfig: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Config returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppConfigResponse"];
                };
            };
        };
    };
    updateConfig: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                /** @description When to apply: 'live' (default) saves and pushes CONFIG_UPDATE to live agents immediately; 'staged' saves without pushing — the next successful deploy applies it. */
                apply?: string;
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ApplicationConfig"];
            };
        };
        responses: {
            /** @description Config saved (and pushed if apply=live) */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ConfigUpdateResponse"];
                };
            };
            /** @description Unknown apply value (must be 'staged' or 'live') */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ConfigUpdateResponse"];
                };
            };
        };
    };
    update_1: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AlertSilenceRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertSilenceResponse"];
                };
            };
        };
    };
    delete_1: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    get: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertRuleResponse"];
                };
            };
        };
    };
    update_2: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AlertRuleRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertRuleResponse"];
                };
            };
        };
    };
    delete_2: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    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;
            };
            /** @description Cannot delete the last admin user */
            409: {
                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"];
                };
            };
        };
    };
    getSensitiveKeys: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["SensitiveKeysConfig"];
                };
            };
        };
    };
    updateSensitiveKeys: {
        parameters: {
            query?: {
                pushToAgents?: boolean;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SensitiveKeysRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["SensitiveKeysResponse"];
                };
            };
        };
    };
    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;
            };
        };
    };
    get_1: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OutboundConnectionDto"];
                };
            };
        };
    };
    update_3: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["OutboundConnectionRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OutboundConnectionDto"];
                };
            };
        };
    };
    delete_3: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                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;
            };
        };
    };
    getEnvironment: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                envSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Environment found */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Environment"];
                };
            };
            /** @description Environment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Environment"];
                };
            };
        };
    };
    updateEnvironment: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                envSlug: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateEnvironmentRequest"];
            };
        };
        responses: {
            /** @description Environment updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Unknown color value */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Environment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    deleteEnvironment: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                envSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Environment deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Cannot delete default environment */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Environment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    updateJarRetention: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                envSlug: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["JarRetentionRequest"];
            };
        };
        responses: {
            /** @description Retention policy updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Environment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    updateDefaultContainerConfig: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                envSlug: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    [key: string]: Record<string, never>;
                };
            };
        };
        responses: {
            /** @description Default container config updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Invalid configuration */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Environment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    get_2: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClaimMappingRule"];
                };
            };
        };
    };
    update_4: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateRuleRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClaimMappingRule"];
                };
            };
        };
    };
    delete_4: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    searchPost: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            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"];
                };
            };
        };
    };
    listApps: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description App list returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["App"][];
                };
            };
        };
    };
    createApp: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateAppRequest"];
            };
        };
        responses: {
            /** @description App created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Invalid slug, or slug already exists in this environment */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    listVersions: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Version list returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppVersion"][];
                };
            };
        };
    };
    uploadJar: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "multipart/form-data": {
                    env?: components["schemas"]["Environment"];
                    /** Format: binary */
                    file: string;
                };
            };
        };
        responses: {
            /** @description JAR uploaded and version created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppVersion"];
                };
            };
            /** @description App not found in this environment */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppVersion"];
                };
            };
        };
    };
    listDeployments: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Deployment list returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Deployment"][];
                };
            };
        };
    };
    deploy: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["DeployRequest"];
            };
        };
        responses: {
            /** @description Deployment accepted and starting */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Deployment"];
                };
            };
        };
    };
    stop: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
                deploymentId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Deployment stopped */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Deployment"];
                };
            };
            /** @description Deployment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Deployment"];
                };
            };
        };
    };
    promote: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
                deploymentId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PromoteRequest"];
            };
        };
        responses: {
            /** @description Promotion accepted and starting */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Deployment or target environment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    testExpression: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: 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 in this environment */
            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"];
                };
            };
        };
    };
    restore: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    read: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    ack: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertDto"];
                };
            };
        };
    };
    list: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertSilenceResponse"][];
                };
            };
        };
    };
    create: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AlertSilenceRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertSilenceResponse"];
                };
            };
        };
    };
    list_1: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertRuleResponse"][];
                };
            };
        };
    };
    create_1: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AlertRuleRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertRuleResponse"];
                };
            };
        };
    };
    testEvaluate: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TestEvaluateRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["TestEvaluateResponse"];
                };
            };
        };
    };
    renderPreview: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RenderPreviewRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["RenderPreviewResponse"];
                };
            };
        };
    };
    enable: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertRuleResponse"];
                };
            };
        };
    };
    disable: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertRuleResponse"];
                };
            };
        };
    };
    bulkRead: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["BulkIdsRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    bulkDelete: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["BulkIdsRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    bulkAck: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["BulkIdsRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    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"]["LogEntry"][];
            };
        };
        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;
            };
        };
    };
    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"];
                };
            };
            /** @description Account locked due to too many failed attempts */
            429: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AuthTokenResponse"];
                };
            };
        };
    };
    retry: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertNotificationDto"];
                };
            };
        };
    };
    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?: {
                environment?: string;
            };
            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?: {
                environment?: string;
            };
            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: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Disabled in OIDC mode */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    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;
            };
            /** @description Disabled in OIDC mode or policy violation */
            400: {
                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;
            };
        };
    };
    query: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["QueryBody"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ServerMetricQueryResponse"];
                };
            };
        };
    };
    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;
                    };
                };
            };
        };
    };
    list_2: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OutboundConnectionDto"][];
                };
            };
        };
    };
    create_2: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["OutboundConnectionRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OutboundConnectionDto"];
                };
            };
        };
    };
    test: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["OutboundConnectionTestResult"];
                };
            };
        };
    };
    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"];
                };
            };
        };
    };
    getCurrent: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["LicenseInfo"];
                };
            };
        };
    };
    update_5: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateLicenseRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    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;
            };
        };
    };
    listEnvironments: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Environment"][];
                };
            };
        };
    };
    createEnvironment: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateEnvironmentRequest"];
            };
        };
        responses: {
            /** @description Environment created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
            /** @description Invalid slug or slug already exists */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": Record<string, never>;
                };
            };
        };
    };
    killQuery: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                pid: number;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    list_3: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClaimMappingRule"][];
                };
            };
        };
    };
    create_3: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateRuleRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ClaimMappingRule"];
                };
            };
        };
    };
    test_1: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TestRequest"];
            };
        };
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["TestResponse"];
                };
            };
        };
    };
    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;
                    };
                };
            };
        };
    };
    stats: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                from: string;
                to?: string;
                routeId?: string;
                application?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ExecutionStats"];
                };
            };
        };
    };
    timeseries: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                from: string;
                to?: string;
                buckets?: number;
                routeId?: string;
                application?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["StatsTimeseries"];
                };
            };
        };
    };
    timeseriesByRoute: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                from: string;
                to?: string;
                buckets?: number;
                application: 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: {
                env: components["schemas"]["Environment"];
                from: string;
                to?: string;
                buckets?: number;
            };
            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: {
                env: components["schemas"]["Environment"];
                application?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["PunchcardCell"][];
                };
            };
        };
    };
    getCatalog: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                from?: string;
                to?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Catalog returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppCatalogEntry"][];
                };
            };
        };
    };
    getMetrics: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                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: {
                env: components["schemas"]["Environment"];
                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"][];
                };
            };
        };
    };
    searchLogs: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                q?: string;
                query?: string;
                level?: string;
                application?: string;
                agentId?: string;
                exchangeId?: string;
                logger?: string;
                source?: string;
                instanceIds?: 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"];
                };
            };
        };
    };
    searchGet: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                status?: string;
                timeFrom?: string;
                timeTo?: string;
                correlationId?: string;
                text?: string;
                routeId?: string;
                agentId?: string;
                processorType?: string;
                application?: string;
                attr?: 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"];
                };
            };
        };
    };
    topErrors: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                from: string;
                to?: string;
                application?: string;
                routeId?: string;
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["TopError"][];
                };
            };
        };
    };
    listConfigs: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Configs returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ApplicationConfig"][];
                };
            };
        };
    };
    attributeKeys: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": string[];
                };
            };
        };
    };
    getApp: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description App found */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["App"];
                };
            };
            /** @description App not found in this environment */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["App"];
                };
            };
        };
    };
    deleteApp: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description App deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    findByAppAndRoute: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                direction?: string;
            };
            header?: never;
            path: {
                appSlug: string;
                routeId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Diagram layout returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["DiagramLayout"];
                };
            };
            /** @description No diagram found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["DiagramLayout"];
                };
            };
        };
    };
    getProcessorRouteMapping: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Mapping returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": {
                        [key: string]: string;
                    };
                };
            };
        };
    };
    getDirtyState: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Dirty-state computed */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["DirtyStateResponse"];
                };
            };
            /** @description App not found in this environment */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["DirtyStateResponse"];
                };
            };
        };
    };
    getDeployment: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
                deploymentId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Deployment found */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Deployment"];
                };
            };
            /** @description Deployment not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["Deployment"];
                };
            };
        };
    };
    getLogs: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                appSlug: string;
                deploymentId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Logs returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": string[];
                };
            };
            /** @description Deployment not found or no container */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": string[];
                };
            };
        };
    };
    getAll: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppSettings"][];
                };
            };
        };
    };
    list_4: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                limit?: number;
                state?: ("PENDING" | "FIRING" | "RESOLVED")[];
                severity?: ("CRITICAL" | "WARNING" | "INFO")[];
                acked?: boolean;
                read?: boolean;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertDto"][];
                };
            };
        };
    };
    get_3: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertDto"];
                };
            };
        };
    };
    delete_5: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    listForInstance: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path: {
                alertId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AlertNotificationDto"][];
                };
            };
        };
    };
    unreadCount: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UnreadCountResponse"];
                };
            };
        };
    };
    listAgents: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                status?: string;
                application?: 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"];
                };
            };
        };
    };
    getMetrics_1: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                names: string;
                from?: string;
                to?: string;
                buckets?: number;
                mode?: string;
            };
            header?: never;
            path: {
                agentId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentMetricsResponse"];
                };
            };
        };
    };
    getEvents: {
        parameters: {
            query: {
                env: components["schemas"]["Environment"];
                appId?: string;
                agentId?: string;
                from?: string;
                to?: string;
                cursor?: string;
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Event page returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AgentEventPageResponse"];
                };
            };
        };
    };
    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>;
                };
            };
        };
    };
    getCatalog_1: {
        parameters: {
            query?: {
                environment?: string;
                from?: string;
                to?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Catalog returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["CatalogApp"][];
                };
            };
        };
    };
    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"];
                };
            };
        };
    };
    me: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current user details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UserDetail"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["UserDetail"];
                };
            };
        };
    };
    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"];
                };
            };
        };
    };
    getConfigForAgent: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Config returned */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppConfigResponse"];
                };
            };
            /** @description Calling agent could not be resolved */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["AppConfigResponse"];
                };
            };
        };
    };
    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"][];
                };
            };
        };
    };
    instances: {
        parameters: {
            query?: {
                from?: string;
                to?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ServerInstanceInfo"][];
                };
            };
        };
    };
    catalog: {
        parameters: {
            query?: {
                from?: string;
                to?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": components["schemas"]["ServerMetricCatalogEntry"][];
                };
            };
        };
    };
    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"];
                };
            };
        };
    };
    usage: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "*/*": string[];
                };
            };
        };
    };
    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"][];
                };
            };
        };
    };
    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"];
                };
            };
        };
    };
    dismissApplication: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                applicationId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Application dismissed */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Cannot dismiss — live agents connected */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
}
