polyaxon 2.0.0rc49__py3-none-any.whl → 2.4.0rc1__py3-none-any.whl

polyaxon/_sdk/api/runs_v1_api.py

@@ -1,11 +1,12 @@
 from datetime import datetime
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 from typing_extensions import Annotated
 
 from clipped.compact.pydantic import Field, StrictInt, StrictStr, validate_arguments
 
 from polyaxon._schemas.lifecycle import V1Status
 from polyaxon._sdk.base_api import BaseApi
+from polyaxon._sdk.schemas import V1RunEdgesGraph
 from polyaxon._sdk.schemas.v1_artifact_tree import V1ArtifactTree
 from polyaxon._sdk.schemas.v1_auth import V1Auth
 from polyaxon._sdk.schemas.v1_entities_tags import V1EntitiesTags
@@ -14,7 +15,10 @@ from polyaxon._sdk.schemas.v1_entity_notification_body import V1EntityNotificati
 from polyaxon._sdk.schemas.v1_entity_status_body_request import (
     V1EntityStatusBodyRequest,
 )
-from polyaxon._sdk.schemas.v1_events_response import V1EventsResponse
+from polyaxon._sdk.schemas.v1_events_response import (
+    V1EventsResponse,
+    V1MultiEventsResponse,
+)
 from polyaxon._sdk.schemas.v1_list_bookmarks_response import V1ListBookmarksResponse
 from polyaxon._sdk.schemas.v1_list_run_artifacts_response import (
     V1ListRunArtifactsResponse,
@@ -218,9 +222,7 @@ class RunsV1Api(BaseApi):
     def approve_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -229,13 +231,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.approve_runs(owner, project, body, async_req=True)
+        >>> thread = api.approve_runs(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -255,16 +257,14 @@ class RunsV1Api(BaseApi):
         """
         kwargs["_return_http_data_only"] = True
         return self.approve_runs_with_http_info(
-            owner, project, body, **kwargs
+            owner, name, body, **kwargs
         )  # noqa: E501
 
     @validate_arguments
     def approve_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ):  # noqa: E501
@@ -273,13 +273,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.approve_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.approve_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -308,7 +308,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -337,8 +337,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -374,7 +374,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/approve",
+            "/api/v1/{owner}/{name}/runs/approve",
             "POST",
             _path_params,
             _query_params,
@@ -576,9 +576,7 @@ class RunsV1Api(BaseApi):
     def archive_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -587,13 +585,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.archive_runs(owner, project, body, async_req=True)
+        >>> thread = api.archive_runs(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -613,16 +611,14 @@ class RunsV1Api(BaseApi):
         """
         kwargs["_return_http_data_only"] = True
         return self.archive_runs_with_http_info(
-            owner, project, body, **kwargs
+            owner, name, body, **kwargs
         )  # noqa: E501
 
     @validate_arguments
     def archive_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ):  # noqa: E501
@@ -631,13 +627,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.archive_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.archive_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -666,7 +662,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -695,8 +691,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -732,7 +728,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/archive",
+            "/api/v1/{owner}/{name}/runs/archive",
             "POST",
             _path_params,
             _query_params,
@@ -934,9 +930,7 @@ class RunsV1Api(BaseApi):
     def bookmark_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -945,13 +939,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.bookmark_runs(owner, project, body, async_req=True)
+        >>> thread = api.bookmark_runs(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -971,16 +965,14 @@ class RunsV1Api(BaseApi):
         """
         kwargs["_return_http_data_only"] = True
         return self.bookmark_runs_with_http_info(
-            owner, project, body, **kwargs
+            owner, name, body, **kwargs
         )  # noqa: E501
 
     @validate_arguments
     def bookmark_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ):  # noqa: E501
@@ -989,13 +981,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.bookmark_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.bookmark_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -1024,7 +1016,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -1053,8 +1045,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -1090,7 +1082,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/bookmark",
+            "/api/v1/{owner}/{name}/runs/bookmark",
             "POST",
             _path_params,
             _query_params,
@@ -2847,9 +2839,7 @@ class RunsV1Api(BaseApi):
     def delete_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -2863,8 +2853,8 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -2884,16 +2874,14 @@ class RunsV1Api(BaseApi):
         """
         kwargs["_return_http_data_only"] = True
         return self.delete_runs_with_http_info(
-            owner, project, body, **kwargs
+            owner, name, body, **kwargs
         )  # noqa: E501
 
     @validate_arguments
     def delete_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ):  # noqa: E501
@@ -2902,13 +2890,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.delete_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.delete_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -2937,7 +2925,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -2966,8 +2954,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -3003,7 +2991,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/delete",
+            "/api/v1/{owner}/{name}/runs/delete",
             "DELETE",
             _path_params,
             _query_params,
@@ -3026,8 +3014,8 @@ class RunsV1Api(BaseApi):
         self,
         namespace: Annotated[StrictStr, Field(..., description="namespace")],
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project where the run will be assigned")
+        entity: Annotated[
+            StrictStr, Field(..., description="Entity where the run will be assigned")
         ],
         kind: Annotated[str, Field(..., description="The artifact kind")],
         names: Annotated[
@@ -3052,21 +3040,21 @@ class RunsV1Api(BaseApi):
             Optional[StrictStr], Field(description="Optional status.")
         ] = None,
         **kwargs
-    ) -> V1EventsResponse:  # noqa: E501
+    ) -> V1MultiEventsResponse:  # noqa: E501
         """Get multi runs events  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_multi_run_events(namespace, owner, project, kind, names, runs, orient, force, sample, connection, status, async_req=True)
+        >>> thread = api.get_multi_run_events(namespace, owner, entity, kind, names, runs, orient, force, sample, connection, status, async_req=True)
         >>> result = thread.get()
 
         :param namespace: namespace (required)
         :type namespace: str
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project where the run will be assigned (required)
-        :type project: str
+        :param entity: Entity where the run will be assigned (required)
+        :type entity: str
         :param kind: The artifact kind (required)
         :type kind: str
         :param names: Names query param.
@@ -3096,13 +3084,13 @@ class RunsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: V1EventsResponse
+        :rtype: V1MultiEventsResponse
         """
         kwargs["_return_http_data_only"] = True
         return self.get_multi_run_events_with_http_info(
             namespace,
             owner,
-            project,
+            entity,
             kind,
             names,
             runs,
@@ -3119,8 +3107,8 @@ class RunsV1Api(BaseApi):
         self,
         namespace: Annotated[StrictStr, Field(..., description="namespace")],
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project where the run will be assigned")
+        entity: Annotated[
+            StrictStr, Field(..., description="Entity where the run will be assigned")
         ],
         kind: Annotated[str, Field(..., description="The artifact kind")],
         names: Annotated[
@@ -3151,15 +3139,15 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_multi_run_events_with_http_info(namespace, owner, project, kind, names, runs, orient, force, sample, connection, status, async_req=True)
+        >>> thread = api.get_multi_run_events_with_http_info(namespace, owner, entity, kind, names, runs, orient, force, sample, connection, status, async_req=True)
         >>> result = thread.get()
 
         :param namespace: namespace (required)
         :type namespace: str
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project where the run will be assigned (required)
-        :type project: str
+        :param entity: Entity where the run will be assigned (required)
+        :type entity: str
         :param kind: The artifact kind (required)
         :type kind: str
         :param names: Names query param.
@@ -3197,7 +3185,7 @@ class RunsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(V1EventsResponse, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(V1MultiEventsResponse, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
@@ -3205,7 +3193,7 @@ class RunsV1Api(BaseApi):
         _all_params = [
             "namespace",
             "owner",
-            "project",
+            "entity",
             "kind",
             "names",
             "runs",
@@ -3245,8 +3233,8 @@ class RunsV1Api(BaseApi):
             _path_params["namespace"] = _params["namespace"]
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["entity"]:
+            _path_params["entity"] = _params["entity"]
         if _params["kind"]:
             _path_params["kind"] = _params["kind"]
 
@@ -3286,14 +3274,14 @@ class RunsV1Api(BaseApi):
         _auth_settings = ["ApiKey"]  # noqa: E501
 
         _response_types_map = {
-            "200": "V1EventsResponse",
+            "200": "V1MultiEventsResponse",
             "204": "object",
             "403": "object",
             "404": "object",
         }
 
         return self.api_client.call_api(
-            "/streams/v1/{namespace}/{owner}/{project}/runs/multi/events/{kind}",
+            "/streams/v1/{namespace}/{owner}/{entity}/runs/multi/events/{kind}",
             "GET",
             _path_params,
             _query_params,
@@ -3311,6 +3299,196 @@ class RunsV1Api(BaseApi):
             _request_auth=_params.get("_request_auth"),
         )
 
+    @validate_arguments
+    def get_multi_run_importance(
+        self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        entity: Annotated[
+            StrictStr, Field(..., description="Entity where the run will be assigned")
+        ],
+        body: Annotated[Dict[str, Any], Field(..., description="Params/Metrics data")],
+        **kwargs
+    ) -> V1MultiEventsResponse:  # noqa: E501
+        """Get multi run importance  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_multi_run_importance(namespace, owner, entity, body, async_req=True)
+        >>> result = thread.get()
+
+        :param namespace: namespace (required)
+        :type namespace: str
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param entity: Entity where the run will be assigned (required)
+        :type entity: str
+        :param body: Params/Metrics data (required)
+        :type body: object
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: V1MultiEventsResponse
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.get_multi_run_importance_with_http_info(
+            namespace, owner, entity, body, **kwargs
+        )  # noqa: E501
+
+    @validate_arguments
+    def get_multi_run_importance_with_http_info(
+        self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        entity: Annotated[
+            StrictStr, Field(..., description="Entity where the run will be assigned")
+        ],
+        body: Annotated[Dict[str, Any], Field(..., description="Params/Metrics data")],
+        **kwargs
+    ):  # noqa: E501
+        """Get multi run importance  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_multi_run_importance_with_http_info(namespace, owner, entity, body, async_req=True)
+        >>> result = thread.get()
+
+        :param namespace: namespace (required)
+        :type namespace: str
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param entity: Entity where the run will be assigned (required)
+        :type entity: str
+        :param body: Params/Metrics data (required)
+        :type body: object
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(V1MultiEventsResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = ["namespace", "owner", "entity", "body"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_multi_run_importance" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["namespace"]:
+            _path_params["namespace"] = _params["namespace"]
+
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+
+        if _params["entity"]:
+            _path_params["entity"] = _params["entity"]
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params["body"]:
+            _body_params = _params["body"]
+
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get(
+            "_content_type",
+            self.api_client.select_header_content_type(["application/json"]),
+        )
+        if _content_types_list:
+            _header_params["Content-Type"] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "V1MultiEventsResponse",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
+
+        return self.api_client.call_api(
+            "/streams/v1/{namespace}/{owner}/{entity}/runs/multi/importance",
+            "POST",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
     @validate_arguments
     def get_run(
         self,
@@ -4179,7 +4357,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -4205,7 +4383,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -4244,7 +4422,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -4270,7 +4448,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -4415,7 +4593,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -4441,7 +4619,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -4480,7 +4658,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -4506,7 +4684,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -4862,7 +5040,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -4888,7 +5066,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -4927,7 +5105,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -4953,7 +5131,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -5098,7 +5276,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -5124,7 +5302,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -5163,7 +5341,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -5189,7 +5367,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -5334,7 +5512,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -5360,7 +5538,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -5399,7 +5577,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -5425,7 +5603,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -5856,216 +6034,9 @@ class RunsV1Api(BaseApi):
         )
 
     @validate_arguments
-    def get_run_importance(
+    def get_run_logs(
         self,
-        namespace: Annotated[StrictStr, Field(..., description="namespace")],
-        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project where the run will be assigned")
-        ],
-        uuid: Annotated[
-            StrictStr, Field(..., description="Uuid identifier of the entity")
-        ],
-        body: Annotated[
-            Dict[str, StrictStr], Field(..., description="Params/Metrics data")
-        ],
-        **kwargs
-    ) -> V1EventsResponse:  # noqa: E501
-        """Get run importance  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-
-        >>> thread = api.get_run_importance(namespace, owner, project, uuid, body, async_req=True)
-        >>> result = thread.get()
-
-        :param namespace: namespace (required)
-        :type namespace: str
-        :param owner: Owner of the namespace (required)
-        :type owner: str
-        :param project: Project where the run will be assigned (required)
-        :type project: str
-        :param uuid: Uuid identifier of the entity (required)
-        :type uuid: str
-        :param body: Params/Metrics data (required)
-        :type body: object
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: Returns the result object.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: V1EventsResponse
-        """
-        kwargs["_return_http_data_only"] = True
-        return self.get_run_importance_with_http_info(
-            namespace, owner, project, uuid, body, **kwargs
-        )  # noqa: E501
-
-    @validate_arguments
-    def get_run_importance_with_http_info(
-        self,
-        namespace: Annotated[StrictStr, Field(..., description="namespace")],
-        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project where the run will be assigned")
-        ],
-        uuid: Annotated[
-            StrictStr, Field(..., description="Uuid identifier of the entity")
-        ],
-        body: Annotated[
-            Dict[str, StrictStr], Field(..., description="Params/Metrics data")
-        ],
-        **kwargs
-    ):  # noqa: E501
-        """Get run importance  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-
-        >>> thread = api.get_run_importance_with_http_info(namespace, owner, project, uuid, body, async_req=True)
-        >>> result = thread.get()
-
-        :param namespace: namespace (required)
-        :type namespace: str
-        :param owner: Owner of the namespace (required)
-        :type owner: str
-        :param project: Project where the run will be assigned (required)
-        :type project: str
-        :param uuid: Uuid identifier of the entity (required)
-        :type uuid: str
-        :param body: Params/Metrics data (required)
-        :type body: object
-        :param async_req: Whether to execute the request asynchronously.
-        :type async_req: bool, optional
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :type _return_http_data_only: bool, optional
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :type _preload_content: bool, optional
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the authentication
-                              in the spec for a single request.
-        :type _request_auth: dict, optional
-        :type _content_type: string, optional: force content-type for the request
-        :return: Returns the result object.
-                 If the method is called asynchronously,
-                 returns the request thread.
-        :rtype: tuple(V1EventsResponse, status_code(int), headers(HTTPHeaderDict))
-        """
-
-        _params = locals()
-
-        _all_params = ["namespace", "owner", "project", "uuid", "body"]
-        _all_params.extend(
-            [
-                "async_req",
-                "_return_http_data_only",
-                "_preload_content",
-                "_request_timeout",
-                "_request_auth",
-                "_content_type",
-                "_headers",
-            ]
-        )
-
-        # validate the arguments
-        for _key, _val in _params["kwargs"].items():
-            if _key not in _all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_run_importance" % _key
-                )
-            _params[_key] = _val
-        del _params["kwargs"]
-
-        _collection_formats = {}
-
-        # process the path parameters
-        _path_params = {}
-        if _params["namespace"]:
-            _path_params["namespace"] = _params["namespace"]
-        if _params["owner"]:
-            _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
-        if _params["uuid"]:
-            _path_params["uuid"] = _params["uuid"]
-
-        # process the query parameters
-        _query_params = []
-
-        # process the header parameters
-        _header_params = dict(_params.get("_headers", {}))
-
-        # process the form parameters
-        _form_params = []
-        _files = {}
-
-        # process the body parameter
-        _body_params = None
-        if _params["body"]:
-            _body_params = _params["body"]
-
-        # set the HTTP header `Accept`
-        _header_params["Accept"] = self.api_client.select_header_accept(
-            ["application/json"]
-        )  # noqa: E501
-
-        # set the HTTP header `Content-Type`
-        _content_types_list = _params.get(
-            "_content_type",
-            self.api_client.select_header_content_type(["application/json"]),
-        )
-        if _content_types_list:
-            _header_params["Content-Type"] = _content_types_list
-
-        # authentication setting
-        _auth_settings = ["ApiKey"]  # noqa: E501
-
-        _response_types_map = {
-            "200": "V1EventsResponse",
-            "204": "object",
-            "403": "object",
-            "404": "object",
-        }
-
-        return self.api_client.call_api(
-            "/streams/v1/{namespace}/{owner}/{project}/runs/{uuid}/importance",
-            "POST",
-            _path_params,
-            _query_params,
-            _header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            response_types_map=_response_types_map,
-            auth_settings=_auth_settings,
-            async_req=_params.get("async_req"),
-            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
-            _preload_content=_params.get("_preload_content", True),
-            _request_timeout=_params.get("_request_timeout"),
-            collection_formats=_collection_formats,
-            _request_auth=_params.get("_request_auth"),
-        )
-
-    @validate_arguments
-    def get_run_logs(
-        self,
-        namespace: StrictStr,
+        namespace: StrictStr,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         project: Annotated[
             StrictStr, Field(..., description="Project where the run will be assigned")
@@ -6979,7 +6950,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -7016,7 +6987,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -7078,7 +7049,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -7115,7 +7086,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -7470,7 +7441,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -7496,7 +7467,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -7535,7 +7506,7 @@ class RunsV1Api(BaseApi):
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         entity: Annotated[
-            StrictStr, Field(..., description="Entity name under namesapce")
+            StrictStr, Field(..., description="Entity name under namespace")
         ],
         uuid: Annotated[StrictStr, Field(..., description="SubEntity uuid")],
         offset: Annotated[
@@ -7561,7 +7532,7 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity name under namesapce (required)
+        :param entity: Entity name under namespace (required)
         :type entity: str
         :param uuid: SubEntity uuid (required)
         :type uuid: str
@@ -8603,9 +8574,7 @@ class RunsV1Api(BaseApi):
     def invalidate_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -8614,13 +8583,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.invalidate_runs(owner, project, body, async_req=True)
+        >>> thread = api.invalidate_runs(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -8640,16 +8609,14 @@ class RunsV1Api(BaseApi):
         """
         kwargs["_return_http_data_only"] = True
         return self.invalidate_runs_with_http_info(
-            owner, project, body, **kwargs
+            owner, name, body, **kwargs
         )  # noqa: E501
 
     @validate_arguments
     def invalidate_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ):  # noqa: E501
@@ -8658,13 +8625,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.invalidate_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.invalidate_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -8693,7 +8660,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -8722,8 +8689,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -8759,7 +8726,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/invalidate",
+            "/api/v1/{owner}/{name}/runs/invalidate",
             "POST",
             _path_params,
             _query_params,
@@ -10208,9 +10175,7 @@ class RunsV1Api(BaseApi):
     def restore_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -10219,13 +10184,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.restore_runs(owner, project, body, async_req=True)
+        >>> thread = api.restore_runs(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -10245,16 +10210,14 @@ class RunsV1Api(BaseApi):
         """
         kwargs["_return_http_data_only"] = True
         return self.restore_runs_with_http_info(
-            owner, project, body, **kwargs
+            owner, name, body, **kwargs
         )  # noqa: E501
 
     @validate_arguments
     def restore_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ):  # noqa: E501
@@ -10263,13 +10226,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.restore_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.restore_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -10298,7 +10261,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -10327,8 +10290,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -10364,7 +10327,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/restore",
+            "/api/v1/{owner}/{name}/runs/restore",
             "POST",
             _path_params,
             _query_params,
@@ -10574,34 +10537,30 @@ class RunsV1Api(BaseApi):
         )
 
     @validate_arguments
-    def stop_run(
+    def set_run_edges_lineage(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        entity: Annotated[
-            StrictStr,
-            Field(
-                ..., description="Entity: project name, hub name, registry name, ..."
-            ),
-        ],
-        uuid: Annotated[
-            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
-        ],
+        project: Annotated[StrictStr, Field(..., description="Project")],
+        uuid: Annotated[StrictStr, Field(..., description="Run uuid")],
+        body: Annotated[V1RunEdgesGraph, Field(..., description="Run edges graph")],
         **kwargs
     ) -> None:  # noqa: E501
-        """Stop run  # noqa: E501
+        """Set run edges graph lineage  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.stop_run(owner, entity, uuid, async_req=True)
+        >>> thread = api.set_run_edges_lineage(owner, project, uuid, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity: project name, hub name, registry name, ... (required)
-        :type entity: str
-        :param uuid: Uuid identifier of the sub-entity (required)
+        :param project: Project (required)
+        :type project: str
+        :param uuid: Run uuid (required)
         :type uuid: str
+        :param body: Run edges graph (required)
+        :type body: V1RunEdgesGraph
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -10618,37 +10577,35 @@ class RunsV1Api(BaseApi):
         :rtype: None
         """
         kwargs["_return_http_data_only"] = True
-        return self.stop_run_with_http_info(owner, entity, uuid, **kwargs)  # noqa: E501
+        return self.set_run_edges_lineage_with_http_info(
+            owner, project, uuid, body, **kwargs
+        )  # noqa: E501
 
     @validate_arguments
-    def stop_run_with_http_info(
+    def set_run_edges_lineage_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        entity: Annotated[
-            StrictStr,
-            Field(
-                ..., description="Entity: project name, hub name, registry name, ..."
-            ),
-        ],
-        uuid: Annotated[
-            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
-        ],
+        project: Annotated[StrictStr, Field(..., description="Project")],
+        uuid: Annotated[StrictStr, Field(..., description="Run uuid")],
+        body: Annotated[V1RunEdgesGraph, Field(..., description="Run edges graph")],
         **kwargs
     ):  # noqa: E501
-        """Stop run  # noqa: E501
+        """Set run edges graph lineage  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.stop_run_with_http_info(owner, entity, uuid, async_req=True)
+        >>> thread = api.set_run_edges_lineage_with_http_info(owner, project, uuid, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Entity: project name, hub name, registry name, ... (required)
-        :type entity: str
-        :param uuid: Uuid identifier of the sub-entity (required)
+        :param project: Project (required)
+        :type project: str
+        :param uuid: Run uuid (required)
         :type uuid: str
+        :param body: Run edges graph (required)
+        :type body: V1RunEdgesGraph
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _return_http_data_only: response data without head status code
@@ -10675,7 +10632,538 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "entity", "uuid"]
+        _all_params = ["owner", "project", "uuid", "body"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method set_run_edges_lineage" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+        if _params["project"]:
+            _path_params["project"] = _params["project"]
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params["body"]:
+            _body_params = _params["body"]
+
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get(
+            "_content_type",
+            self.api_client.select_header_content_type(["application/json"]),
+        )
+        if _content_types_list:
+            _header_params["Content-Type"] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {}
+
+        return self.api_client.call_api(
+            "/api/v1/{owner}/{project}/runs/{uuid}/lineage/edges",
+            "POST",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
+    @validate_arguments
+    def skip_run(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        entity: Annotated[
+            StrictStr,
+            Field(
+                ..., description="Entity: project name, hub name, registry name, ..."
+            ),
+        ],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
+        ],
+        **kwargs
+    ) -> None:  # noqa: E501
+        """Skip run  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.skip_run(owner, entity, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param entity: Entity: project name, hub name, registry name, ... (required)
+        :type entity: str
+        :param uuid: Uuid identifier of the sub-entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: None
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.skip_run_with_http_info(owner, entity, uuid, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def skip_run_with_http_info(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        entity: Annotated[
+            StrictStr,
+            Field(
+                ..., description="Entity: project name, hub name, registry name, ..."
+            ),
+        ],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
+        ],
+        **kwargs
+    ):  # noqa: E501
+        """Skip run  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.skip_run_with_http_info(owner, entity, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param entity: Entity: project name, hub name, registry name, ... (required)
+        :type entity: str
+        :param uuid: Uuid identifier of the sub-entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: None
+        """
+
+        _params = locals()
+
+        _all_params = ["owner", "entity", "uuid"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method skip_run" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+
+        if _params["entity"]:
+            _path_params["entity"] = _params["entity"]
+
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {}
+
+        return self.api_client.call_api(
+            "/api/v1/{owner}/{entity}/runs/{uuid}/skip",
+            "POST",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
+    @validate_arguments
+    def skip_runs(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
+        body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
+        **kwargs
+    ) -> None:  # noqa: E501
+        """Skip runs  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.skip_runs(owner, name, body, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param name: Entity under namespace (required)
+        :type name: str
+        :param body: Uuids of the entities (required)
+        :type body: V1Uuids
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: None
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.skip_runs_with_http_info(owner, name, body, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def skip_runs_with_http_info(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
+        body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
+        **kwargs
+    ):  # noqa: E501
+        """Skip runs  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.skip_runs_with_http_info(owner, name, body, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param name: Entity under namespace (required)
+        :type name: str
+        :param body: Uuids of the entities (required)
+        :type body: V1Uuids
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: None
+        """
+
+        _params = locals()
+
+        _all_params = ["owner", "name", "body"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method skip_runs" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params["body"]:
+            _body_params = _params["body"]
+
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get(
+            "_content_type",
+            self.api_client.select_header_content_type(["application/json"]),
+        )
+        if _content_types_list:
+            _header_params["Content-Type"] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {}
+
+        return self.api_client.call_api(
+            "/api/v1/{owner}/{name}/runs/skip",
+            "POST",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
+    @validate_arguments
+    def stop_run(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        entity: Annotated[
+            StrictStr,
+            Field(
+                ..., description="Entity: project name, hub name, registry name, ..."
+            ),
+        ],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
+        ],
+        **kwargs
+    ) -> None:  # noqa: E501
+        """Stop run  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.stop_run(owner, entity, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param entity: Entity: project name, hub name, registry name, ... (required)
+        :type entity: str
+        :param uuid: Uuid identifier of the sub-entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: None
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.stop_run_with_http_info(owner, entity, uuid, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def stop_run_with_http_info(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        entity: Annotated[
+            StrictStr,
+            Field(
+                ..., description="Entity: project name, hub name, registry name, ..."
+            ),
+        ],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
+        ],
+        **kwargs
+    ):  # noqa: E501
+        """Stop run  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.stop_run_with_http_info(owner, entity, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param entity: Entity: project name, hub name, registry name, ... (required)
+        :type entity: str
+        :param uuid: Uuid identifier of the sub-entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: None
+        """
+
+        _params = locals()
+
+        _all_params = ["owner", "entity", "uuid"]
         _all_params.extend(
             [
                 "async_req",
@@ -10755,9 +11243,7 @@ class RunsV1Api(BaseApi):
     def stop_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -10766,13 +11252,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.stop_runs(owner, project, body, async_req=True)
+        >>> thread = api.stop_runs(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -10791,17 +11277,13 @@ class RunsV1Api(BaseApi):
         :rtype: None
         """
         kwargs["_return_http_data_only"] = True
-        return self.stop_runs_with_http_info(
-            owner, project, body, **kwargs
-        )  # noqa: E501
+        return self.stop_runs_with_http_info(owner, name, body, **kwargs)  # noqa: E501
 
     @validate_arguments
     def stop_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1Uuids, Field(..., description="Uuids of the entities")],
         **kwargs
     ):  # noqa: E501
@@ -10810,13 +11292,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.stop_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.stop_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Uuids of the entities (required)
         :type body: V1Uuids
         :param async_req: Whether to execute the request asynchronously.
@@ -10845,7 +11327,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -10874,8 +11356,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -10911,7 +11393,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/stop",
+            "/api/v1/{owner}/{name}/runs/stop",
             "POST",
             _path_params,
             _query_params,
@@ -11111,9 +11593,7 @@ class RunsV1Api(BaseApi):
     def tag_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1EntitiesTags, Field(..., description="Data")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -11127,8 +11607,8 @@ class RunsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Data (required)
         :type body: V1EntitiesTags
         :param async_req: Whether to execute the request asynchronously.
@@ -11147,17 +11627,13 @@ class RunsV1Api(BaseApi):
         :rtype: None
         """
         kwargs["_return_http_data_only"] = True
-        return self.tag_runs_with_http_info(
-            owner, project, body, **kwargs
-        )  # noqa: E501
+        return self.tag_runs_with_http_info(owner, name, body, **kwargs)  # noqa: E501
 
     @validate_arguments
     def tag_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1EntitiesTags, Field(..., description="Data")],
         **kwargs
     ):  # noqa: E501
@@ -11166,13 +11642,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.tag_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.tag_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Data (required)
         :type body: V1EntitiesTags
         :param async_req: Whether to execute the request asynchronously.
@@ -11201,7 +11677,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -11230,8 +11706,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -11267,7 +11743,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/tag",
+            "/api/v1/{owner}/{name}/runs/tag",
             "POST",
             _path_params,
             _query_params,
@@ -11475,9 +11951,7 @@ class RunsV1Api(BaseApi):
     def transfer_runs(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1EntitiesTransfer, Field(..., description="Data")],
         **kwargs
     ) -> None:  # noqa: E501
@@ -11486,13 +11960,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.transfer_runs(owner, project, body, async_req=True)
+        >>> thread = api.transfer_runs(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Data (required)
         :type body: V1EntitiesTransfer
         :param async_req: Whether to execute the request asynchronously.
@@ -11512,16 +11986,14 @@ class RunsV1Api(BaseApi):
         """
         kwargs["_return_http_data_only"] = True
         return self.transfer_runs_with_http_info(
-            owner, project, body, **kwargs
+            owner, name, body, **kwargs
         )  # noqa: E501
 
     @validate_arguments
     def transfer_runs_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        project: Annotated[
-            StrictStr, Field(..., description="Project under namesapce")
-        ],
+        name: Annotated[StrictStr, Field(..., description="Entity under namespace")],
         body: Annotated[V1EntitiesTransfer, Field(..., description="Data")],
         **kwargs
     ):  # noqa: E501
@@ -11530,13 +12002,13 @@ class RunsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.transfer_runs_with_http_info(owner, project, body, async_req=True)
+        >>> thread = api.transfer_runs_with_http_info(owner, name, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param project: Project under namesapce (required)
-        :type project: str
+        :param name: Entity under namespace (required)
+        :type name: str
         :param body: Data (required)
         :type body: V1EntitiesTransfer
         :param async_req: Whether to execute the request asynchronously.
@@ -11565,7 +12037,7 @@ class RunsV1Api(BaseApi):
 
         _params = locals()
 
-        _all_params = ["owner", "project", "body"]
+        _all_params = ["owner", "name", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -11594,8 +12066,8 @@ class RunsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["project"]:
-            _path_params["project"] = _params["project"]
+        if _params["name"]:
+            _path_params["name"] = _params["name"]
 
         # process the query parameters
         _query_params = []
@@ -11631,7 +12103,7 @@ class RunsV1Api(BaseApi):
         _response_types_map = {}
 
         return self.api_client.call_api(
-            "/api/v1/{owner}/{project}/runs/transfer",
+            "/api/v1/{owner}/{name}/runs/transfer",
             "POST",
             _path_params,
             _query_params,