@meshery/schemas 1.3.31 → 1.3.32

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-interface components$A {
+interface components$B {
     schemas: {
         /**
          * @description Meshery manages entities in accordance with their specific capabilities. This field explicitly identifies those capabilities largely by what actions a given component supports; e.g. metric-scrape, sub-interface, and so on. This field is extensible. Entities may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management.
@@ -109,7 +109,7 @@ interface components$A {
     pathItems: never;
 }
 
-interface components$z {
+interface components$A {
     schemas: {
         CatalogData: {
             /** @description Tracks the specific content version that has been made available in the Catalog. */
@@ -149,7 +149,7 @@ interface components$z {
     pathItems: never;
 }
 
-interface components$y {
+interface components$z {
     schemas: {
         /**
          * @description Meshery manages entities in accordance with their specific capabilities. This field explicitly identifies those capabilities largely by what actions a given component supports; e.g. metric-scrape, sub-interface, and so on. This field is extensible. Entities may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management.
@@ -260,7 +260,7 @@ interface components$y {
     pathItems: never;
 }
 
-interface components$x {
+interface components$y {
     schemas: {
         /** @description Components are reusable building blocks for depicting capabilities defined within models. Learn more at https://docs.meshery.io/concepts/components */
         ComponentDefinition: {
@@ -1017,7 +1017,7 @@ interface components$x {
     pathItems: never;
 }
 
-interface components$w {
+interface components$x {
     schemas: {
         /** @description Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
         Connection: {
@@ -1419,7 +1419,7 @@ interface components$w {
     pathItems: never;
 }
 
-interface components$v {
+interface components$w {
     schemas: {
         /** @description Meshery Credentials store sensitive information such as API keys, tokens, and passwords used by connections to external systems. */
         Credential: {
@@ -1556,7 +1556,7 @@ interface components$v {
     pathItems: never;
 }
 
-interface components$u {
+interface components$v {
     schemas: {
         /** @description Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
         Model: {
@@ -2294,7 +2294,7 @@ interface components$u {
     pathItems: never;
 }
 
-interface components$t {
+interface components$u {
     schemas: {
         /** @description Represents a user */
         User: {
@@ -3291,7 +3291,7 @@ interface components$t {
     pathItems: never;
 }
 
-interface components$s {
+interface components$t {
     schemas: {
         DeletePatternModel: {
             /** Format: uuid */
@@ -10574,7 +10574,7 @@ interface components$s {
     pathItems: never;
 }
 
-interface components$r {
+interface components$s {
     schemas: {
         /** @description Category of the model. */
         CategoryDefinition: {
@@ -10600,7 +10600,7 @@ interface components$r {
     pathItems: never;
 }
 
-interface components$q {
+interface components$r {
     schemas: {
         /**
          * SubCategory
@@ -10617,7 +10617,7 @@ interface components$q {
     pathItems: never;
 }
 
-interface components$p {
+interface components$q {
     schemas: {
         /**
          * Environment
@@ -10873,7 +10873,7 @@ interface components$p {
     pathItems: never;
 }
 
-interface components$o {
+interface components$p {
     schemas: {
         EvaluationRequest: {
             /**
@@ -13825,7 +13825,7 @@ interface components$o {
     pathItems: never;
 }
 
-interface components$n {
+interface components$o {
     schemas: {
         /** @description A feature is a quantified entitlement granted to an organization through its subscription plan, such as the number of components allowed in a design. */
         Feature: {
@@ -14014,7 +14014,7 @@ interface components$n {
     pathItems: never;
 }
 
-interface components$m {
+interface components$n {
     schemas: {
         /** @description Represents an authorization key used for access control. */
         Key: {
@@ -14167,7 +14167,7 @@ interface components$m {
     pathItems: never;
 }
 
-interface components$l {
+interface components$m {
     schemas: {
         /** @description Represents a collection of keys. */
         Keychain: {
@@ -14302,7 +14302,7 @@ interface components$l {
     pathItems: never;
 }
 
-interface components$k {
+interface components$l {
     schemas: {
         /**
          * Format: uuid
@@ -15011,7 +15011,7 @@ interface components$k {
     pathItems: never;
 }
 
-interface components$j {
+interface components$k {
     schemas: {
         /** @description Role definition */
         Role: {
@@ -15231,7 +15231,7 @@ interface components$j {
     pathItems: never;
 }
 
-interface components$i {
+interface components$j {
     schemas: {
         /** @description A schedule defines a recurring cron-based trigger for performance tests or other automated tasks. */
         Schedule: {
@@ -15352,6 +15352,501 @@ interface components$i {
     pathItems: never;
 }
 
+interface components$i {
+    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;
+}
+
 interface components$h {
     schemas: {
         /** @description A Team is a group of one or more users. Teams are often used as a grouping mechanism for assigning permissions, whether in the context of an organization, a workspace, or some other domain within Meshery. Learn more at https://docs.meshery.io/concepts/logical/teams */
@@ -36721,34 +37216,36 @@ declare const SupportRequestRjsfSchemaV1Beta1: RJSFSchema;
 declare const SupportRequestRjsfUiSchemaV1Beta1: UiSchema;
 
 declare namespace v1alpha1 {
-    type CatalogData = components$z["schemas"]["CatalogData"];
-    type Capability = components$A["schemas"];
+    type CatalogData = components$A["schemas"]["CatalogData"];
+    type Capability = components$B["schemas"];
 }
 declare namespace v1alpha2 {
-    type CatalogData = components$z["schemas"]["CatalogData"];
+    type CatalogData = components$A["schemas"]["CatalogData"];
 }
 declare namespace v1beta1 {
     type Badge = components$e["schemas"]["Badge"];
-    type Capability = components$y["schemas"]["Capability"];
-    type Category = components$r["schemas"]["CategoryDefinition"];
-    type Component = components$x["schemas"]["ComponentDefinition"];
-    type Connection = components$w["schemas"]["Connection"];
-    type Credential = components$v["schemas"]["Credential"];
-    type Design = components$s["schemas"]["PatternFile"];
-    type Environment = components$p["schemas"]["Environment"];
-    type EvaluationRequest = components$o["schemas"]["EvaluationRequest"];
-    type EvaluationResponse = components$o["schemas"]["EvaluationResponse"];
-    type Feature = components$n["schemas"]["Feature"];
+    type Capability = components$z["schemas"]["Capability"];
+    type Category = components$s["schemas"]["CategoryDefinition"];
+    type Component = components$y["schemas"]["ComponentDefinition"];
+    type Connection = components$x["schemas"]["Connection"];
+    type ConnectionStatusValue = components$x["schemas"]["ConnectionStatusValue"];
+    type ControllerStatusValue = components$i["schemas"]["ControllerStatusValue"];
+    type Credential = components$w["schemas"]["Credential"];
+    type Design = components$t["schemas"]["PatternFile"];
+    type Environment = components$q["schemas"]["Environment"];
+    type EvaluationRequest = components$p["schemas"]["EvaluationRequest"];
+    type EvaluationResponse = components$p["schemas"]["EvaluationResponse"];
+    type Feature = components$o["schemas"]["Feature"];
     type Invitation = components$f["schemas"]["Invitation"];
-    type Key = components$m["schemas"]["Key"];
-    type Keychain = components$l["schemas"]["Keychain"];
-    type Model = components$u["schemas"]["ModelDefinition"];
-    type Organization = components$k["schemas"]["Organization"];
-    type Role = components$j["schemas"]["Role"];
-    type Schedule = components$i["schemas"]["Schedule"];
-    type Subcategory = components$q["schemas"]["SubCategoryDefinition"];
+    type Key = components$n["schemas"]["Key"];
+    type Keychain = components$m["schemas"]["Keychain"];
+    type Model = components$v["schemas"]["ModelDefinition"];
+    type Organization = components$l["schemas"]["Organization"];
+    type Role = components$k["schemas"]["Role"];
+    type Schedule = components$j["schemas"]["Schedule"];
+    type Subcategory = components$r["schemas"]["SubCategoryDefinition"];
     type Team = components$h["schemas"]["Team"];
-    type User = components$t["schemas"]["User"];
+    type User = components$u["schemas"]["User"];
     type Workspace = components$g["schemas"]["Workspace"];
 }