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

export interface paths {
    "/api/system/database": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get a summary of the Meshery server's database
         * @description Returns a paginated summary of Meshery database tables and row counts.
         */
        get: operations["getSystemDatabase"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/database/reset": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Reset the Meshery server's database
         * @description Resets the Meshery server database. This is a destructive operation.
         */
        delete: operations["resetSystemDatabase"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/version": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get the running Meshery server's version metadata
         * @description Returns version metadata for the running Meshery service.
         */
        get: operations["getSystemVersion"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/email/test": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send a test email
         * @description Sends a test email through the configured SMTP provider to verify the email configuration. Restricted to provider administrators.
         */
        post: operations["sendTestEmail"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/kubernetes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Import a kubeconfig
         * @description Uploads a kubeconfig and registers each discovered context as a Kubernetes connection. Unreachable contexts are still registered as discovered connections; reachability only gates the transition to connected. The optional `contexts` and `selectedContexts` form fields scope and configure the import.
         */
        post: operations["addKubernetesConfig"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/kubernetes/contexts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Discover kubeconfig contexts
         * @description Parses an uploaded kubeconfig and returns its contexts - including unreachable ones, flagged via `reachable` - without persisting any connection. Lets a client present the discovered contexts for selection before importing them.
         */
        post: operations["discoverKubernetesContexts"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/kubernetes/ping": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Ping a Kubernetes connection
         * @description Verifies connectivity to the Kubernetes cluster behind a connection by fetching the API server version.
         */
        get: operations["pingKubernetes"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/sync": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get initial session bootstrap data
         * @description Returns session bootstrap data for the authenticated user.
         */
        get: operations["getSystemSync"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/controllers/operator/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get the Meshery Operator status for a connection
         * @description Returns the current status of the Meshery Operator controller for the given kubernetes connection. Replaces the getOperatorStatus GraphQL query.
         */
        get: operations["getOperatorControllerStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/controllers/meshsync/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get the MeshSync controller status for a connection
         * @description Returns the current status of the MeshSync controller for the given kubernetes connection. Replaces the getMeshsyncStatus GraphQL query.
         */
        get: operations["getMeshsyncControllerStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/controllers/broker/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get the Meshery Broker (NATS) controller status for a connection
         * @description Returns the current status of the Meshery Broker (NATS) controller for the given kubernetes connection. Replaces the getNatsStatus GraphQL query.
         */
        get: operations["getBrokerControllerStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/controllers/diagnostics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get controller diagnostics and remediation for a connection
         * @description Returns human-actionable diagnostics for a kubernetes connection's Meshery controllers (operator, MeshSync, broker), derived from their current status and Meshery's live broker connection. Each diagnostic carries a severity, a summary, an explanation, and concrete remediation steps so the UI can render a "Diagnostics" section in the connection detail view. An empty diagnostics list (with healthy=true) means no problems were detected.
         */
        get: operations["getControllerDiagnostics"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/controllers/status/subscribe": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Stream Meshery controller status over Server-Sent Events
         * @description Server-Sent Events (SSE) stream of controller status (operator, MeshSync, broker) for the requested kubernetes connections. Replaces the subscribeMesheryControllersStatus GraphQL subscription. The server emits the full status array as an unnamed SSE event (`data: <json>` followed by a blank line) on subscribe and again whenever any controller's status changes; a comment keepalive is sent periodically. Consume with a native EventSource, not a buffered JSON client.
         */
        get: operations["subscribeControllersStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        /** @description Request body for sending a test email through the configured SMTP provider. */
        EmailTestRequest: {
            /**
             * Format: email
             * @description Recipient email address for the test message.
             */
            to: string;
            /** @description Subject line for the test message. A default subject is used when omitted. */
            subject?: string;
        };
        /** @description Result of a test email send attempt. */
        EmailTestResponse: {
            /** @description Outcome status of the send attempt (e.g. `success`). */
            status: string;
            /** @description Human-readable result message. */
            message: string;
            /** @description Unix-epoch seconds, as a decimal string, when the test email was sent. */
            timestamp: string;
            /**
             * Format: email
             * @description Recipient address the test email was sent to.
             */
            sentTo: string;
        };
        /** @description Status message response. */
        SystemMessageResponse: {
            /** @description Human-readable status message. */
            message: string;
        };
        /**
         * @description Current status of a single Meshery controller (operator, MeshSync, or broker). Mirrors the MesheryControllerStatus GraphQL enum (server/internal/graphql/schema/schema.graphql) during the ongoing migration of controller-status consumers from GraphQL to this REST API; the literal values (including the published "UNKOWN" spelling) are load-bearing and must not be changed independently of that enum.
         * @enum {string}
         */
        ControllerStatusValue: "DEPLOYED" | "NOTDEPLOYED" | "DEPLOYING" | "UNKOWN" | "UNDEPLOYED" | "ENABLED" | "RUNNING" | "CONNECTED";
        /** @description Status of a single Meshery controller (operator, MeshSync, or broker) for a kubernetes connection. Element type of the controller-status SSE stream and the operator status response. */
        ControllerStatus: {
            /**
             * Format: uuid
             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
             */
            connectionId: string;
            /**
             * @description The controller this status describes.
             * @enum {string}
             */
            controller: "OPERATOR" | "MESHSYNC" | "BROKER";
            /**
             * @description Current controller status.
             * @enum {string}
             */
            status: "DEPLOYED" | "NOTDEPLOYED" | "DEPLOYING" | "UNKOWN" | "UNDEPLOYED" | "ENABLED" | "RUNNING" | "CONNECTED";
            /** @description Deployed controller version, when known. */
            version: string;
        };
        /** @description Detailed status of a named Meshery controller (MeshSync or Broker) for a kubernetes connection. */
        ControllerInfo: {
            /** @description Controller name (e.g. MeshSync, MesheryBroker). */
            name: string;
            /** @description Deployed controller version, when known. */
            version: string;
            /** @description Current controller status. May be composed, e.g. "Connected <endpoint>". */
            status: string;
            /**
             * Format: uuid
             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
             */
            connectionId: string;
        };
        /** @description A single human-actionable diagnostic about a kubernetes connection's Meshery controllers, with an explanation and remediation steps. */
        ControllerDiagnostic: {
            /**
             * @description How serious the diagnostic is.
             * @enum {string}
             */
            severity: "info" | "warning" | "error";
            /**
             * @description The controller this diagnostic concerns, when applicable.
             * @enum {string}
             */
            controller?: "OPERATOR" | "MESHSYNC" | "BROKER";
            /** @description Stable machine-readable code for this diagnostic (e.g. `broker_unreachable`), for the UI to key on. */
            code: string;
            /** @description Short, human-readable title for the diagnostic. */
            summary: string;
            /** @description A fuller explanation of what is wrong and why. */
            description?: string;
            /** @description Ordered, concrete steps the user can take to resolve the issue. */
            remediation?: string[];
            /** @description A relevant endpoint for the diagnostic, when applicable (e.g. the broker's published address the user needs to make reachable). */
            endpoint?: string;
        };
        /** @description Diagnostics for a kubernetes connection's Meshery controllers, for rendering a "Diagnostics" section in the connection detail view. */
        ConnectionDiagnostics: {
            /**
             * Format: uuid
             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
             */
            connectionId: string;
            /** @description True when no warning/error diagnostics were detected (informational diagnostics do not affect health). */
            healthy: boolean;
            /** @description The diagnostics detected for this connection (possibly empty). */
            diagnostics: {
                /**
                 * @description How serious the diagnostic is.
                 * @enum {string}
                 */
                severity: "info" | "warning" | "error";
                /**
                 * @description The controller this diagnostic concerns, when applicable.
                 * @enum {string}
                 */
                controller?: "OPERATOR" | "MESHSYNC" | "BROKER";
                /** @description Stable machine-readable code for this diagnostic (e.g. `broker_unreachable`), for the UI to key on. */
                code: string;
                /** @description Short, human-readable title for the diagnostic. */
                summary: string;
                /** @description A fuller explanation of what is wrong and why. */
                description?: string;
                /** @description Ordered, concrete steps the user can take to resolve the issue. */
                remediation?: string[];
                /** @description A relevant endpoint for the diagnostic, when applicable (e.g. the broker's published address the user needs to make reachable). */
                endpoint?: string;
            }[];
        };
        /** @description Database table summary. */
        SystemDatabaseTable: {
            /** @description Name of the table. */
            name: string;
            /** @description SQLite object type (e.g. `table`). */
            type: string;
            /**
             * Format: int64
             * @description Number of rows currently in the table.
             */
            count: number;
        };
        /** @description Paginated summary of the Meshery server's embedded database. */
        SystemDatabaseSummary: {
            /** @description Zero-based page index of the returned table slice. */
            page: number;
            /** @description Number of tables included in this page. */
            pageSize: number;
            /** @description Total number of tables in the database matching the search filter. */
            totalTables: number;
            /** @description Aggregate row count across the tables returned in this page. */
            recordCount: number;
            /** @description Tables included in this page, with per-table row counts. */
            tables: {
                /** @description Name of the table. */
                name: string;
                /** @description SQLite object type (e.g. `table`). */
                type: string;
                /**
                 * Format: int64
                 * @description Number of rows currently in the table.
                 */
                count: number;
            }[];
        };
        /** @description Version metadata for a running Meshery service. */
        SystemVersion: {
            /** @description Meshery Cloud deployment version. */
            version?: string;
            /** @description Build identifier (typically the git tag of the running binary). */
            build?: string;
            /** @description Latest available Meshery release tag fetched from GitHub. */
            latest?: string;
            /** @description True when the running build is older than the latest available release. */
            outdated?: boolean;
            /** @description Git commit SHA of the running service. The wire field is `commitsha`. */
            commitsha?: string;
            /** @description Release channel of the running binary (e.g. `stable`, `edge`). */
            releaseChannel?: string;
        };
        /** @description Kubernetes context tracked by Meshery. */
        SystemSessionSyncK8sContext: {
            /** @description Stable identifier for the Kubernetes context. */
            id?: string;
            /** @description Human-readable name of the Kubernetes context. */
            name?: string;
            /** @description True when Meshery has a usable kubeconfig for this context. */
            clusterConfigured?: boolean;
            /** @description API server URL for the Kubernetes context. */
            server?: string;
            /**
             * Format: uuid
             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
             */
            clusterId?: string;
            /**
             * Format: date-time
             * @description When the context was first registered with Meshery.
             */
            createdAt?: string;
            /**
             * Format: date-time
             * @description When the context was last updated.
             */
            updatedAt?: string;
        };
        /** @description Session bootstrap payload for the authenticated user. */
        SystemSessionSync: {
            /** @description Kubernetes contexts currently tracked by the Meshery server. */
            k8sConfig?: {
                /** @description Stable identifier for the Kubernetes context. */
                id?: string;
                /** @description Human-readable name of the Kubernetes context. */
                name?: string;
                /** @description True when Meshery has a usable kubeconfig for this context. */
                clusterConfigured?: boolean;
                /** @description API server URL for the Kubernetes context. */
                server?: string;
                /**
                 * Format: uuid
                 * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
                 */
                clusterId?: string;
                /**
                 * Format: date-time
                 * @description When the context was first registered with Meshery.
                 */
                createdAt?: string;
                /**
                 * Format: date-time
                 * @description When the context was last updated.
                 */
                updatedAt?: string;
            }[];
        } & {
            [key: string]: unknown;
        };
        /** @description Multipart form payload for importing a kubeconfig. `contexts` and `selectedContexts` are JSON-encoded strings because they travel as multipart form fields alongside the file. */
        AddKubernetesConfigPayload: {
            /**
             * Format: binary
             * @description Kubeconfig file contents.
             */
            k8sfile: string;
            /** @description JSON-encoded object mapping a discovered context ID to per-context import options, e.g. `{"<contextId>": {"meshsyncDeploymentMode": "operator", "name": "my-cluster"}}`. `meshsyncDeploymentMode` selects how MeshSync runs for the resulting connection; `name` overrides the connection name. */
            contexts?: string;
            /** @description JSON-encoded array of discovered context IDs to import. When absent, every context discovered in the kubeconfig is imported. */
            selectedContexts?: string;
        };
        /** @description Multipart form payload for kubeconfig context discovery. */
        DiscoverKubernetesContextsPayload: {
            /**
             * Format: binary
             * @description Kubeconfig file contents.
             */
            k8sfile: string;
        };
        /** @description Discovered kubeconfig contexts bucketed by import outcome. Every bucket is always present (empty when no context landed in it). */
        AddKubernetesConfigResponse: {
            /** @description Contexts newly registered as discovered connections. */
            registeredContexts: {
                /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                id?: string;
                /** @description Human-readable name of the Kubernetes context. */
                name?: string;
                /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                auth?: Record<string, never>;
                /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                cluster?: Record<string, never>;
                /** @description API server URL of the Kubernetes cluster. */
                server?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who owns the underlying connection.
                 */
                owner?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who registered the context.
                 */
                createdBy?: string;
                /**
                 * Format: uuid
                 * @description ID of the Meshery instance the context is registered with.
                 */
                mesheryInstanceId?: string;
                /**
                 * Format: uuid
                 * @description ID of the Kubernetes server associated with the context.
                 */
                kubernetesServerId?: string;
                /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                deploymentType?: string;
                /** @description Kubernetes server version of the cluster. */
                version?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was created.
                 */
                createdAt?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was last updated.
                 */
                updatedAt?: string;
                /**
                 * Format: uuid
                 * @description ID of the connection this context was projected from.
                 */
                connectionId?: string;
                /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                reachable?: boolean;
            }[];
            /** @description Contexts whose connection already exists in (or transitioned to) the connected state. */
            connectedContexts: {
                /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                id?: string;
                /** @description Human-readable name of the Kubernetes context. */
                name?: string;
                /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                auth?: Record<string, never>;
                /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                cluster?: Record<string, never>;
                /** @description API server URL of the Kubernetes cluster. */
                server?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who owns the underlying connection.
                 */
                owner?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who registered the context.
                 */
                createdBy?: string;
                /**
                 * Format: uuid
                 * @description ID of the Meshery instance the context is registered with.
                 */
                mesheryInstanceId?: string;
                /**
                 * Format: uuid
                 * @description ID of the Kubernetes server associated with the context.
                 */
                kubernetesServerId?: string;
                /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                deploymentType?: string;
                /** @description Kubernetes server version of the cluster. */
                version?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was created.
                 */
                createdAt?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was last updated.
                 */
                updatedAt?: string;
                /**
                 * Format: uuid
                 * @description ID of the connection this context was projected from.
                 */
                connectionId?: string;
                /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                reachable?: boolean;
            }[];
            /** @description Contexts whose connection is in the ignored state. */
            ignoredContexts: {
                /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                id?: string;
                /** @description Human-readable name of the Kubernetes context. */
                name?: string;
                /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                auth?: Record<string, never>;
                /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                cluster?: Record<string, never>;
                /** @description API server URL of the Kubernetes cluster. */
                server?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who owns the underlying connection.
                 */
                owner?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who registered the context.
                 */
                createdBy?: string;
                /**
                 * Format: uuid
                 * @description ID of the Meshery instance the context is registered with.
                 */
                mesheryInstanceId?: string;
                /**
                 * Format: uuid
                 * @description ID of the Kubernetes server associated with the context.
                 */
                kubernetesServerId?: string;
                /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                deploymentType?: string;
                /** @description Kubernetes server version of the cluster. */
                version?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was created.
                 */
                createdAt?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was last updated.
                 */
                updatedAt?: string;
                /**
                 * Format: uuid
                 * @description ID of the connection this context was projected from.
                 */
                connectionId?: string;
                /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                reachable?: boolean;
            }[];
            /** @description Contexts that could not be saved as connections. The failure detail is recorded in the emitted event's metadata, not on the context object. */
            erroredContexts: {
                /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                id?: string;
                /** @description Human-readable name of the Kubernetes context. */
                name?: string;
                /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                auth?: Record<string, never>;
                /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                cluster?: Record<string, never>;
                /** @description API server URL of the Kubernetes cluster. */
                server?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who owns the underlying connection.
                 */
                owner?: string;
                /**
                 * Format: uuid
                 * @description ID of the user who registered the context.
                 */
                createdBy?: string;
                /**
                 * Format: uuid
                 * @description ID of the Meshery instance the context is registered with.
                 */
                mesheryInstanceId?: string;
                /**
                 * Format: uuid
                 * @description ID of the Kubernetes server associated with the context.
                 */
                kubernetesServerId?: string;
                /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                deploymentType?: string;
                /** @description Kubernetes server version of the cluster. */
                version?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was created.
                 */
                createdAt?: string;
                /**
                 * Format: date-time
                 * @description Timestamp when the underlying connection was last updated.
                 */
                updatedAt?: string;
                /**
                 * Format: uuid
                 * @description ID of the connection this context was projected from.
                 */
                connectionId?: string;
                /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                reachable?: boolean;
            }[];
        };
        /** @description Result of pinging a Kubernetes connection's API server. */
        KubernetesPingResponse: {
            /** @description Version string reported by the cluster's API server. The wire field is `server_version` - this endpoint's published wire casing predates the camelCase convention and is preserved within this API version. */
            server_version: string;
        };
    };
    responses: {
        /** @description Expired JWT token used or insufficient privilege */
        401: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "text/plain": string;
            };
        };
    };
    parameters: never;
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    getSystemDatabase: {
        parameters: {
            query?: {
                /** @description Zero-based page index for the table list. */
                page?: number;
                /** @description Number of tables to include per page. */
                pageSize?: number;
                /** @description Substring filter applied to table names. */
                search?: string;
                /** @description Column to order the table list by. */
                sort?: "name";
                /** @description Sort direction for the `sort` column. */
                order?: "asc" | "desc";
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Database summary */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Zero-based page index of the returned table slice. */
                        page: number;
                        /** @description Number of tables included in this page. */
                        pageSize: number;
                        /** @description Total number of tables in the database matching the search filter. */
                        totalTables: number;
                        /** @description Aggregate row count across the tables returned in this page. */
                        recordCount: number;
                        /** @description Tables included in this page, with per-table row counts. */
                        tables: {
                            /** @description Name of the table. */
                            name: string;
                            /** @description SQLite object type (e.g. `table`). */
                            type: string;
                            /**
                             * Format: int64
                             * @description Number of rows currently in the table.
                             */
                            count: number;
                        }[];
                    };
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Internal server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    resetSystemDatabase: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Database reset */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Human-readable status message. */
                        message: string;
                    };
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Internal server error during reset (archive, drop, migrate, or reseed). */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getSystemVersion: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Server version metadata */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Meshery Cloud deployment version. */
                        version?: string;
                        /** @description Build identifier (typically the git tag of the running binary). */
                        build?: string;
                        /** @description Latest available Meshery release tag fetched from GitHub. */
                        latest?: string;
                        /** @description True when the running build is older than the latest available release. */
                        outdated?: boolean;
                        /** @description Git commit SHA of the running service. The wire field is `commitsha`. */
                        commitsha?: string;
                        /** @description Release channel of the running binary (e.g. `stable`, `edge`). */
                        releaseChannel?: string;
                    };
                };
            };
            /** @description Encoding error while serializing the version payload. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    sendTestEmail: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Recipient and optional subject for the test email. */
        requestBody: {
            content: {
                "application/json": {
                    /**
                     * Format: email
                     * @description Recipient email address for the test message.
                     */
                    to: string;
                    /** @description Subject line for the test message. A default subject is used when omitted. */
                    subject?: string;
                };
            };
        };
        responses: {
            /** @description Test email sent */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Outcome status of the send attempt (e.g. `success`). */
                        status: string;
                        /** @description Human-readable result message. */
                        message: string;
                        /** @description Unix-epoch seconds, as a decimal string, when the test email was sent. */
                        timestamp: string;
                        /**
                         * Format: email
                         * @description Recipient address the test email was sent to.
                         */
                        sentTo: string;
                    };
                };
            };
            /** @description Invalid request payload or malformed recipient email address. */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Email configuration validation failed or the send attempt errored. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    addKubernetesConfig: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "multipart/form-data": {
                    /**
                     * Format: binary
                     * @description Kubeconfig file contents.
                     */
                    k8sfile: string;
                    /** @description JSON-encoded object mapping a discovered context ID to per-context import options, e.g. `{"<contextId>": {"meshsyncDeploymentMode": "operator", "name": "my-cluster"}}`. `meshsyncDeploymentMode` selects how MeshSync runs for the resulting connection; `name` overrides the connection name. */
                    contexts?: string;
                    /** @description JSON-encoded array of discovered context IDs to import. When absent, every context discovered in the kubeconfig is imported. */
                    selectedContexts?: string;
                };
            };
        };
        responses: {
            /** @description Discovered contexts bucketed by import outcome. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Contexts newly registered as discovered connections. */
                        registeredContexts: {
                            /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                            id?: string;
                            /** @description Human-readable name of the Kubernetes context. */
                            name?: string;
                            /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                            auth?: Record<string, never>;
                            /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                            cluster?: Record<string, never>;
                            /** @description API server URL of the Kubernetes cluster. */
                            server?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who owns the underlying connection.
                             */
                            owner?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who registered the context.
                             */
                            createdBy?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Meshery instance the context is registered with.
                             */
                            mesheryInstanceId?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Kubernetes server associated with the context.
                             */
                            kubernetesServerId?: string;
                            /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                            deploymentType?: string;
                            /** @description Kubernetes server version of the cluster. */
                            version?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was created.
                             */
                            createdAt?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was last updated.
                             */
                            updatedAt?: string;
                            /**
                             * Format: uuid
                             * @description ID of the connection this context was projected from.
                             */
                            connectionId?: string;
                            /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                            reachable?: boolean;
                        }[];
                        /** @description Contexts whose connection already exists in (or transitioned to) the connected state. */
                        connectedContexts: {
                            /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                            id?: string;
                            /** @description Human-readable name of the Kubernetes context. */
                            name?: string;
                            /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                            auth?: Record<string, never>;
                            /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                            cluster?: Record<string, never>;
                            /** @description API server URL of the Kubernetes cluster. */
                            server?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who owns the underlying connection.
                             */
                            owner?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who registered the context.
                             */
                            createdBy?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Meshery instance the context is registered with.
                             */
                            mesheryInstanceId?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Kubernetes server associated with the context.
                             */
                            kubernetesServerId?: string;
                            /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                            deploymentType?: string;
                            /** @description Kubernetes server version of the cluster. */
                            version?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was created.
                             */
                            createdAt?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was last updated.
                             */
                            updatedAt?: string;
                            /**
                             * Format: uuid
                             * @description ID of the connection this context was projected from.
                             */
                            connectionId?: string;
                            /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                            reachable?: boolean;
                        }[];
                        /** @description Contexts whose connection is in the ignored state. */
                        ignoredContexts: {
                            /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                            id?: string;
                            /** @description Human-readable name of the Kubernetes context. */
                            name?: string;
                            /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                            auth?: Record<string, never>;
                            /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                            cluster?: Record<string, never>;
                            /** @description API server URL of the Kubernetes cluster. */
                            server?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who owns the underlying connection.
                             */
                            owner?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who registered the context.
                             */
                            createdBy?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Meshery instance the context is registered with.
                             */
                            mesheryInstanceId?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Kubernetes server associated with the context.
                             */
                            kubernetesServerId?: string;
                            /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                            deploymentType?: string;
                            /** @description Kubernetes server version of the cluster. */
                            version?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was created.
                             */
                            createdAt?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was last updated.
                             */
                            updatedAt?: string;
                            /**
                             * Format: uuid
                             * @description ID of the connection this context was projected from.
                             */
                            connectionId?: string;
                            /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                            reachable?: boolean;
                        }[];
                        /** @description Contexts that could not be saved as connections. The failure detail is recorded in the emitted event's metadata, not on the context object. */
                        erroredContexts: {
                            /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                            id?: string;
                            /** @description Human-readable name of the Kubernetes context. */
                            name?: string;
                            /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                            auth?: Record<string, never>;
                            /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                            cluster?: Record<string, never>;
                            /** @description API server URL of the Kubernetes cluster. */
                            server?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who owns the underlying connection.
                             */
                            owner?: string;
                            /**
                             * Format: uuid
                             * @description ID of the user who registered the context.
                             */
                            createdBy?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Meshery instance the context is registered with.
                             */
                            mesheryInstanceId?: string;
                            /**
                             * Format: uuid
                             * @description ID of the Kubernetes server associated with the context.
                             */
                            kubernetesServerId?: string;
                            /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                            deploymentType?: string;
                            /** @description Kubernetes server version of the cluster. */
                            version?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was created.
                             */
                            createdAt?: string;
                            /**
                             * Format: date-time
                             * @description Timestamp when the underlying connection was last updated.
                             */
                            updatedAt?: string;
                            /**
                             * Format: uuid
                             * @description ID of the connection this context was projected from.
                             */
                            connectionId?: string;
                            /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                            reachable?: boolean;
                        }[];
                    };
                };
            };
            /** @description Missing or unparsable kubeconfig, or malformed `contexts` / `selectedContexts` JSON. */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Failed to retrieve the user token from the request context. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    discoverKubernetesContexts: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "multipart/form-data": {
                    /**
                     * Format: binary
                     * @description Kubeconfig file contents.
                     */
                    k8sfile: string;
                };
            };
        };
        responses: {
            /** @description Contexts discovered in the uploaded kubeconfig. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
                        id?: string;
                        /** @description Human-readable name of the Kubernetes context. */
                        name?: string;
                        /** @description Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
                        auth?: Record<string, never>;
                        /** @description Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
                        cluster?: Record<string, never>;
                        /** @description API server URL of the Kubernetes cluster. */
                        server?: string;
                        /**
                         * Format: uuid
                         * @description ID of the user who owns the underlying connection.
                         */
                        owner?: string;
                        /**
                         * Format: uuid
                         * @description ID of the user who registered the context.
                         */
                        createdBy?: string;
                        /**
                         * Format: uuid
                         * @description ID of the Meshery instance the context is registered with.
                         */
                        mesheryInstanceId?: string;
                        /**
                         * Format: uuid
                         * @description ID of the Kubernetes server associated with the context.
                         */
                        kubernetesServerId?: string;
                        /** @description How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
                        deploymentType?: string;
                        /** @description Kubernetes server version of the cluster. */
                        version?: string;
                        /**
                         * Format: date-time
                         * @description Timestamp when the underlying connection was created.
                         */
                        createdAt?: string;
                        /**
                         * Format: date-time
                         * @description Timestamp when the underlying connection was last updated.
                         */
                        updatedAt?: string;
                        /**
                         * Format: uuid
                         * @description ID of the connection this context was projected from.
                         */
                        connectionId?: string;
                        /** @description Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
                        reachable?: boolean;
                    }[];
                };
            };
            /** @description Missing or unparsable kubeconfig. */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Failed to retrieve the provider token for the request. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    pingKubernetes: {
        parameters: {
            query: {
                /** @description ID of the Kubernetes connection whose cluster to ping. */
                connectionId: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Cluster is reachable. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Version string reported by the cluster's API server. The wire field is `server_version` - this endpoint's published wire casing predates the camelCase convention and is preserved within this API version. */
                        server_version: string;
                    };
                };
            };
            /** @description Missing `connectionId` query parameter, or the stored kubeconfig is invalid. */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description No Kubernetes context found for the given connection ID. */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Failed to reach the cluster or fetch its server version. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getSystemSync: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Session sync payload */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Kubernetes contexts currently tracked by the Meshery server. */
                        k8sConfig?: {
                            /** @description Stable identifier for the Kubernetes context. */
                            id?: string;
                            /** @description Human-readable name of the Kubernetes context. */
                            name?: string;
                            /** @description True when Meshery has a usable kubeconfig for this context. */
                            clusterConfigured?: boolean;
                            /** @description API server URL for the Kubernetes context. */
                            server?: string;
                            /**
                             * Format: uuid
                             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
                             */
                            clusterId?: string;
                            /**
                             * Format: date-time
                             * @description When the context was first registered with Meshery.
                             */
                            createdAt?: string;
                            /**
                             * Format: date-time
                             * @description When the context was last updated.
                             */
                            updatedAt?: string;
                        }[];
                    } & {
                        [key: string]: unknown;
                    };
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Marshal error while serializing the session sync payload. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getOperatorControllerStatus: {
        parameters: {
            query: {
                /** @description The kubernetes connection ID whose operator status is requested. */
                connectionId: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Operator controller status */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /**
                         * Format: uuid
                         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
                         */
                        connectionId: string;
                        /**
                         * @description The controller this status describes.
                         * @enum {string}
                         */
                        controller: "OPERATOR" | "MESHSYNC" | "BROKER";
                        /**
                         * @description Current controller status.
                         * @enum {string}
                         */
                        status: "DEPLOYED" | "NOTDEPLOYED" | "DEPLOYING" | "UNKOWN" | "UNDEPLOYED" | "ENABLED" | "RUNNING" | "CONNECTED";
                        /** @description Deployed controller version, when known. */
                        version: string;
                    };
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Internal server error while resolving controller status. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getMeshsyncControllerStatus: {
        parameters: {
            query: {
                /** @description The kubernetes connection ID whose MeshSync status is requested. */
                connectionId: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description MeshSync controller status */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Controller name (e.g. MeshSync, MesheryBroker). */
                        name: string;
                        /** @description Deployed controller version, when known. */
                        version: string;
                        /** @description Current controller status. May be composed, e.g. "Connected <endpoint>". */
                        status: string;
                        /**
                         * Format: uuid
                         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
                         */
                        connectionId: string;
                    };
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Internal server error while resolving controller status. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getBrokerControllerStatus: {
        parameters: {
            query: {
                /** @description The kubernetes connection ID whose broker status is requested. */
                connectionId: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Broker controller status */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Controller name (e.g. MeshSync, MesheryBroker). */
                        name: string;
                        /** @description Deployed controller version, when known. */
                        version: string;
                        /** @description Current controller status. May be composed, e.g. "Connected <endpoint>". */
                        status: string;
                        /**
                         * Format: uuid
                         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
                         */
                        connectionId: string;
                    };
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Internal server error while resolving controller status. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getControllerDiagnostics: {
        parameters: {
            query: {
                /** @description The kubernetes connection ID whose diagnostics are requested. */
                connectionId: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Connection controller diagnostics */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /**
                         * Format: uuid
                         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
                         */
                        connectionId: string;
                        /** @description True when no warning/error diagnostics were detected (informational diagnostics do not affect health). */
                        healthy: boolean;
                        /** @description The diagnostics detected for this connection (possibly empty). */
                        diagnostics: {
                            /**
                             * @description How serious the diagnostic is.
                             * @enum {string}
                             */
                            severity: "info" | "warning" | "error";
                            /**
                             * @description The controller this diagnostic concerns, when applicable.
                             * @enum {string}
                             */
                            controller?: "OPERATOR" | "MESHSYNC" | "BROKER";
                            /** @description Stable machine-readable code for this diagnostic (e.g. `broker_unreachable`), for the UI to key on. */
                            code: string;
                            /** @description Short, human-readable title for the diagnostic. */
                            summary: string;
                            /** @description A fuller explanation of what is wrong and why. */
                            description?: string;
                            /** @description Ordered, concrete steps the user can take to resolve the issue. */
                            remediation?: string[];
                            /** @description A relevant endpoint for the diagnostic, when applicable (e.g. the broker's published address the user needs to make reachable). */
                            endpoint?: string;
                        }[];
                    };
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Internal server error while resolving controller diagnostics. */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    subscribeControllersStatus: {
        parameters: {
            query?: {
                /** @description Kubernetes connection IDs to watch. Repeatable (connectionIds=<id>&connectionIds=<id>). */
                connectionIds?: string[];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description An open text/event-stream of controller status snapshots. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": string;
                };
            };
            /** @description Expired JWT token used or insufficient privilege */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
        };
    };
}
