zenml-nightly 0.55.0.dev20240124__py3-none-any.whl → 0.72.0.dev20250116__py3-none-any.whl

zenml/client.py

@@ -13,11 +13,12 @@
 #  permissions and limitations under the License.
 """Client implementation."""
 
+import functools
 import json
 import os
 from abc import ABCMeta
+from collections import Counter
 from datetime import datetime
-from functools import partial
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -35,9 +36,14 @@ from typing import (
 )
 from uuid import UUID, uuid4
 
-from pydantic import SecretStr
+from pydantic import ConfigDict, SecretStr
 
+from zenml.client_lazy_loader import (
+    client_lazy_loader,
+    evaluate_all_lazy_load_args_in_client_methods,
+)
 from zenml.config.global_config import GlobalConfiguration
+from zenml.config.pipeline_run_configuration import PipelineRunConfiguration
 from zenml.config.source import Source
 from zenml.constants import (
     ENV_ZENML_ACTIVE_STACK_ID,
@@ -54,9 +60,10 @@ from zenml.constants import (
 from zenml.enums import (
     ArtifactType,
     LogicalOperators,
-    MetadataResourceTypes,
     ModelStages,
     OAuthDeviceStatus,
+    PluginSubType,
+    PluginType,
     SecretScope,
     SorterOps,
     StackComponentType,
@@ -73,6 +80,10 @@ from zenml.exceptions import (
 from zenml.io import fileio
 from zenml.logger import get_logger
 from zenml.models import (
+    ActionFilter,
+    ActionRequest,
+    ActionResponse,
+    ActionUpdate,
     APIKeyFilter,
     APIKeyRequest,
     APIKeyResponse,
@@ -84,7 +95,7 @@ from zenml.models import (
     ArtifactVersionFilter,
     ArtifactVersionResponse,
     ArtifactVersionUpdate,
-    BaseResponse,
+    BaseIdentifiedResponse,
     CodeRepositoryFilter,
     CodeRepositoryRequest,
     CodeRepositoryResponse,
@@ -93,8 +104,11 @@ from zenml.models import (
     ComponentRequest,
     ComponentResponse,
     ComponentUpdate,
+    EventSourceFilter,
+    EventSourceRequest,
+    EventSourceResponse,
+    EventSourceUpdate,
     FlavorFilter,
-    FlavorRequest,
     FlavorResponse,
     ModelFilter,
     ModelRequest,
@@ -120,15 +134,20 @@ from zenml.models import (
     PipelineResponse,
     PipelineRunFilter,
     PipelineRunResponse,
-    RunMetadataFilter,
     RunMetadataRequest,
-    RunMetadataResponse,
+    RunMetadataResource,
+    RunTemplateFilter,
+    RunTemplateRequest,
+    RunTemplateResponse,
+    RunTemplateUpdate,
     ScheduleFilter,
     ScheduleResponse,
     SecretFilter,
     SecretRequest,
     SecretResponse,
     SecretUpdate,
+    ServerSettingsResponse,
+    ServerSettingsUpdate,
     ServiceAccountFilter,
     ServiceAccountRequest,
     ServiceAccountResponse,
@@ -139,6 +158,10 @@ from zenml.models import (
     ServiceConnectorResponse,
     ServiceConnectorTypeModel,
     ServiceConnectorUpdate,
+    ServiceFilter,
+    ServiceRequest,
+    ServiceResponse,
+    ServiceUpdate,
     StackFilter,
     StackRequest,
     StackResponse,
@@ -149,6 +172,12 @@ from zenml.models import (
     TagRequest,
     TagResponse,
     TagUpdate,
+    TriggerExecutionFilter,
+    TriggerExecutionResponse,
+    TriggerFilter,
+    TriggerRequest,
+    TriggerResponse,
+    TriggerUpdate,
     UserFilter,
     UserRequest,
     UserResponse,
@@ -158,7 +187,12 @@ from zenml.models import (
     WorkspaceResponse,
     WorkspaceUpdate,
 )
+from zenml.models.v2.core.step_run import StepRunUpdate
+from zenml.services.service import ServiceConfig
+from zenml.services.service_status import ServiceState
+from zenml.services.service_type import ServiceType
 from zenml.utils import io_utils, source_utils
+from zenml.utils.dict_utils import dict_to_bytes
 from zenml.utils.filesync_model import FileSyncModel
 from zenml.utils.pagination_utils import depaginate
 from zenml.utils.uuid_utils import is_valid_uuid
@@ -171,7 +205,8 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
-AnyResponse = TypeVar("AnyResponse", bound=BaseResponse)  # type: ignore[type-arg]
+AnyResponse = TypeVar("AnyResponse", bound=BaseIdentifiedResponse)  # type: ignore[type-arg]
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 class ClientConfiguration(FileSyncModel):
@@ -219,18 +254,14 @@ class ClientConfiguration(FileSyncModel):
         self.active_stack_id = stack.id
         self._active_stack = stack
 
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # Validate attributes when assigning them. We need to set this in order
         # to have a mix of mutable and immutable attributes
-        validate_assignment = True
+        validate_assignment=True,
         # Allow extra attributes from configs of previous ZenML versions to
         # permit downgrading
-        extra = "allow"
-        # all attributes with leading underscore are private and therefore
-        # are mutable and not included in serialization
-        underscore_attrs_are_private = True
+        extra="allow",
+    )
 
 
 class ClientMetaClass(ABCMeta):
@@ -281,6 +312,30 @@ class ClientMetaClass(ABCMeta):
         return cls._global_client
 
 
+def _fail_for_sql_zen_store(method: F) -> F:
+    """Decorator for methods that are not allowed with a SQLZenStore.
+
+    Args:
+        method: The method to decorate.
+
+    Returns:
+        The decorated method.
+    """
+
+    @functools.wraps(method)
+    def wrapper(self: "Client", *args: Any, **kwargs: Any) -> Any:
+        # No isinstance check to avoid importing ZenStore implementations
+        if self.zen_store.__class__.__name__ == "SqlZenStore":
+            raise TypeError(
+                "This method is not allowed when not connected "
+                "to a ZenML Server through the API interface."
+            )
+        return method(self, *args, **kwargs)
+
+    return cast(F, wrapper)
+
+
+@evaluate_all_lazy_load_args_in_client_methods
 class Client(metaclass=ClientMetaClass):
     """ZenML client class.
 
@@ -289,6 +344,8 @@ class Client(metaclass=ClientMetaClass):
     """
 
     _active_user: Optional["UserResponse"] = None
+    _active_workspace: Optional["WorkspaceResponse"] = None
+    _active_stack: Optional["StackResponse"] = None
 
     def __init__(
         self,
@@ -643,12 +700,62 @@ class Client(metaclass=ClientMetaClass):
             GlobalConfiguration().set_active_workspace(workspace)
         return workspace
 
+    # ----------------------------- Server Settings ----------------------------
+
+    def get_settings(self, hydrate: bool = True) -> ServerSettingsResponse:
+        """Get the server settings.
+
+        Args:
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            The server settings.
+        """
+        return self.zen_store.get_server_settings(hydrate=hydrate)
+
+    def update_server_settings(
+        self,
+        updated_name: Optional[str] = None,
+        updated_logo_url: Optional[str] = None,
+        updated_enable_analytics: Optional[bool] = None,
+        updated_enable_announcements: Optional[bool] = None,
+        updated_enable_updates: Optional[bool] = None,
+        updated_onboarding_state: Optional[Dict[str, Any]] = None,
+    ) -> ServerSettingsResponse:
+        """Update the server settings.
+
+        Args:
+            updated_name: Updated name for the server.
+            updated_logo_url: Updated logo URL for the server.
+            updated_enable_analytics: Updated value whether to enable
+                analytics for the server.
+            updated_enable_announcements: Updated value whether to display
+                announcements about ZenML.
+            updated_enable_updates: Updated value whether to display updates
+                about ZenML.
+            updated_onboarding_state: Updated onboarding state for the server.
+
+        Returns:
+            The updated server settings.
+        """
+        update_model = ServerSettingsUpdate(
+            server_name=updated_name,
+            logo_url=updated_logo_url,
+            enable_analytics=updated_enable_analytics,
+            display_announcements=updated_enable_announcements,
+            display_updates=updated_enable_updates,
+            onboarding_state=updated_onboarding_state,
+        )
+        return self.zen_store.update_server_settings(update_model)
+
     # ---------------------------------- Users ---------------------------------
 
     def create_user(
         self,
         name: str,
         password: Optional[str] = None,
+        is_admin: bool = False,
     ) -> UserResponse:
         """Create a new user.
 
@@ -656,11 +763,14 @@ class Client(metaclass=ClientMetaClass):
             name: The name of the user.
             password: The password of the user. If not provided, the user will
                 be created with empty password.
+            is_admin: Whether the user should be an admin.
 
         Returns:
             The model of the created user.
         """
-        user = UserRequest(name=name, password=password or None)
+        user = UserRequest(
+            name=name, password=password or None, is_admin=is_admin
+        )
         user.active = (
             password != "" if self.zen_store.type != StoreType.REST else True
         )
@@ -758,7 +868,11 @@ class Client(metaclass=ClientMetaClass):
         updated_full_name: Optional[str] = None,
         updated_email: Optional[str] = None,
         updated_email_opt_in: Optional[bool] = None,
-        updated_hub_token: Optional[str] = None,
+        updated_password: Optional[str] = None,
+        old_password: Optional[str] = None,
+        updated_is_admin: Optional[bool] = None,
+        updated_metadata: Optional[Dict[str, Any]] = None,
+        active: Optional[bool] = None,
     ) -> UserResponse:
         """Update a user.
 
@@ -768,10 +882,19 @@ class Client(metaclass=ClientMetaClass):
             updated_full_name: The new full name of the user.
             updated_email: The new email of the user.
             updated_email_opt_in: The new email opt-in status of the user.
-            updated_hub_token: Update the hub token
+            updated_password: The new password of the user.
+            old_password: The old password of the user. Required for password
+                update.
+            updated_is_admin: Whether the user should be an admin.
+            updated_metadata: The new metadata for the user.
+            active: Use to activate or deactivate the user.
 
         Returns:
             The updated user.
+
+        Raises:
+            ValidationError: If the old password is not provided when updating
+                the password.
         """
         user = self.get_user(
             name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
@@ -786,13 +909,41 @@ class Client(metaclass=ClientMetaClass):
             )
         if updated_email_opt_in is not None:
             user_update.email_opted_in = updated_email_opt_in
-        if updated_hub_token is not None:
-            user_update.hub_token = updated_hub_token
+        if updated_password is not None:
+            user_update.password = updated_password
+            if old_password is None:
+                raise ValidationError(
+                    "Old password is required to update the password."
+                )
+            user_update.old_password = old_password
+        if updated_is_admin is not None:
+            user_update.is_admin = updated_is_admin
+        if active is not None:
+            user_update.active = active
+
+        if updated_metadata is not None:
+            user_update.user_metadata = updated_metadata
 
         return self.zen_store.update_user(
             user_id=user.id, user_update=user_update
         )
 
+    @_fail_for_sql_zen_store
+    def deactivate_user(self, name_id_or_prefix: str) -> "UserResponse":
+        """Deactivate a user and generate an activation token.
+
+        Args:
+            name_id_or_prefix: The name or ID of the user to reset.
+
+        Returns:
+            The deactivated user.
+        """
+        from zenml.zen_stores.rest_zen_store import RestZenStore
+
+        user = self.get_user(name_id_or_prefix, allow_name_prefix_match=False)
+        assert isinstance(self.zen_store, RestZenStore)
+        return self.zen_store.deactivate_user(user_name_or_id=user.name)
+
     def delete_user(self, name_id_or_prefix: str) -> None:
         """Delete a user.
 
@@ -962,9 +1113,13 @@ class Client(metaclass=ClientMetaClass):
         Raises:
             RuntimeError: If the active workspace is not set.
         """
-        if ENV_ZENML_ACTIVE_WORKSPACE_ID in os.environ:
-            workspace_id = os.environ[ENV_ZENML_ACTIVE_WORKSPACE_ID]
-            return self.get_workspace(workspace_id)
+        if workspace_id := os.environ.get(ENV_ZENML_ACTIVE_WORKSPACE_ID):
+            if not self._active_workspace or self._active_workspace.id != UUID(
+                workspace_id
+            ):
+                self._active_workspace = self.get_workspace(workspace_id)
+
+            return self._active_workspace
 
         from zenml.constants import DEFAULT_WORKSPACE_NAME
 
@@ -1001,6 +1156,7 @@ class Client(metaclass=ClientMetaClass):
         name: str,
         components: Mapping[StackComponentType, Union[str, UUID]],
         stack_spec_file: Optional[str] = None,
+        labels: Optional[Dict[str, Any]] = None,
     ) -> StackResponse:
         """Registers a stack and its components.
 
@@ -1008,6 +1164,7 @@ class Client(metaclass=ClientMetaClass):
             name: The name of the stack to register.
             components: dictionary which maps component types to component names
             stack_spec_file: path to the stack spec file
+            labels: The labels of the stack.
 
         Returns:
             The model of the registered stack.
@@ -1032,6 +1189,7 @@ class Client(metaclass=ClientMetaClass):
             stack_spec_path=stack_spec_file,
             workspace=self.active_workspace.id,
             user=self.active_user.id,
+            labels=labels,
         )
 
         self._validate_stack_configuration(stack=stack)
@@ -1075,13 +1233,15 @@ class Client(metaclass=ClientMetaClass):
         size: int = PAGE_SIZE_DEFAULT,
         logical_operator: LogicalOperators = LogicalOperators.AND,
         id: Optional[Union[UUID, str]] = None,
-        created: Optional[datetime] = None,
-        updated: Optional[datetime] = None,
+        created: Optional[Union[datetime, str]] = None,
+        updated: Optional[Union[datetime, str]] = None,
         name: Optional[str] = None,
         description: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
         component_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        component: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[StackResponse]:
         """Lists all stacks.
@@ -1098,6 +1258,8 @@ class Client(metaclass=ClientMetaClass):
             workspace_id: The id of the workspace to filter by.
             user_id: The  id of the user to filter by.
             component_id: The id of the component to filter by.
+            user: The name/ID of the user to filter by.
+            component: The name/ID of the component to filter by.
             name: The name of the stack to filter by.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
@@ -1113,6 +1275,8 @@ class Client(metaclass=ClientMetaClass):
             workspace_id=workspace_id,
             user_id=user_id,
             component_id=component_id,
+            user=user,
+            component=component,
             name=name,
             description=description,
             id=id,
@@ -1127,6 +1291,7 @@ class Client(metaclass=ClientMetaClass):
         name_id_or_prefix: Optional[Union[UUID, str]] = None,
         name: Optional[str] = None,
         stack_spec_file: Optional[str] = None,
+        labels: Optional[Dict[str, Any]] = None,
         description: Optional[str] = None,
         component_updates: Optional[
             Dict[StackComponentType, List[Union[UUID, str]]]
@@ -1137,7 +1302,8 @@ class Client(metaclass=ClientMetaClass):
         Args:
             name_id_or_prefix: The name, id or prefix of the stack to update.
             name: the new name of the stack.
-            stack_spec_file: path to the stack spec file
+            stack_spec_file: path to the stack spec file.
+            labels: The new labels of the stack component.
             description: the new description of the stack.
             component_updates: dictionary which maps stack component types to
                 lists of new stack component names or ids.
@@ -1154,7 +1320,7 @@ class Client(metaclass=ClientMetaClass):
         )
 
         # Create the update model
-        update_model = StackUpdate(  # type: ignore[call-arg]
+        update_model = StackUpdate(
             workspace=self.active_workspace.id,
             user=self.active_user.id,
             stack_spec_path=stack_spec_file,
@@ -1191,6 +1357,15 @@ class Client(metaclass=ClientMetaClass):
                 for c_type, c_list in components_dict.items()
             }
 
+        if labels is not None:
+            existing_labels = stack.labels or {}
+            existing_labels.update(labels)
+
+            existing_labels = {
+                k: v for k, v in existing_labels.items() if v is not None
+            }
+            update_model.labels = existing_labels
+
         updated_stack = self.zen_store.update_stack(
             stack_id=stack.id,
             stack_update=update_model,
@@ -1294,8 +1469,13 @@ class Client(metaclass=ClientMetaClass):
         Raises:
             RuntimeError: If the active stack is not set.
         """
-        if ENV_ZENML_ACTIVE_STACK_ID in os.environ:
-            return self.get_stack(os.environ[ENV_ZENML_ACTIVE_STACK_ID])
+        if env_stack_id := os.environ.get(ENV_ZENML_ACTIVE_STACK_ID):
+            if not self._active_stack or self._active_stack.id != UUID(
+                env_stack_id
+            ):
+                self._active_stack = self.get_stack(env_stack_id)
+
+            return self._active_stack
 
         stack_id: Optional[UUID] = None
 
@@ -1357,25 +1537,25 @@ class Client(metaclass=ClientMetaClass):
             stack: The stack to validate.
 
         Raises:
-            KeyError: If the stack references missing components.
             ValidationError: If the stack configuration is invalid.
         """
         local_components: List[str] = []
         remote_components: List[str] = []
         assert stack.components is not None
-        for component_type, component_ids in stack.components.items():
-            for component_id in component_ids:
-                try:
-                    component = self.get_stack_component(
-                        name_id_or_prefix=component_id,
+        for component_type, components in stack.components.items():
+            component_flavor: Union[FlavorResponse, str]
+
+            for component in components:
+                if isinstance(component, UUID):
+                    component_response = self.get_stack_component(
+                        name_id_or_prefix=component,
                         component_type=component_type,
                     )
-                except KeyError as e:
-                    raise KeyError(
-                        f"Cannot register stack '{stack.name}' since it has an "
-                        f"unregistered {component_type} with id "
-                        f"'{component_id}'."
-                    ) from e
+                    component_config = component_response.configuration
+                    component_flavor = component_response.flavor
+                else:
+                    component_config = component.configuration
+                    component_flavor = component.flavor
 
                 # Create and validate the configuration
                 from zenml.stack.utils import (
@@ -1384,9 +1564,9 @@ class Client(metaclass=ClientMetaClass):
                 )
 
                 configuration = validate_stack_component_config(
-                    configuration_dict=component.configuration,
-                    flavor_name=component.flavor,
-                    component_type=component.type,
+                    configuration_dict=component_config,
+                    flavor=component_flavor,
+                    component_type=component_type,
                     # Always enforce validation of custom flavors
                     validate_custom_flavors=True,
                 )
@@ -1394,13 +1574,18 @@ class Client(metaclass=ClientMetaClass):
                 # `validate_custom_flavors=True` above
                 assert configuration is not None
                 warn_if_config_server_mismatch(configuration)
+                flavor_name = (
+                    component_flavor.name
+                    if isinstance(component_flavor, FlavorResponse)
+                    else component_flavor
+                )
                 if configuration.is_local:
                     local_components.append(
-                        f"{component.type.value}: {component.name}"
+                        f"{component_type.value}: {flavor_name}"
                     )
                 elif configuration.is_remote:
                     remote_components.append(
-                        f"{component.type.value}: {component.name}"
+                        f"{component_type.value}: {flavor_name}"
                     )
 
         if local_components and remote_components:
@@ -1424,6 +1609,230 @@ class Client(metaclass=ClientMetaClass):
                 "an Orchestrator."
             )
 
+    # ----------------------------- Services -----------------------------------
+
+    def create_service(
+        self,
+        config: ServiceConfig,
+        service_type: ServiceType,
+        model_version_id: Optional[UUID] = None,
+    ) -> ServiceResponse:
+        """Registers a service.
+
+        Args:
+            config: The configuration of the service.
+            service_type: The type of the service.
+            model_version_id: The ID of the model version to associate with the
+                service.
+
+        Returns:
+            The registered service.
+        """
+        service_request = ServiceRequest(
+            name=config.service_name,
+            service_type=service_type,
+            config=config.model_dump(),
+            workspace=self.active_workspace.id,
+            user=self.active_user.id,
+            model_version_id=model_version_id,
+        )
+        # Register the service
+        return self.zen_store.create_service(service_request)
+
+    def get_service(
+        self,
+        name_id_or_prefix: Union[str, UUID],
+        allow_name_prefix_match: bool = True,
+        hydrate: bool = True,
+        type: Optional[str] = None,
+    ) -> ServiceResponse:
+        """Gets a service.
+
+        Args:
+            name_id_or_prefix: The name or ID of the service.
+            allow_name_prefix_match: If True, allow matching by name prefix.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+            type: The type of the service.
+
+        Returns:
+            The Service
+        """
+
+        def type_scoped_list_method(
+            hydrate: bool = True,
+            **kwargs: Any,
+        ) -> Page[ServiceResponse]:
+            """Call `zen_store.list_services` with type scoping.
+
+            Args:
+                hydrate: Flag deciding whether to hydrate the output model(s)
+                    by including metadata fields in the response.
+                **kwargs: Keyword arguments to pass to `ServiceFilterModel`.
+
+            Returns:
+                The type-scoped list of services.
+            """
+            service_filter_model = ServiceFilter(**kwargs)
+            if type:
+                service_filter_model.set_type(type=type)
+            service_filter_model.set_scope_workspace(self.active_workspace.id)
+            return self.zen_store.list_services(
+                filter_model=service_filter_model,
+                hydrate=hydrate,
+            )
+
+        return self._get_entity_by_id_or_name_or_prefix(
+            get_method=self.zen_store.get_service,
+            list_method=type_scoped_list_method,
+            name_id_or_prefix=name_id_or_prefix,
+            allow_name_prefix_match=allow_name_prefix_match,
+            hydrate=hydrate,
+        )
+
+    def list_services(
+        self,
+        sort_by: str = "created",
+        page: int = PAGINATION_STARTING_PAGE,
+        size: int = PAGE_SIZE_DEFAULT,
+        logical_operator: LogicalOperators = LogicalOperators.AND,
+        id: Optional[Union[UUID, str]] = None,
+        created: Optional[datetime] = None,
+        updated: Optional[datetime] = None,
+        type: Optional[str] = None,
+        flavor: Optional[str] = None,
+        user: Optional[Union[UUID, str]] = None,
+        workspace_id: Optional[Union[str, UUID]] = None,
+        user_id: Optional[Union[str, UUID]] = None,
+        hydrate: bool = False,
+        running: Optional[bool] = None,
+        service_name: Optional[str] = None,
+        pipeline_name: Optional[str] = None,
+        pipeline_run_id: Optional[str] = None,
+        pipeline_step_name: Optional[str] = None,
+        model_version_id: Optional[Union[str, UUID]] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> Page[ServiceResponse]:
+        """List all services.
+
+        Args:
+            sort_by: The column to sort by
+            page: The page of items
+            size: The maximum size of all pages
+            logical_operator: Which logical operator to use [and, or]
+            id: Use the id of services to filter by.
+            created: Use to filter by time of creation
+            updated: Use the last updated date for filtering
+            type: Use the service type for filtering
+            flavor: Use the service flavor for filtering
+            workspace_id: The id of the workspace to filter by.
+            user_id: The id of the user to filter by.
+            user: Filter by user name/ID.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+            running: Use the running status for filtering
+            pipeline_name: Use the pipeline name for filtering
+            service_name: Use the service name or model name
+                for filtering
+            pipeline_step_name: Use the pipeline step name for filtering
+            model_version_id: Use the model version id for filtering
+            config: Use the config for filtering
+            pipeline_run_id: Use the pipeline run id for filtering
+
+        Returns:
+            The Service response page.
+        """
+        service_filter_model = ServiceFilter(
+            sort_by=sort_by,
+            page=page,
+            size=size,
+            logical_operator=logical_operator,
+            id=id,
+            created=created,
+            updated=updated,
+            type=type,
+            flavor=flavor,
+            workspace_id=workspace_id,
+            user_id=user_id,
+            user=user,
+            running=running,
+            name=service_name,
+            pipeline_name=pipeline_name,
+            pipeline_step_name=pipeline_step_name,
+            model_version_id=model_version_id,
+            pipeline_run_id=pipeline_run_id,
+            config=dict_to_bytes(config) if config else None,
+        )
+        service_filter_model.set_scope_workspace(self.active_workspace.id)
+        return self.zen_store.list_services(
+            filter_model=service_filter_model, hydrate=hydrate
+        )
+
+    def update_service(
+        self,
+        id: UUID,
+        name: Optional[str] = None,
+        service_source: Optional[str] = None,
+        admin_state: Optional[ServiceState] = None,
+        status: Optional[Dict[str, Any]] = None,
+        endpoint: Optional[Dict[str, Any]] = None,
+        labels: Optional[Dict[str, str]] = None,
+        prediction_url: Optional[str] = None,
+        health_check_url: Optional[str] = None,
+        model_version_id: Optional[UUID] = None,
+    ) -> ServiceResponse:
+        """Update a service.
+
+        Args:
+            id: The ID of the service to update.
+            name: The new name of the service.
+            admin_state: The new admin state of the service.
+            status: The new status of the service.
+            endpoint: The new endpoint of the service.
+            service_source: The new service source of the service.
+            labels: The new labels of the service.
+            prediction_url: The new prediction url of the service.
+            health_check_url: The new health check url of the service.
+            model_version_id: The new model version id of the service.
+
+        Returns:
+            The updated service.
+        """
+        service_update = ServiceUpdate()
+        if name:
+            service_update.name = name
+        if service_source:
+            service_update.service_source = service_source
+        if admin_state:
+            service_update.admin_state = admin_state
+        if status:
+            service_update.status = status
+        if endpoint:
+            service_update.endpoint = endpoint
+        if labels:
+            service_update.labels = labels
+        if prediction_url:
+            service_update.prediction_url = prediction_url
+        if health_check_url:
+            service_update.health_check_url = health_check_url
+        if model_version_id:
+            service_update.model_version_id = model_version_id
+        return self.zen_store.update_service(
+            service_id=id, update=service_update
+        )
+
+    def delete_service(self, name_id_or_prefix: UUID) -> None:
+        """Delete a service.
+
+        Args:
+            name_id_or_prefix: The name or ID of the service to delete.
+        """
+        service = self.get_service(
+            name_id_or_prefix,
+            allow_name_prefix_match=False,
+        )
+        self.zen_store.delete_service(service_id=service.id)
+
     # -------------------------------- Components ------------------------------
 
     def get_stack_component(
@@ -1516,6 +1925,7 @@ class Client(metaclass=ClientMetaClass):
         user_id: Optional[Union[str, UUID]] = None,
         connector_id: Optional[Union[str, UUID]] = None,
         stack_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[ComponentResponse]:
         """Lists all registered stack components.
@@ -1535,6 +1945,7 @@ class Client(metaclass=ClientMetaClass):
             connector_id: The id of the connector to filter by.
             stack_id: The id of the stack to filter by.
             name: The name of the component to filter by.
+            user: The ID of name of the user to filter by.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -1556,6 +1967,7 @@ class Client(metaclass=ClientMetaClass):
             id=id,
             created=created,
             updated=updated,
+            user=user,
         )
         component_filter_model.set_scope_workspace(self.active_workspace.id)
 
@@ -1569,7 +1981,6 @@ class Client(metaclass=ClientMetaClass):
         flavor: str,
         component_type: StackComponentType,
         configuration: Dict[str, str],
-        component_spec_path: Optional[str] = None,
         labels: Optional[Dict[str, Any]] = None,
     ) -> "ComponentResponse":
         """Registers a stack component.
@@ -1577,7 +1988,6 @@ class Client(metaclass=ClientMetaClass):
         Args:
             name: The name of the stack component.
             flavor: The flavor of the stack component.
-            component_spec_path: The path to the stack spec file.
             component_type: The type of the stack component.
             configuration: The configuration of the stack component.
             labels: The labels of the stack component.
@@ -1592,7 +2002,7 @@ class Client(metaclass=ClientMetaClass):
 
         validated_config = validate_stack_component_config(
             configuration_dict=configuration,
-            flavor_name=flavor,
+            flavor=flavor,
             component_type=component_type,
             # Always enforce validation of custom flavors
             validate_custom_flavors=True,
@@ -1606,7 +2016,6 @@ class Client(metaclass=ClientMetaClass):
             name=name,
             type=component_type,
             flavor=flavor,
-            component_spec_path=component_spec_path,
             configuration=configuration,
             user=self.active_user.id,
             workspace=self.active_workspace.id,
@@ -1623,7 +2032,6 @@ class Client(metaclass=ClientMetaClass):
         name_id_or_prefix: Optional[Union[UUID, str]],
         component_type: StackComponentType,
         name: Optional[str] = None,
-        component_spec_path: Optional[str] = None,
         configuration: Optional[Dict[str, Any]] = None,
         labels: Optional[Dict[str, Any]] = None,
         disconnect: Optional[bool] = None,
@@ -1637,7 +2045,6 @@ class Client(metaclass=ClientMetaClass):
                 update.
             component_type: The type of the stack component to update.
             name: The new name of the stack component.
-            component_spec_path: The new path to the stack spec file.
             configuration: The new configuration of the stack component.
             labels: The new labels of the stack component.
             disconnect: Whether to disconnect the stack component from its
@@ -1659,10 +2066,9 @@ class Client(metaclass=ClientMetaClass):
             allow_name_prefix_match=False,
         )
 
-        update_model = ComponentUpdate(  # type: ignore[call-arg]
+        update_model = ComponentUpdate(
             workspace=self.active_workspace.id,
             user=self.active_user.id,
-            component_spec_path=component_spec_path,
         )
 
         if name is not None:
@@ -1693,7 +2099,7 @@ class Client(metaclass=ClientMetaClass):
 
             validated_config = validate_stack_component_config(
                 configuration_dict=existing_configuration,
-                flavor_name=component.flavor,
+                flavor=component.flavor,
                 component_type=component.type,
                 # Always enforce validation of custom flavors
                 validate_custom_flavors=True,
@@ -1794,17 +2200,8 @@ class Client(metaclass=ClientMetaClass):
                 "configuration class' docstring."
             )
 
-        create_flavor_request = FlavorRequest(
-            source=source,
-            type=flavor.type,
-            name=flavor.name,
-            config_schema=flavor.config_schema,
-            integration="custom",
-            user=self.active_user.id,
-            workspace=self.active_workspace.id,
-        )
-
-        return self.zen_store.create_flavor(flavor=create_flavor_request)
+        flavor_request = flavor.to_model(integration="custom", is_custom=True)
+        return self.zen_store.create_flavor(flavor=flavor_request)
 
     def get_flavor(
         self,
@@ -1845,6 +2242,7 @@ class Client(metaclass=ClientMetaClass):
         type: Optional[str] = None,
         integration: Optional[str] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[FlavorResponse]:
         """Fetches all the flavor models.
@@ -1858,6 +2256,7 @@ class Client(metaclass=ClientMetaClass):
             created: Use to flavors by time of creation
             updated: Use the last updated date for filtering
             user_id: The  id of the user to filter by.
+            user: Filter by user name/ID.
             name: The name of the flavor to filter by.
             type: The type of the flavor to filter by.
             integration: The integration of the flavor to filter by.
@@ -1873,6 +2272,7 @@ class Client(metaclass=ClientMetaClass):
             sort_by=sort_by,
             logical_operator=logical_operator,
             user_id=user_id,
+            user=user,
             name=name,
             type=type,
             integration=integration,
@@ -1964,11 +2364,11 @@ class Client(metaclass=ClientMetaClass):
         created: Optional[Union[datetime, str]] = None,
         updated: Optional[Union[datetime, str]] = None,
         name: Optional[str] = None,
-        version: Optional[str] = None,
-        version_hash: Optional[str] = None,
-        docstring: Optional[str] = None,
+        latest_run_status: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        tag: Optional[str] = None,
         hydrate: bool = False,
     ) -> Page[PipelineResponse]:
         """List all pipelines.
@@ -1982,11 +2382,12 @@ class Client(metaclass=ClientMetaClass):
             created: Use to filter by time of creation
             updated: Use the last updated date for filtering
             name: The name of the pipeline to filter by.
-            version: The version of the pipeline to filter by.
-            version_hash: The version hash of the pipeline to filter by.
-            docstring: The docstring of the pipeline to filter by.
+            latest_run_status: Filter by the status of the latest run of a
+                pipeline.
             workspace_id: The id of the workspace to filter by.
             user_id: The id of the user to filter by.
+            user: The name/ID of the user to filter by.
+            tag: Tag to filter by.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -2002,11 +2403,11 @@ class Client(metaclass=ClientMetaClass):
             created=created,
             updated=updated,
             name=name,
-            version=version,
-            version_hash=version_hash,
-            docstring=docstring,
+            latest_run_status=latest_run_status,
             workspace_id=workspace_id,
             user_id=user_id,
+            user=user,
+            tag=tag,
         )
         pipeline_filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_pipelines(
@@ -2017,46 +2418,176 @@ class Client(metaclass=ClientMetaClass):
     def get_pipeline(
         self,
         name_id_or_prefix: Union[str, UUID],
-        version: Optional[str] = None,
         hydrate: bool = True,
     ) -> PipelineResponse:
         """Get a pipeline by name, id or prefix.
 
         Args:
             name_id_or_prefix: The name, ID or ID prefix of the pipeline.
-            version: The pipeline version. If not specified, the latest
-                version is returned.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
         Returns:
             The pipeline.
         """
-        return self._get_entity_version_by_id_or_name_or_prefix(
+        return self._get_entity_by_id_or_name_or_prefix(
             get_method=self.zen_store.get_pipeline,
             list_method=self.list_pipelines,
             name_id_or_prefix=name_id_or_prefix,
-            version=version,
             hydrate=hydrate,
         )
 
     def delete_pipeline(
         self,
         name_id_or_prefix: Union[str, UUID],
-        version: Optional[str] = None,
     ) -> None:
         """Delete a pipeline.
 
         Args:
             name_id_or_prefix: The name, ID or ID prefix of the pipeline.
-            version: The pipeline version. If left empty, will delete
-                the latest version.
         """
-        pipeline = self.get_pipeline(
-            name_id_or_prefix=name_id_or_prefix, version=version
-        )
+        pipeline = self.get_pipeline(name_id_or_prefix=name_id_or_prefix)
         self.zen_store.delete_pipeline(pipeline_id=pipeline.id)
 
+    @_fail_for_sql_zen_store
+    def trigger_pipeline(
+        self,
+        pipeline_name_or_id: Union[str, UUID, None] = None,
+        run_configuration: Optional[PipelineRunConfiguration] = None,
+        config_path: Optional[str] = None,
+        template_id: Optional[UUID] = None,
+        stack_name_or_id: Union[str, UUID, None] = None,
+        synchronous: bool = False,
+    ) -> PipelineRunResponse:
+        """Trigger a pipeline from the server.
+
+        Usage examples:
+        * Run the latest runnable template for a pipeline:
+        ```python
+        Client().trigger_pipeline(pipeline_name_or_id=<NAME>)
+        ```
+        * Run the latest runnable template for a pipeline on a specific stack:
+        ```python
+        Client().trigger_pipeline(
+            pipeline_name_or_id=<NAME>,
+            stack_name_or_id=<STACK_NAME_OR_ID>
+        )
+        ```
+        * Run a specific template:
+        ```python
+        Client().trigger_pipeline(template_id=<ID>)
+        ```
+
+        Args:
+            pipeline_name_or_id: Name or ID of the pipeline. If this is
+                specified, the latest runnable template for this pipeline will
+                be used for the run (Runnable here means that the build
+                associated with the template is for a remote stack without any
+                custom flavor stack components). If not given, a template ID
+                that should be run needs to be specified.
+            run_configuration: Configuration for the run. Either this or a
+                path to a config file can be specified.
+            config_path: Path to a YAML configuration file. This file will be
+                parsed as a `PipelineRunConfiguration` object. Either this or
+                the configuration in code can be specified.
+            template_id: ID of the template to run. Either this or a pipeline
+                can be specified.
+            stack_name_or_id: Name or ID of the stack on which to run the
+                pipeline. If not specified, this method will try to find a
+                runnable template on any stack.
+            synchronous: If `True`, this method will wait until the triggered
+                run is finished.
+
+        Raises:
+            RuntimeError: If triggering the pipeline failed.
+
+        Returns:
+            Model of the pipeline run.
+        """
+        from zenml.pipelines.run_utils import (
+            validate_run_config_is_runnable_from_server,
+            validate_stack_is_runnable_from_server,
+            wait_for_pipeline_run_to_finish,
+        )
+
+        if Counter([template_id, pipeline_name_or_id])[None] != 1:
+            raise RuntimeError(
+                "You need to specify exactly one of pipeline or template "
+                "to trigger."
+            )
+
+        if run_configuration and config_path:
+            raise RuntimeError(
+                "Only config path or runtime configuration can be specified."
+            )
+
+        if config_path:
+            run_configuration = PipelineRunConfiguration.from_yaml(config_path)
+
+        if run_configuration:
+            validate_run_config_is_runnable_from_server(run_configuration)
+
+        if template_id:
+            if stack_name_or_id:
+                logger.warning(
+                    "Template ID and stack specified, ignoring the stack and "
+                    "using stack associated with the template instead."
+                )
+
+            run = self.zen_store.run_template(
+                template_id=template_id,
+                run_configuration=run_configuration,
+            )
+        else:
+            assert pipeline_name_or_id
+            pipeline = self.get_pipeline(name_id_or_prefix=pipeline_name_or_id)
+
+            stack = None
+            if stack_name_or_id:
+                stack = self.get_stack(
+                    stack_name_or_id, allow_name_prefix_match=False
+                )
+                validate_stack_is_runnable_from_server(
+                    zen_store=self.zen_store, stack=stack
+                )
+
+            templates = depaginate(
+                self.list_run_templates,
+                pipeline_id=pipeline.id,
+                stack_id=stack.id if stack else None,
+            )
+
+            for template in templates:
+                if not template.build:
+                    continue
+
+                stack = template.build.stack
+                if not stack:
+                    continue
+
+                try:
+                    validate_stack_is_runnable_from_server(
+                        zen_store=self.zen_store, stack=stack
+                    )
+                except ValueError:
+                    continue
+
+                run = self.zen_store.run_template(
+                    template_id=template.id,
+                    run_configuration=run_configuration,
+                )
+                break
+            else:
+                raise RuntimeError(
+                    "Unable to find a runnable template for the given stack "
+                    "and pipeline."
+                )
+
+        if synchronous:
+            run = wait_for_pipeline_run_to_finish(run_id=run.id)
+
+        return run
+
     # -------------------------------- Builds ----------------------------------
 
     def get_build(
@@ -2126,13 +2657,16 @@ class Client(metaclass=ClientMetaClass):
         updated: Optional[Union[datetime, str]] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         pipeline_id: Optional[Union[str, UUID]] = None,
         stack_id: Optional[Union[str, UUID]] = None,
+        container_registry_id: Optional[Union[UUID, str]] = None,
         is_local: Optional[bool] = None,
         contains_code: Optional[bool] = None,
         zenml_version: Optional[str] = None,
         python_version: Optional[str] = None,
         checksum: Optional[str] = None,
+        stack_checksum: Optional[str] = None,
         hydrate: bool = False,
     ) -> Page[PipelineBuildResponse]:
         """List all builds.
@@ -2147,13 +2681,17 @@ class Client(metaclass=ClientMetaClass):
             updated: Use the last updated date for filtering
             workspace_id: The id of the workspace to filter by.
             user_id: The  id of the user to filter by.
+            user: Filter by user name/ID.
             pipeline_id: The id of the pipeline to filter by.
             stack_id: The id of the stack to filter by.
+            container_registry_id: The id of the container registry to
+                filter by.
             is_local: Use to filter local builds.
             contains_code: Use to filter builds that contain code.
             zenml_version: The version of ZenML to filter by.
             python_version: The Python version to filter by.
             checksum: The build checksum to filter by.
+            stack_checksum: The stack checksum to filter by.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -2170,13 +2708,16 @@ class Client(metaclass=ClientMetaClass):
             updated=updated,
             workspace_id=workspace_id,
             user_id=user_id,
+            user=user,
             pipeline_id=pipeline_id,
             stack_id=stack_id,
+            container_registry_id=container_registry_id,
             is_local=is_local,
             contains_code=contains_code,
             zenml_version=zenml_version,
             python_version=python_version,
             checksum=checksum,
+            stack_checksum=stack_checksum,
         )
         build_filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_builds(
@@ -2193,36 +2734,615 @@ class Client(metaclass=ClientMetaClass):
         build = self.get_build(id_or_prefix=id_or_prefix)
         self.zen_store.delete_build(build_id=build.id)
 
-    # ------------------------------ Deployments -------------------------------
+    # --------------------------------- Event Sources -------------------------
 
-    def get_deployment(
+    @_fail_for_sql_zen_store
+    def create_event_source(
         self,
-        id_or_prefix: str,
-        hydrate: bool = True,
-    ) -> PipelineDeploymentResponse:
-        """Get a deployment by id or prefix.
+        name: str,
+        configuration: Dict[str, Any],
+        flavor: str,
+        event_source_subtype: PluginSubType,
+        description: str = "",
+    ) -> EventSourceResponse:
+        """Registers an event source.
 
         Args:
-            id_or_prefix: The id or id prefix of the build.
-            hydrate: Flag deciding whether to hydrate the output model(s)
-                by including metadata fields in the response.
+            name: The name of the event source to create.
+            configuration: Configuration for this event source.
+            flavor: The flavor of event source.
+            event_source_subtype: The event source subtype.
+            description: The description of the event source.
 
         Returns:
-            The deployment.
-
-        Raises:
-            KeyError: If no deployment was found for the given id or prefix.
-            ZenKeyError: If multiple deployments were found that match the given
-                id or prefix.
+            The model of the registered event source.
         """
-        from zenml.utils.uuid_utils import is_valid_uuid
+        event_source = EventSourceRequest(
+            name=name,
+            configuration=configuration,
+            description=description,
+            flavor=flavor,
+            plugin_type=PluginType.EVENT_SOURCE,
+            plugin_subtype=event_source_subtype,
+            user=self.active_user.id,
+            workspace=self.active_workspace.id,
+        )
+
+        return self.zen_store.create_event_source(event_source=event_source)
+
+    @_fail_for_sql_zen_store
+    def get_event_source(
+        self,
+        name_id_or_prefix: Union[UUID, str],
+        allow_name_prefix_match: bool = True,
+        hydrate: bool = True,
+    ) -> EventSourceResponse:
+        """Get an event source by name, ID or prefix.
+
+        Args:
+            name_id_or_prefix: The name, ID or prefix of the stack.
+            allow_name_prefix_match: If True, allow matching by name prefix.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            The event_source.
+        """
+        return self._get_entity_by_id_or_name_or_prefix(
+            get_method=self.zen_store.get_event_source,
+            list_method=self.list_event_sources,
+            name_id_or_prefix=name_id_or_prefix,
+            allow_name_prefix_match=allow_name_prefix_match,
+            hydrate=hydrate,
+        )
+
+    def list_event_sources(
+        self,
+        sort_by: str = "created",
+        page: int = PAGINATION_STARTING_PAGE,
+        size: int = PAGE_SIZE_DEFAULT,
+        logical_operator: LogicalOperators = LogicalOperators.AND,
+        id: Optional[Union[UUID, str]] = None,
+        created: Optional[datetime] = None,
+        updated: Optional[datetime] = None,
+        name: Optional[str] = None,
+        flavor: Optional[str] = None,
+        event_source_type: Optional[str] = None,
+        workspace_id: Optional[Union[str, UUID]] = None,
+        user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        hydrate: bool = False,
+    ) -> Page[EventSourceResponse]:
+        """Lists all event_sources.
+
+        Args:
+            sort_by: The column to sort by
+            page: The page of items
+            size: The maximum size of all pages
+            logical_operator: Which logical operator to use [and, or]
+            id: Use the id of event_sources to filter by.
+            created: Use to filter by time of creation
+            updated: Use the last updated date for filtering
+            workspace_id: The id of the workspace to filter by.
+            user_id: The  id of the user to filter by.
+            user: Filter by user name/ID.
+            name: The name of the event_source to filter by.
+            flavor: The flavor of the event_source to filter by.
+            event_source_type: The subtype of the event_source to filter by.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            A page of event_sources.
+        """
+        event_source_filter_model = EventSourceFilter(
+            page=page,
+            size=size,
+            sort_by=sort_by,
+            logical_operator=logical_operator,
+            workspace_id=workspace_id,
+            user_id=user_id,
+            user=user,
+            name=name,
+            flavor=flavor,
+            plugin_subtype=event_source_type,
+            id=id,
+            created=created,
+            updated=updated,
+        )
+        event_source_filter_model.set_scope_workspace(self.active_workspace.id)
+        return self.zen_store.list_event_sources(
+            event_source_filter_model, hydrate=hydrate
+        )
+
+    @_fail_for_sql_zen_store
+    def update_event_source(
+        self,
+        name_id_or_prefix: Union[UUID, str],
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        configuration: Optional[Dict[str, Any]] = None,
+        rotate_secret: Optional[bool] = None,
+        is_active: Optional[bool] = None,
+    ) -> EventSourceResponse:
+        """Updates a event_source.
+
+        Args:
+            name_id_or_prefix: The name, id or prefix of the event_source to update.
+            name: the new name of the event_source.
+            description: the new description of the event_source.
+            configuration: The event source configuration.
+            rotate_secret: Allows rotating of secret, if true, the response will
+                contain the new secret value
+            is_active: Optional[bool] = Allows for activation/deactivating the
+                event source
+
+        Returns:
+            The model of the updated event_source.
+
+        Raises:
+            EntityExistsError: If the event_source name is already taken.
+        """
+        # First, get the eve
+        event_source = self.get_event_source(
+            name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
+        )
+
+        # Create the update model
+        update_model = EventSourceUpdate(
+            name=name,
+            description=description,
+            configuration=configuration,
+            rotate_secret=rotate_secret,
+            is_active=is_active,
+        )
+
+        if name:
+            if self.list_event_sources(name=name):
+                raise EntityExistsError(
+                    "There are already existing event_sources with the name "
+                    f"'{name}'."
+                )
+
+        updated_event_source = self.zen_store.update_event_source(
+            event_source_id=event_source.id,
+            event_source_update=update_model,
+        )
+        return updated_event_source
+
+    @_fail_for_sql_zen_store
+    def delete_event_source(self, name_id_or_prefix: Union[str, UUID]) -> None:
+        """Deletes an event_source.
+
+        Args:
+            name_id_or_prefix: The name, id or prefix id of the event_source
+                to deregister.
+        """
+        event_source = self.get_event_source(
+            name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
+        )
+
+        self.zen_store.delete_event_source(event_source_id=event_source.id)
+        logger.info("Deleted event_source with name '%s'.", event_source.name)
+
+    # --------------------------------- Actions -------------------------
+
+    @_fail_for_sql_zen_store
+    def create_action(
+        self,
+        name: str,
+        flavor: str,
+        action_type: PluginSubType,
+        configuration: Dict[str, Any],
+        service_account_id: UUID,
+        auth_window: Optional[int] = None,
+        description: str = "",
+    ) -> ActionResponse:
+        """Create an action.
+
+        Args:
+            name: The name of the action.
+            flavor: The flavor of the action,
+            action_type: The action subtype.
+            configuration: The action configuration.
+            service_account_id: The service account that is used to execute the
+                action.
+            auth_window: The time window in minutes for which the service
+                account is authorized to execute the action. Set this to 0 to
+                authorize the service account indefinitely (not recommended).
+            description: The description of the action.
+
+        Returns:
+            The created action
+        """
+        action = ActionRequest(
+            name=name,
+            description=description,
+            flavor=flavor,
+            plugin_subtype=action_type,
+            configuration=configuration,
+            service_account_id=service_account_id,
+            auth_window=auth_window,
+            user=self.active_user.id,
+            workspace=self.active_workspace.id,
+        )
+
+        return self.zen_store.create_action(action=action)
+
+    @_fail_for_sql_zen_store
+    def get_action(
+        self,
+        name_id_or_prefix: Union[UUID, str],
+        allow_name_prefix_match: bool = True,
+        hydrate: bool = True,
+    ) -> ActionResponse:
+        """Get an action by name, ID or prefix.
+
+        Args:
+            name_id_or_prefix: The name, ID or prefix of the action.
+            allow_name_prefix_match: If True, allow matching by name prefix.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            The action.
+        """
+        return self._get_entity_by_id_or_name_or_prefix(
+            get_method=self.zen_store.get_action,
+            list_method=self.list_actions,
+            name_id_or_prefix=name_id_or_prefix,
+            allow_name_prefix_match=allow_name_prefix_match,
+            hydrate=hydrate,
+        )
+
+    @_fail_for_sql_zen_store
+    def list_actions(
+        self,
+        sort_by: str = "created",
+        page: int = PAGINATION_STARTING_PAGE,
+        size: int = PAGE_SIZE_DEFAULT,
+        logical_operator: LogicalOperators = LogicalOperators.AND,
+        id: Optional[Union[UUID, str]] = None,
+        created: Optional[datetime] = None,
+        updated: Optional[datetime] = None,
+        name: Optional[str] = None,
+        flavor: Optional[str] = None,
+        action_type: Optional[str] = None,
+        workspace_id: Optional[Union[str, UUID]] = None,
+        user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        hydrate: bool = False,
+    ) -> Page[ActionResponse]:
+        """List actions.
+
+        Args:
+            sort_by: The column to sort by
+            page: The page of items
+            size: The maximum size of all pages
+            logical_operator: Which logical operator to use [and, or]
+            id: Use the id of the action to filter by.
+            created: Use to filter by time of creation
+            updated: Use the last updated date for filtering
+            workspace_id: The id of the workspace to filter by.
+            user_id: The id of the user to filter by.
+            user: Filter by user name/ID.
+            name: The name of the action to filter by.
+            flavor: The flavor of the action to filter by.
+            action_type: The type of the action to filter by.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            A page of actions.
+        """
+        filter_model = ActionFilter(
+            page=page,
+            size=size,
+            sort_by=sort_by,
+            logical_operator=logical_operator,
+            workspace_id=workspace_id,
+            user_id=user_id,
+            user=user,
+            name=name,
+            id=id,
+            flavor=flavor,
+            plugin_subtype=action_type,
+            created=created,
+            updated=updated,
+        )
+        filter_model.set_scope_workspace(self.active_workspace.id)
+        return self.zen_store.list_actions(filter_model, hydrate=hydrate)
+
+    @_fail_for_sql_zen_store
+    def update_action(
+        self,
+        name_id_or_prefix: Union[UUID, str],
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        configuration: Optional[Dict[str, Any]] = None,
+        service_account_id: Optional[UUID] = None,
+        auth_window: Optional[int] = None,
+    ) -> ActionResponse:
+        """Update an action.
+
+        Args:
+            name_id_or_prefix: The name, id or prefix of the action to update.
+            name: The new name of the action.
+            description: The new description of the action.
+            configuration: The new configuration of the action.
+            service_account_id: The new service account that is used to execute
+                the action.
+            auth_window: The new time window in minutes for which the service
+                account is authorized to execute the action. Set this to 0 to
+                authorize the service account indefinitely (not recommended).
+
+        Returns:
+            The updated action.
+        """
+        action = self.get_action(
+            name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
+        )
+
+        update_model = ActionUpdate(
+            name=name,
+            description=description,
+            configuration=configuration,
+            service_account_id=service_account_id,
+            auth_window=auth_window,
+        )
+
+        return self.zen_store.update_action(
+            action_id=action.id,
+            action_update=update_model,
+        )
+
+    @_fail_for_sql_zen_store
+    def delete_action(self, name_id_or_prefix: Union[str, UUID]) -> None:
+        """Delete an action.
+
+        Args:
+            name_id_or_prefix: The name, id or prefix id of the action
+                to delete.
+        """
+        action = self.get_action(
+            name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
+        )
+
+        self.zen_store.delete_action(action_id=action.id)
+        logger.info("Deleted action with name '%s'.", action.name)
+
+    # --------------------------------- Triggers -------------------------
+
+    @_fail_for_sql_zen_store
+    def create_trigger(
+        self,
+        name: str,
+        event_source_id: UUID,
+        event_filter: Dict[str, Any],
+        action_id: UUID,
+        description: str = "",
+    ) -> TriggerResponse:
+        """Registers a trigger.
+
+        Args:
+            name: The name of the trigger to create.
+            event_source_id: The id of the event source id
+            event_filter: The event filter
+            action_id: The ID of the action that should be triggered.
+            description: The description of the trigger
+
+        Returns:
+            The created trigger.
+        """
+        trigger = TriggerRequest(
+            name=name,
+            description=description,
+            event_source_id=event_source_id,
+            event_filter=event_filter,
+            action_id=action_id,
+            user=self.active_user.id,
+            workspace=self.active_workspace.id,
+        )
+
+        return self.zen_store.create_trigger(trigger=trigger)
+
+    @_fail_for_sql_zen_store
+    def get_trigger(
+        self,
+        name_id_or_prefix: Union[UUID, str],
+        allow_name_prefix_match: bool = True,
+        hydrate: bool = True,
+    ) -> TriggerResponse:
+        """Get a trigger by name, ID or prefix.
+
+        Args:
+            name_id_or_prefix: The name, ID or prefix of the trigger.
+            allow_name_prefix_match: If True, allow matching by name prefix.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            The trigger.
+        """
+        return self._get_entity_by_id_or_name_or_prefix(
+            get_method=self.zen_store.get_trigger,
+            list_method=self.list_triggers,
+            name_id_or_prefix=name_id_or_prefix,
+            allow_name_prefix_match=allow_name_prefix_match,
+            hydrate=hydrate,
+        )
+
+    @_fail_for_sql_zen_store
+    def list_triggers(
+        self,
+        sort_by: str = "created",
+        page: int = PAGINATION_STARTING_PAGE,
+        size: int = PAGE_SIZE_DEFAULT,
+        logical_operator: LogicalOperators = LogicalOperators.AND,
+        id: Optional[Union[UUID, str]] = None,
+        created: Optional[datetime] = None,
+        updated: Optional[datetime] = None,
+        name: Optional[str] = None,
+        event_source_id: Optional[UUID] = None,
+        action_id: Optional[UUID] = None,
+        event_source_flavor: Optional[str] = None,
+        event_source_subtype: Optional[str] = None,
+        action_flavor: Optional[str] = None,
+        action_subtype: Optional[str] = None,
+        workspace_id: Optional[Union[str, UUID]] = None,
+        user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        hydrate: bool = False,
+    ) -> Page[TriggerResponse]:
+        """Lists all triggers.
+
+        Args:
+            sort_by: The column to sort by
+            page: The page of items
+            size: The maximum size of all pages
+            logical_operator: Which logical operator to use [and, or]
+            id: Use the id of triggers to filter by.
+            created: Use to filter by time of creation
+            updated: Use the last updated date for filtering
+            workspace_id: The id of the workspace to filter by.
+            user_id: The  id of the user to filter by.
+            user: Filter by user name/ID.
+            name: The name of the trigger to filter by.
+            event_source_id: The event source associated with the trigger.
+            action_id: The action associated with the trigger.
+            event_source_flavor: Flavor of the event source associated with the
+                trigger.
+            event_source_subtype: Type of the event source associated with the
+                trigger.
+            action_flavor: Flavor of the action associated with the trigger.
+            action_subtype: Type of the action associated with the trigger.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            A page of triggers.
+        """
+        trigger_filter_model = TriggerFilter(
+            page=page,
+            size=size,
+            sort_by=sort_by,
+            logical_operator=logical_operator,
+            workspace_id=workspace_id,
+            user_id=user_id,
+            user=user,
+            name=name,
+            event_source_id=event_source_id,
+            action_id=action_id,
+            event_source_flavor=event_source_flavor,
+            event_source_subtype=event_source_subtype,
+            action_flavor=action_flavor,
+            action_subtype=action_subtype,
+            id=id,
+            created=created,
+            updated=updated,
+        )
+        trigger_filter_model.set_scope_workspace(self.active_workspace.id)
+        return self.zen_store.list_triggers(
+            trigger_filter_model, hydrate=hydrate
+        )
+
+    @_fail_for_sql_zen_store
+    def update_trigger(
+        self,
+        name_id_or_prefix: Union[UUID, str],
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        event_filter: Optional[Dict[str, Any]] = None,
+        is_active: Optional[bool] = None,
+    ) -> TriggerResponse:
+        """Updates a trigger.
+
+        Args:
+            name_id_or_prefix: The name, id or prefix of the trigger to update.
+            name: the new name of the trigger.
+            description: the new description of the trigger.
+            event_filter: The event filter configuration.
+            is_active: Whether the trigger is active or not.
+
+        Returns:
+            The model of the updated trigger.
+
+        Raises:
+            EntityExistsError: If the trigger name is already taken.
+        """
+        # First, get the eve
+        trigger = self.get_trigger(
+            name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
+        )
+
+        # Create the update model
+        update_model = TriggerUpdate(
+            name=name,
+            description=description,
+            event_filter=event_filter,
+            is_active=is_active,
+        )
+
+        if name:
+            if self.list_triggers(name=name):
+                raise EntityExistsError(
+                    "There are already is an existing trigger with the name "
+                    f"'{name}'."
+                )
+
+        updated_trigger = self.zen_store.update_trigger(
+            trigger_id=trigger.id,
+            trigger_update=update_model,
+        )
+        return updated_trigger
+
+    @_fail_for_sql_zen_store
+    def delete_trigger(self, name_id_or_prefix: Union[str, UUID]) -> None:
+        """Deletes an trigger.
+
+        Args:
+            name_id_or_prefix: The name, id or prefix id of the trigger
+                to deregister.
+        """
+        trigger = self.get_trigger(
+            name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
+        )
+
+        self.zen_store.delete_trigger(trigger_id=trigger.id)
+        logger.info("Deleted trigger with name '%s'.", trigger.name)
+
+    # ------------------------------ Deployments -------------------------------
+
+    def get_deployment(
+        self,
+        id_or_prefix: Union[str, UUID],
+        hydrate: bool = True,
+    ) -> PipelineDeploymentResponse:
+        """Get a deployment by id or prefix.
+
+        Args:
+            id_or_prefix: The id or id prefix of the deployment.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            The deployment.
+
+        Raises:
+            KeyError: If no deployment was found for the given id or prefix.
+            ZenKeyError: If multiple deployments were found that match the given
+                id or prefix.
+        """
+        from zenml.utils.uuid_utils import is_valid_uuid
 
         # First interpret as full UUID
         if is_valid_uuid(id_or_prefix):
-            return self.zen_store.get_deployment(
-                UUID(id_or_prefix),
-                hydrate=hydrate,
+            id_ = (
+                UUID(id_or_prefix)
+                if isinstance(id_or_prefix, str)
+                else id_or_prefix
             )
+            return self.zen_store.get_deployment(id_, hydrate=hydrate)
 
         entity = self.list_deployments(
             id=f"startswith:{id_or_prefix}",
@@ -2240,80 +3360,277 @@ class Client(metaclass=ClientMetaClass):
                 f"prefix that matches the provided string '{id_or_prefix}'."
             )
 
-        raise ZenKeyError(
-            f"{entity.total} deployments have been found that have "
-            f"an ID that matches the provided "
-            f"string '{id_or_prefix}':\n"
-            f"{[entity.items]}.\n"
-            f"Please use the id to uniquely identify "
-            f"only one of the deployments."
+        raise ZenKeyError(
+            f"{entity.total} deployments have been found that have "
+            f"an ID that matches the provided "
+            f"string '{id_or_prefix}':\n"
+            f"{[entity.items]}.\n"
+            f"Please use the id to uniquely identify "
+            f"only one of the deployments."
+        )
+
+    def list_deployments(
+        self,
+        sort_by: str = "created",
+        page: int = PAGINATION_STARTING_PAGE,
+        size: int = PAGE_SIZE_DEFAULT,
+        logical_operator: LogicalOperators = LogicalOperators.AND,
+        id: Optional[Union[UUID, str]] = None,
+        created: Optional[Union[datetime, str]] = None,
+        updated: Optional[Union[datetime, str]] = None,
+        workspace_id: Optional[Union[str, UUID]] = None,
+        user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        pipeline_id: Optional[Union[str, UUID]] = None,
+        stack_id: Optional[Union[str, UUID]] = None,
+        build_id: Optional[Union[str, UUID]] = None,
+        template_id: Optional[Union[str, UUID]] = None,
+        hydrate: bool = False,
+    ) -> Page[PipelineDeploymentResponse]:
+        """List all deployments.
+
+        Args:
+            sort_by: The column to sort by
+            page: The page of items
+            size: The maximum size of all pages
+            logical_operator: Which logical operator to use [and, or]
+            id: Use the id of build to filter by.
+            created: Use to filter by time of creation
+            updated: Use the last updated date for filtering
+            workspace_id: The id of the workspace to filter by.
+            user_id: The  id of the user to filter by.
+            user: Filter by user name/ID.
+            pipeline_id: The id of the pipeline to filter by.
+            stack_id: The id of the stack to filter by.
+            build_id: The id of the build to filter by.
+            template_id: The ID of the template to filter by.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            A page with deployments fitting the filter description
+        """
+        deployment_filter_model = PipelineDeploymentFilter(
+            sort_by=sort_by,
+            page=page,
+            size=size,
+            logical_operator=logical_operator,
+            id=id,
+            created=created,
+            updated=updated,
+            workspace_id=workspace_id,
+            user_id=user_id,
+            user=user,
+            pipeline_id=pipeline_id,
+            stack_id=stack_id,
+            build_id=build_id,
+            template_id=template_id,
+        )
+        deployment_filter_model.set_scope_workspace(self.active_workspace.id)
+        return self.zen_store.list_deployments(
+            deployment_filter_model=deployment_filter_model,
+            hydrate=hydrate,
+        )
+
+    def delete_deployment(self, id_or_prefix: str) -> None:
+        """Delete a deployment.
+
+        Args:
+            id_or_prefix: The id or id prefix of the deployment.
+        """
+        deployment = self.get_deployment(
+            id_or_prefix=id_or_prefix, hydrate=False
+        )
+        self.zen_store.delete_deployment(deployment_id=deployment.id)
+
+    # ------------------------------ Run templates -----------------------------
+
+    def create_run_template(
+        self,
+        name: str,
+        deployment_id: UUID,
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+    ) -> RunTemplateResponse:
+        """Create a run template.
+
+        Args:
+            name: The name of the run template.
+            deployment_id: ID of the deployment which this template should be
+                based off of.
+            description: The description of the run template.
+            tags: Tags associated with the run template.
+
+        Returns:
+            The created run template.
+        """
+        return self.zen_store.create_run_template(
+            template=RunTemplateRequest(
+                name=name,
+                description=description,
+                source_deployment_id=deployment_id,
+                tags=tags,
+                user=self.active_user.id,
+                workspace=self.active_workspace.id,
+            )
+        )
+
+    def get_run_template(
+        self,
+        name_id_or_prefix: Union[str, UUID],
+        hydrate: bool = True,
+    ) -> RunTemplateResponse:
+        """Get a run template.
+
+        Args:
+            name_id_or_prefix: Name/ID/ID prefix of the template to get.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            The run template.
+        """
+        return self._get_entity_by_id_or_name_or_prefix(
+            get_method=self.zen_store.get_run_template,
+            list_method=self.list_run_templates,
+            name_id_or_prefix=name_id_or_prefix,
+            allow_name_prefix_match=False,
+            hydrate=hydrate,
         )
 
-    def list_deployments(
+    def list_run_templates(
         self,
         sort_by: str = "created",
         page: int = PAGINATION_STARTING_PAGE,
         size: int = PAGE_SIZE_DEFAULT,
         logical_operator: LogicalOperators = LogicalOperators.AND,
-        id: Optional[Union[UUID, str]] = None,
         created: Optional[Union[datetime, str]] = None,
         updated: Optional[Union[datetime, str]] = None,
+        id: Optional[Union[UUID, str]] = None,
+        name: Optional[str] = None,
+        tag: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
         pipeline_id: Optional[Union[str, UUID]] = None,
-        stack_id: Optional[Union[str, UUID]] = None,
         build_id: Optional[Union[str, UUID]] = None,
+        stack_id: Optional[Union[str, UUID]] = None,
+        code_repository_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        pipeline: Optional[Union[UUID, str]] = None,
+        stack: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
-    ) -> Page[PipelineDeploymentResponse]:
-        """List all deployments.
+    ) -> Page[RunTemplateResponse]:
+        """Get a page of run templates.
 
         Args:
-            sort_by: The column to sort by
-            page: The page of items
-            size: The maximum size of all pages
-            logical_operator: Which logical operator to use [and, or]
-            id: Use the id of build to filter by.
-            created: Use to filter by time of creation
-            updated: Use the last updated date for filtering
-            workspace_id: The id of the workspace to filter by.
-            user_id: The  id of the user to filter by.
-            pipeline_id: The id of the pipeline to filter by.
-            stack_id: The id of the stack to filter by.
-            build_id: The id of the build to filter by.
+            sort_by: The column to sort by.
+            page: The page of items.
+            size: The maximum size of all pages.
+            logical_operator: Which logical operator to use [and, or].
+            created: Filter by the creation date.
+            updated: Filter by the last updated date.
+            id: Filter by run template ID.
+            name: Filter by run template name.
+            tag: Filter by run template tags.
+            workspace_id: Filter by workspace ID.
+            user_id: Filter by user ID.
+            pipeline_id: Filter by pipeline ID.
+            build_id: Filter by build ID.
+            stack_id: Filter by stack ID.
+            code_repository_id: Filter by code repository ID.
+            user: Filter by user name/ID.
+            pipeline: Filter by pipeline name/ID.
+            stack: Filter by stack name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
         Returns:
-            A page with deployments fitting the filter description
+            A page of run templates.
         """
-        deployment_filter_model = PipelineDeploymentFilter(
+        filter = RunTemplateFilter(
             sort_by=sort_by,
             page=page,
             size=size,
             logical_operator=logical_operator,
-            id=id,
             created=created,
             updated=updated,
+            id=id,
+            name=name,
+            tag=tag,
             workspace_id=workspace_id,
             user_id=user_id,
             pipeline_id=pipeline_id,
-            stack_id=stack_id,
             build_id=build_id,
+            stack_id=stack_id,
+            code_repository_id=code_repository_id,
+            user=user,
+            pipeline=pipeline,
+            stack=stack,
         )
-        deployment_filter_model.set_scope_workspace(self.active_workspace.id)
-        return self.zen_store.list_deployments(
-            deployment_filter_model=deployment_filter_model,
-            hydrate=hydrate,
+
+        return self.zen_store.list_run_templates(
+            template_filter_model=filter, hydrate=hydrate
         )
 
-    def delete_deployment(self, id_or_prefix: str) -> None:
-        """Delete a deployment.
+    def update_run_template(
+        self,
+        name_id_or_prefix: Union[str, UUID],
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        add_tags: Optional[List[str]] = None,
+        remove_tags: Optional[List[str]] = None,
+    ) -> RunTemplateResponse:
+        """Update a run template.
 
         Args:
-            id_or_prefix: The id or id prefix of the deployment.
+            name_id_or_prefix: Name/ID/ID prefix of the template to update.
+            name: The new name of the run template.
+            description: The new description of the run template.
+            add_tags: Tags to add to the run template.
+            remove_tags: Tags to remove from the run template.
+
+        Returns:
+            The updated run template.
         """
-        deployment = self.get_deployment(id_or_prefix=id_or_prefix)
-        self.zen_store.delete_deployment(deployment_id=deployment.id)
+        if is_valid_uuid(name_id_or_prefix):
+            template_id = (
+                UUID(name_id_or_prefix)
+                if isinstance(name_id_or_prefix, str)
+                else name_id_or_prefix
+            )
+        else:
+            template_id = self.get_run_template(
+                name_id_or_prefix, hydrate=False
+            ).id
+
+        return self.zen_store.update_run_template(
+            template_id=template_id,
+            template_update=RunTemplateUpdate(
+                name=name,
+                description=description,
+                add_tags=add_tags,
+                remove_tags=remove_tags,
+            ),
+        )
+
+    def delete_run_template(self, name_id_or_prefix: Union[str, UUID]) -> None:
+        """Delete a run template.
+
+        Args:
+            name_id_or_prefix: Name/ID/ID prefix of the template to delete.
+        """
+        if is_valid_uuid(name_id_or_prefix):
+            template_id = (
+                UUID(name_id_or_prefix)
+                if isinstance(name_id_or_prefix, str)
+                else name_id_or_prefix
+            )
+        else:
+            template_id = self.get_run_template(
+                name_id_or_prefix, hydrate=False
+            ).id
+
+        self.zen_store.delete_run_template(template_id=template_id)
 
     # ------------------------------- Schedules --------------------------------
 
@@ -2354,6 +3671,7 @@ class Client(metaclass=ClientMetaClass):
         name: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         pipeline_id: Optional[Union[str, UUID]] = None,
         orchestrator_id: Optional[Union[str, UUID]] = None,
         active: Optional[Union[str, bool]] = None,
@@ -2363,6 +3681,7 @@ class Client(metaclass=ClientMetaClass):
         interval_second: Optional[int] = None,
         catchup: Optional[Union[str, bool]] = None,
         hydrate: bool = False,
+        run_once_start_time: Optional[Union[datetime, str]] = None,
     ) -> Page[ScheduleResponse]:
         """List schedules.
 
@@ -2377,6 +3696,7 @@ class Client(metaclass=ClientMetaClass):
             name: The name of the stack to filter by.
             workspace_id: The id of the workspace to filter by.
             user_id: The  id of the user to filter by.
+            user: Filter by user name/ID.
             pipeline_id: The id of the pipeline to filter by.
             orchestrator_id: The id of the orchestrator to filter by.
             active: Use to filter by active status.
@@ -2387,6 +3707,7 @@ class Client(metaclass=ClientMetaClass):
             catchup: Use to filter by catchup.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
+            run_once_start_time: Use to filter by run once start time.
 
         Returns:
             A list of schedules.
@@ -2402,6 +3723,7 @@ class Client(metaclass=ClientMetaClass):
             name=name,
             workspace_id=workspace_id,
             user_id=user_id,
+            user=user,
             pipeline_id=pipeline_id,
             orchestrator_id=orchestrator_id,
             active=active,
@@ -2410,6 +3732,7 @@ class Client(metaclass=ClientMetaClass):
             end_time=end_time,
             interval_second=interval_second,
             catchup=catchup,
+            run_once_start_time=run_once_start_time,
         )
         schedule_filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_schedules(
@@ -2473,18 +3796,30 @@ class Client(metaclass=ClientMetaClass):
         name: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         pipeline_id: Optional[Union[str, UUID]] = None,
+        pipeline_name: Optional[str] = None,
         user_id: Optional[Union[str, UUID]] = None,
         stack_id: Optional[Union[str, UUID]] = None,
         schedule_id: Optional[Union[str, UUID]] = None,
         build_id: Optional[Union[str, UUID]] = None,
         deployment_id: Optional[Union[str, UUID]] = None,
         code_repository_id: Optional[Union[str, UUID]] = None,
+        template_id: Optional[Union[str, UUID]] = None,
+        model_version_id: Optional[Union[str, UUID]] = None,
         orchestrator_run_id: Optional[str] = None,
         status: Optional[str] = None,
         start_time: Optional[Union[datetime, str]] = None,
         end_time: Optional[Union[datetime, str]] = None,
         num_steps: Optional[Union[int, str]] = None,
         unlisted: Optional[bool] = None,
+        templatable: Optional[bool] = None,
+        tag: Optional[str] = None,
+        user: Optional[Union[UUID, str]] = None,
+        run_metadata: Optional[Dict[str, str]] = None,
+        pipeline: Optional[Union[UUID, str]] = None,
+        code_repository: Optional[Union[UUID, str]] = None,
+        model: Optional[Union[UUID, str]] = None,
+        stack: Optional[Union[UUID, str]] = None,
+        stack_component: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[PipelineRunResponse]:
         """List all pipeline runs.
@@ -2499,12 +3834,16 @@ class Client(metaclass=ClientMetaClass):
             updated: Use the last updated date for filtering
             workspace_id: The id of the workspace to filter by.
             pipeline_id: The id of the pipeline to filter by.
+            pipeline_name: DEPRECATED. Use `pipeline` instead to filter by
+                pipeline name.
             user_id: The id of the user to filter by.
             stack_id: The id of the stack to filter by.
             schedule_id: The id of the schedule to filter by.
             build_id: The id of the build to filter by.
             deployment_id: The id of the deployment to filter by.
             code_repository_id: The id of the code repository to filter by.
+            template_id: The ID of the template to filter by.
+            model_version_id: The ID of the model version to filter by.
             orchestrator_run_id: The run id of the orchestrator to filter by.
             name: The name of the run to filter by.
             status: The status of the pipeline run
@@ -2512,6 +3851,15 @@ class Client(metaclass=ClientMetaClass):
             end_time: The end_time for the pipeline run
             num_steps: The number of steps for the pipeline run
             unlisted: If the runs should be unlisted or not.
+            templatable: If the runs should be templatable or not.
+            tag: Tag to filter by.
+            user: The name/ID of the user to filter by.
+            run_metadata: The run_metadata of the run to filter by.
+            pipeline: The name/ID of the pipeline to filter by.
+            code_repository: Filter by code repository name/ID.
+            model: Filter by model name/ID.
+            stack: Filter by stack name/ID.
+            stack_component: Filter by stack component name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -2529,10 +3877,13 @@ class Client(metaclass=ClientMetaClass):
             name=name,
             workspace_id=workspace_id,
             pipeline_id=pipeline_id,
+            pipeline_name=pipeline_name,
             schedule_id=schedule_id,
             build_id=build_id,
             deployment_id=deployment_id,
             code_repository_id=code_repository_id,
+            template_id=template_id,
+            model_version_id=model_version_id,
             orchestrator_run_id=orchestrator_run_id,
             user_id=user_id,
             stack_id=stack_id,
@@ -2540,7 +3891,16 @@ class Client(metaclass=ClientMetaClass):
             start_time=start_time,
             end_time=end_time,
             num_steps=num_steps,
+            tag=tag,
             unlisted=unlisted,
+            user=user,
+            run_metadata=run_metadata,
+            pipeline=pipeline,
+            code_repository=code_repository,
+            stack=stack,
+            model=model,
+            stack_component=stack_component,
+            templatable=templatable,
         )
         runs_filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_runs(
@@ -2548,21 +3908,6 @@ class Client(metaclass=ClientMetaClass):
             hydrate=hydrate,
         )
 
-    def list_runs(self, **kwargs: Any) -> Page[PipelineRunResponse]:
-        """(Deprecated) List all pipeline runs.
-
-        Args:
-            **kwargs: The filter arguments passed to `list_pipeline_runs`.
-
-        Returns:
-            A page with Pipeline Runs fitting the filter description
-        """
-        logger.warning(
-            "`Client.list_runs()` is deprecated and will be removed in a "
-            "future release. Please use `Client.list_pipeline_runs()` instead."
-        )
-        return self.list_pipeline_runs(**kwargs)
-
     def delete_pipeline_run(
         self,
         name_id_or_prefix: Union[str, UUID],
@@ -2609,17 +3954,19 @@ class Client(metaclass=ClientMetaClass):
         created: Optional[Union[datetime, str]] = None,
         updated: Optional[Union[datetime, str]] = None,
         name: Optional[str] = None,
-        entrypoint_name: Optional[str] = None,
-        code_hash: Optional[str] = None,
         cache_key: Optional[str] = None,
+        code_hash: Optional[str] = None,
         status: Optional[str] = None,
         start_time: Optional[Union[datetime, str]] = None,
         end_time: Optional[Union[datetime, str]] = None,
         pipeline_run_id: Optional[Union[str, UUID]] = None,
+        deployment_id: Optional[Union[str, UUID]] = None,
         original_step_run_id: Optional[Union[str, UUID]] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
-        num_outputs: Optional[Union[int, str]] = None,
+        user: Optional[Union[UUID, str]] = None,
+        model_version_id: Optional[Union[str, UUID]] = None,
+        model: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[StepRunResponse]:
         """List all pipelines.
@@ -2636,14 +3983,16 @@ class Client(metaclass=ClientMetaClass):
             end_time: Use to filter by the time when the step finished running
             workspace_id: The id of the workspace to filter by.
             user_id: The  id of the user to filter by.
-            pipeline_run_id: The  id of the pipeline run to filter by.
-            original_step_run_id: The  id of the pipeline run to filter by.
-            name: The name of the run to filter by.
-            entrypoint_name: The entrypoint_name of the run to filter by.
-            code_hash: The code_hash of the run to filter by.
-            cache_key: The cache_key of the run to filter by.
+            user: Filter by user name/ID.
+            pipeline_run_id: The id of the pipeline run to filter by.
+            deployment_id: The id of the deployment to filter by.
+            original_step_run_id: The id of the original step run to filter by.
+            model_version_id: The ID of the model version to filter by.
+            model: Filter by model name/ID.
+            name: The name of the step run to filter by.
+            cache_key: The cache key of the step run to filter by.
+            code_hash: The code hash of the step run to filter by.
             status: The name of the run to filter by.
-            num_outputs: The number of outputs for the step run
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -2656,10 +4005,10 @@ class Client(metaclass=ClientMetaClass):
             size=size,
             logical_operator=logical_operator,
             id=id,
-            entrypoint_name=entrypoint_name,
-            code_hash=code_hash,
             cache_key=cache_key,
+            code_hash=code_hash,
             pipeline_run_id=pipeline_run_id,
+            deployment_id=deployment_id,
             original_step_run_id=original_step_run_id,
             status=status,
             created=created,
@@ -2669,7 +4018,9 @@ class Client(metaclass=ClientMetaClass):
             name=name,
             workspace_id=workspace_id,
             user_id=user_id,
-            num_outputs=num_outputs,
+            user=user,
+            model_version_id=model_version_id,
+            model=model,
         )
         step_run_filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_run_steps(
@@ -2757,6 +4108,7 @@ class Client(metaclass=ClientMetaClass):
         new_name: Optional[str] = None,
         add_tags: Optional[List[str]] = None,
         remove_tags: Optional[List[str]] = None,
+        has_custom_name: Optional[bool] = None,
     ) -> ArtifactResponse:
         """Update an artifact.
 
@@ -2765,6 +4117,7 @@ class Client(metaclass=ClientMetaClass):
             new_name: The new name of the artifact.
             add_tags: Tags to add to the artifact.
             remove_tags: Tags to remove from the artifact.
+            has_custom_name: Whether the artifact has a custom name.
 
         Returns:
             The updated artifact.
@@ -2774,6 +4127,7 @@ class Client(metaclass=ClientMetaClass):
             name=new_name,
             add_tags=add_tags,
             remove_tags=remove_tags,
+            has_custom_name=has_custom_name,
         )
         return self.zen_store.update_artifact(
             artifact_id=artifact.id, artifact_update=artifact_update
@@ -2805,7 +4159,7 @@ class Client(metaclass=ClientMetaClass):
         """
         if delete_from_artifact_store:
             unused_artifact_versions = depaginate(
-                partial(self.list_artifact_versions, only_unused=True)
+                self.list_artifact_versions, only_unused=True
             )
             for unused_artifact_version in unused_artifact_versions:
                 self._delete_artifact_from_artifact_store(
@@ -2837,13 +4191,35 @@ class Client(metaclass=ClientMetaClass):
         Returns:
             The artifact version.
         """
-        return self._get_entity_version_by_id_or_name_or_prefix(
+        from zenml import get_step_context
+
+        if cll := client_lazy_loader(
+            method_name="get_artifact_version",
+            name_id_or_prefix=name_id_or_prefix,
+            version=version,
+            hydrate=hydrate,
+        ):
+            return cll  # type: ignore[return-value]
+
+        artifact = self._get_entity_version_by_id_or_name_or_prefix(
             get_method=self.zen_store.get_artifact_version,
             list_method=self.list_artifact_versions,
             name_id_or_prefix=name_id_or_prefix,
             version=version,
             hydrate=hydrate,
         )
+        try:
+            step_run = get_step_context().step_run
+            client = Client()
+            client.zen_store.update_run_step(
+                step_run_id=step_run.id,
+                step_run_update=StepRunUpdate(
+                    loaded_artifact_versions={artifact.name: artifact.id}
+                ),
+            )
+        except RuntimeError:
+            pass  # Cannot link to step run if called outside a step
+        return artifact
 
     def list_artifact_versions(
         self,
@@ -2865,10 +4241,15 @@ class Client(metaclass=ClientMetaClass):
         materializer: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        model_version_id: Optional[Union[str, UUID]] = None,
         only_unused: Optional[bool] = False,
         has_custom_name: Optional[bool] = None,
-        hydrate: bool = False,
+        user: Optional[Union[UUID, str]] = None,
+        model: Optional[Union[UUID, str]] = None,
+        pipeline_run: Optional[Union[UUID, str]] = None,
+        run_metadata: Optional[Dict[str, str]] = None,
         tag: Optional[str] = None,
+        hydrate: bool = False,
     ) -> Page[ArtifactVersionResponse]:
         """Get a list of artifact versions.
 
@@ -2890,13 +4271,18 @@ class Client(metaclass=ClientMetaClass):
             uri: The uri of the artifact to filter by.
             materializer: The materializer of the artifact to filter by.
             workspace_id: The id of the workspace to filter by.
-            user_id: The  id of the user to filter by.
+            user_id: The id of the user to filter by.
+            model_version_id: Filter by model version ID.
             only_unused: Only return artifact versions that are not used in
                 any pipeline runs.
             has_custom_name: Filter artifacts with/without custom names.
+            tag: A tag to filter by.
+            user: Filter by user name or ID.
+            model: Filter by model name or ID.
+            pipeline_run: Filter by pipeline run name or ID.
+            run_metadata: Filter by run metadata.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
-            tag: A tag to filter by.
 
         Returns:
             A list of artifact versions.
@@ -2920,9 +4306,13 @@ class Client(metaclass=ClientMetaClass):
             materializer=materializer,
             workspace_id=workspace_id,
             user_id=user_id,
+            model_version_id=model_version_id,
             only_unused=only_unused,
             has_custom_name=has_custom_name,
             tag=tag,
+            user=user,
+            model=model,
+            pipeline_run=pipeline_run,
         )
         artifact_version_filter_model.set_scope_workspace(
             self.active_workspace.id
@@ -3007,7 +4397,7 @@ class Client(metaclass=ClientMetaClass):
             ValueError: If the artifact version is still used in any runs.
         """
         if artifact_version not in depaginate(
-            partial(self.list_artifact_versions, only_unused=True)
+            self.list_artifact_versions, only_unused=True
         ):
             raise ValueError(
                 "The metadata of artifact versions that are used in runs "
@@ -3069,23 +4459,20 @@ class Client(metaclass=ClientMetaClass):
     def create_run_metadata(
         self,
         metadata: Dict[str, "MetadataType"],
-        resource_id: UUID,
-        resource_type: MetadataResourceTypes,
+        resources: List[RunMetadataResource],
         stack_component_id: Optional[UUID] = None,
-    ) -> List[RunMetadataResponse]:
+        publisher_step_id: Optional[UUID] = None,
+    ) -> None:
         """Create run metadata.
 
         Args:
             metadata: The metadata to create as a dictionary of key-value pairs.
-            resource_id: The ID of the resource for which the
-                metadata was produced.
-            resource_type: The type of the resource for which the
+            resources: The list of IDs and types of the resources for that the
                 metadata was produced.
             stack_component_id: The ID of the stack component that produced
                 the metadata.
-
-        Returns:
-            The created metadata, as string to model dictionary.
+            publisher_step_id: The ID of the step execution that publishes
+                this metadata automatically.
         """
         from zenml.metadata.metadata_types import get_metadata_type
 
@@ -3114,80 +4501,13 @@ class Client(metaclass=ClientMetaClass):
         run_metadata = RunMetadataRequest(
             workspace=self.active_workspace.id,
             user=self.active_user.id,
-            resource_id=resource_id,
-            resource_type=resource_type,
+            resources=resources,
             stack_component_id=stack_component_id,
+            publisher_step_id=publisher_step_id,
             values=values,
             types=types,
         )
-        return self.zen_store.create_run_metadata(run_metadata)
-
-    def list_run_metadata(
-        self,
-        sort_by: str = "created",
-        page: int = PAGINATION_STARTING_PAGE,
-        size: int = PAGE_SIZE_DEFAULT,
-        logical_operator: LogicalOperators = LogicalOperators.AND,
-        id: Optional[Union[UUID, str]] = None,
-        created: Optional[Union[datetime, str]] = None,
-        updated: Optional[Union[datetime, str]] = None,
-        workspace_id: Optional[UUID] = None,
-        user_id: Optional[UUID] = None,
-        resource_id: Optional[UUID] = None,
-        resource_type: Optional[MetadataResourceTypes] = None,
-        stack_component_id: Optional[UUID] = None,
-        key: Optional[str] = None,
-        value: Optional["MetadataType"] = None,
-        type: Optional[str] = None,
-        hydrate: bool = False,
-    ) -> Page[RunMetadataResponse]:
-        """List run metadata.
-
-        Args:
-            sort_by: The field to sort the results by.
-            page: The page number to return.
-            size: The number of results to return per page.
-            logical_operator: The logical operator to use for filtering.
-            id: The ID of the metadata.
-            created: The creation time of the metadata.
-            updated: The last update time of the metadata.
-            workspace_id: The ID of the workspace the metadata belongs to.
-            user_id: The ID of the user that created the metadata.
-            resource_id: The ID of the resource the metadata belongs to.
-            resource_type: The type of the resource the metadata belongs to.
-            stack_component_id: The ID of the stack component that produced
-                the metadata.
-            key: The key of the metadata.
-            value: The value of the metadata.
-            type: The type of the metadata.
-            hydrate: Flag deciding whether to hydrate the output model(s)
-                by including metadata fields in the response.
-
-        Returns:
-            The run metadata.
-        """
-        metadata_filter_model = RunMetadataFilter(
-            sort_by=sort_by,
-            page=page,
-            size=size,
-            logical_operator=logical_operator,
-            id=id,
-            created=created,
-            updated=updated,
-            workspace_id=workspace_id,
-            user_id=user_id,
-            resource_id=resource_id,
-            resource_type=resource_type,
-            stack_component_id=stack_component_id,
-            key=key,
-            value=value,
-            type=type,
-        )
-        metadata_filter_model.set_scope_workspace(self.active_workspace.id)
-        return self.zen_store.list_run_metadata(
-            metadata_filter_model,
-            hydrate=hydrate,
-        )
+        self.zen_store.create_run_metadata(run_metadata)
 
     # -------------------------------- Secrets ---------------------------------
 
@@ -3349,10 +4669,7 @@ class Client(metaclass=ClientMetaClass):
                     hydrate=hydrate,
                 )
 
-        msg = (
-            f"No secret found with name, ID or prefix "
-            f"'{name_id_or_prefix}'"
-        )
+        msg = f"No secret found with name, ID or prefix '{name_id_or_prefix}'"
         if scope is not None:
             msg += f" in scope '{scope}'"
 
@@ -3371,6 +4688,7 @@ class Client(metaclass=ClientMetaClass):
         scope: Optional[SecretScope] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[SecretResponse]:
         """Fetches all the secret models.
@@ -3390,6 +4708,7 @@ class Client(metaclass=ClientMetaClass):
             scope: The scope of the secret to filter by.
             workspace_id: The id of the workspace to filter by.
             user_id: The  id of the user to filter by.
+            user: Filter by user name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -3406,6 +4725,7 @@ class Client(metaclass=ClientMetaClass):
             sort_by=sort_by,
             logical_operator=logical_operator,
             user_id=user_id,
+            user=user,
             workspace_id=workspace_id,
             name=name,
             scope=scope,
@@ -3462,7 +4782,7 @@ class Client(metaclass=ClientMetaClass):
             hydrate=True,
         )
 
-        secret_update = SecretUpdate(name=new_name or secret.name)  # type: ignore[call-arg]
+        secret_update = SecretUpdate(name=new_name or secret.name)
 
         if new_scope:
             secret_update.scope = new_scope
@@ -3657,10 +4977,10 @@ class Client(metaclass=ClientMetaClass):
         """
         from zenml.code_repositories import BaseCodeRepository
 
-        code_repo_class: Type[
-            BaseCodeRepository
-        ] = source_utils.load_and_validate_class(
-            source=source, expected_class=BaseCodeRepository
+        code_repo_class: Type[BaseCodeRepository] = (
+            source_utils.load_and_validate_class(
+                source=source, expected_class=BaseCodeRepository
+            )
         )
         try:
             # Validate the repo config
@@ -3720,6 +5040,7 @@ class Client(metaclass=ClientMetaClass):
         name: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[CodeRepositoryResponse]:
         """List all code repositories.
@@ -3735,6 +5056,7 @@ class Client(metaclass=ClientMetaClass):
             name: The name of the code repository to filter by.
             workspace_id: The id of the workspace to filter by.
             user_id: The id of the user to filter by.
+            user: Filter by user name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -3752,6 +5074,7 @@ class Client(metaclass=ClientMetaClass):
             name=name,
             workspace_id=workspace_id,
             user_id=user_id,
+            user=user,
         )
         filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_code_repositories(
@@ -3781,7 +5104,7 @@ class Client(metaclass=ClientMetaClass):
         repo = self.get_code_repository(
             name_id_or_prefix=name_id_or_prefix, allow_name_prefix_match=False
         )
-        update = CodeRepositoryUpdate(  # type: ignore[call-arg]
+        update = CodeRepositoryUpdate(
             name=name, description=description, logo_url=logo_url
         )
         return self.zen_store.update_code_repository(
@@ -4112,6 +5435,7 @@ class Client(metaclass=ClientMetaClass):
         resource_id: Optional[str] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         labels: Optional[Dict[str, Optional[str]]] = None,
         secret_id: Optional[Union[str, UUID]] = None,
         hydrate: bool = False,
@@ -4134,6 +5458,7 @@ class Client(metaclass=ClientMetaClass):
                 they can give access to.
             workspace_id: The id of the workspace to filter by.
             user_id: The id of the user to filter by.
+            user: Filter by user name/ID.
             name: The name of the service connector to filter by.
             labels: The labels of the service connector to filter by.
             secret_id: Filter by the id of the secret that is referenced by the
@@ -4151,6 +5476,7 @@ class Client(metaclass=ClientMetaClass):
             logical_operator=logical_operator,
             workspace_id=workspace_id or self.active_workspace.id,
             user_id=user_id,
+            user=user,
             name=name,
             connector_type=connector_type,
             auth_method=auth_method,
@@ -4177,6 +5503,7 @@ class Client(metaclass=ClientMetaClass):
         configuration: Optional[Dict[str, str]] = None,
         resource_id: Optional[str] = None,
         description: Optional[str] = None,
+        expires_at: Optional[datetime] = None,
         expires_skew_tolerance: Optional[int] = None,
         expiration_seconds: Optional[int] = None,
         labels: Optional[Dict[str, Optional[str]]] = None,
@@ -4220,6 +5547,7 @@ class Client(metaclass=ClientMetaClass):
                 If set to the empty string, the existing resource ID will be
                 removed.
             description: The description of the service connector.
+            expires_at: The new UTC expiration time of the service connector.
             expires_skew_tolerance: The allowed expiration skew for the service
                 connector credentials.
             expiration_seconds: The expiration time of the service connector.
@@ -4286,11 +5614,11 @@ class Client(metaclass=ClientMetaClass):
             connector_type=connector.connector_type,
             description=description or connector_model.description,
             auth_method=auth_method or connector_model.auth_method,
+            expires_at=expires_at,
             expires_skew_tolerance=expires_skew_tolerance,
             expiration_seconds=expiration_seconds,
-            user=self.active_user.id,
-            workspace=self.active_workspace.id,
         )
+
         # Validate and configure the resources
         if configuration is not None:
             # The supplied configuration is a drop-in replacement for the
@@ -4331,21 +5659,32 @@ class Client(metaclass=ClientMetaClass):
 
         if verify:
             # Prefer to verify the connector config server-side if the
-            # implementation if available there, because it ensures
+            # implementation, if available there, because it ensures
             # that the connector can be shared with other users or used
             # from other machines and because some auth methods rely on the
             # server-side authentication environment
+
+            # Convert the update model to a request model for validation
+            connector_request_dict = connector_update.model_dump()
+            connector_request_dict.update(
+                user=self.active_user.id,
+                workspace=self.active_workspace.id,
+            )
+            connector_request = ServiceConnectorRequest.model_validate(
+                connector_request_dict
+            )
+
             if connector.remote:
                 connector_resources = (
                     self.zen_store.verify_service_connector_config(
-                        connector_update,
+                        service_connector=connector_request,
                         list_resources=list_resources,
                     )
                 )
             else:
                 connector_instance = (
                     service_connector_registry.instantiate_connector(
-                        model=connector_update
+                        model=connector_request,
                     )
                 )
                 connector_resources = connector_instance.verify(
@@ -4509,6 +5848,7 @@ class Client(metaclass=ClientMetaClass):
             name_id_or_prefix=name_id_or_prefix,
             resource_type=resource_type,
             resource_id=resource_id,
+            verify=False,
         )
 
         connector_client.configure_local_client(
@@ -4522,6 +5862,7 @@ class Client(metaclass=ClientMetaClass):
         name_id_or_prefix: Union[UUID, str],
         resource_type: Optional[str] = None,
         resource_id: Optional[str] = None,
+        verify: bool = False,
     ) -> "ServiceConnector":
         """Get the client side of a service connector instance to use with a local client.
 
@@ -4537,6 +5878,8 @@ class Client(metaclass=ClientMetaClass):
                 equivalent to the one requested, a `ValueError` exception is
                 raised. May be omitted for connectors and resource types that do
                 not support multiple resource instances.
+            verify: Whether to verify that the service connector configuration
+                and credentials can be used to gain access to the resource.
 
         Returns:
             The client side of the indicated service connector instance that can
@@ -4574,9 +5917,10 @@ class Client(metaclass=ClientMetaClass):
                 )
             )
 
-            # Verify the connector client on the local machine, because the
-            # server-side implementation may not be able to do so
-            connector_client.verify()
+            if verify:
+                # Verify the connector client on the local machine, because the
+                # server-side implementation may not be able to do so
+                connector_client.verify()
         else:
             connector_instance = (
                 service_connector_registry.instantiate_connector(
@@ -4727,6 +6071,7 @@ class Client(metaclass=ClientMetaClass):
         ethics: Optional[str] = None,
         add_tags: Optional[List[str]] = None,
         remove_tags: Optional[List[str]] = None,
+        save_models_to_registry: Optional[bool] = None,
     ) -> ModelResponse:
         """Updates an existing model in Model Control Plane.
 
@@ -4742,6 +6087,8 @@ class Client(metaclass=ClientMetaClass):
             ethics: The ethical implications of the model.
             add_tags: Tags to add to the model.
             remove_tags: Tags to remove from to the model.
+            save_models_to_registry: Whether to save the model to the
+                registry.
 
         Returns:
             The updated model.
@@ -4761,6 +6108,7 @@ class Client(metaclass=ClientMetaClass):
                 ethics=ethics,
                 add_tags=add_tags,
                 remove_tags=remove_tags,
+                save_models_to_registry=save_models_to_registry,
             ),
         )
 
@@ -4779,6 +6127,10 @@ class Client(metaclass=ClientMetaClass):
         Returns:
             The model of interest.
         """
+        if cll := client_lazy_loader(
+            "get_model", model_name_or_id=model_name_or_id, hydrate=hydrate
+        ):
+            return cll  # type: ignore[return-value]
         return self.zen_store.get_model(
             model_name_or_id=model_name_or_id,
             hydrate=hydrate,
@@ -4793,6 +6145,7 @@ class Client(metaclass=ClientMetaClass):
         created: Optional[Union[datetime, str]] = None,
         updated: Optional[Union[datetime, str]] = None,
         name: Optional[str] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
         tag: Optional[str] = None,
     ) -> Page[ModelResponse]:
@@ -4806,6 +6159,7 @@ class Client(metaclass=ClientMetaClass):
             created: Use to filter by time of creation
             updated: Use the last updated date for filtering
             name: The name of the model to filter by.
+            user: Filter by user name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
             tag: The tag of the model to filter by.
@@ -4822,6 +6176,7 @@ class Client(metaclass=ClientMetaClass):
             created=created,
             updated=updated,
             tag=tag,
+            user=user,
         )
 
         return self.zen_store.list_models(
@@ -4879,7 +6234,7 @@ class Client(metaclass=ClientMetaClass):
 
     def get_model_version(
         self,
-        model_name_or_id: Union[str, UUID],
+        model_name_or_id: Optional[Union[str, UUID]] = None,
         model_version_name_or_number_or_id: Optional[
             Union[str, int, ModelStages, UUID]
         ] = None,
@@ -4902,7 +6257,25 @@ class Client(metaclass=ClientMetaClass):
         Raises:
             RuntimeError: In case method inputs don't adhere to restrictions.
             KeyError: In case no model version with the identifiers exists.
+            ValueError: In case retrieval is attempted using non UUID model version
+                identifier and no model identifier provided.
         """
+        if (
+            not is_valid_uuid(model_version_name_or_number_or_id)
+            and model_name_or_id is None
+        ):
+            raise ValueError(
+                "No model identifier provided and model version identifier "
+                f"`{model_version_name_or_number_or_id}` is not a valid UUID."
+            )
+        if cll := client_lazy_loader(
+            "get_model_version",
+            model_name_or_id=model_name_or_id,
+            model_version_name_or_number_or_id=model_version_name_or_number_or_id,
+            hydrate=hydrate,
+        ):
+            return cll  # type: ignore[return-value]
+
         if model_version_name_or_number_or_id is None:
             model_version_name_or_number_or_id = ModelStages.LATEST
 
@@ -4983,6 +6356,7 @@ class Client(metaclass=ClientMetaClass):
         name: Optional[str] = None,
         number: Optional[int] = None,
         stage: Optional[Union[str, ModelStages]] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
         tag: Optional[str] = None,
     ) -> Page[ModelVersionResponse]:
@@ -5000,6 +6374,7 @@ class Client(metaclass=ClientMetaClass):
             name: name or id of the model version.
             number: number of the model version.
             stage: stage of the model version.
+            user: Filter by user name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
             tag: The tag to filter by.
@@ -5018,6 +6393,7 @@ class Client(metaclass=ClientMetaClass):
             number=number,
             stage=stage,
             tag=tag,
+            user=user,
         )
 
         return self.zen_store.list_model_versions(
@@ -5085,9 +6461,6 @@ class Client(metaclass=ClientMetaClass):
         logical_operator: LogicalOperators = LogicalOperators.AND,
         created: Optional[Union[datetime, str]] = None,
         updated: Optional[Union[datetime, str]] = None,
-        workspace_id: Optional[Union[UUID, str]] = None,
-        user_id: Optional[Union[UUID, str]] = None,
-        model_id: Optional[Union[UUID, str]] = None,
         model_version_id: Optional[Union[UUID, str]] = None,
         artifact_version_id: Optional[Union[UUID, str]] = None,
         artifact_name: Optional[str] = None,
@@ -5095,6 +6468,7 @@ class Client(metaclass=ClientMetaClass):
         only_model_artifacts: Optional[bool] = None,
         only_deployment_artifacts: Optional[bool] = None,
         has_custom_name: Optional[bool] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[ModelVersionArtifactResponse]:
         """Get model version to artifact links by filter in Model Control Plane.
@@ -5106,9 +6480,6 @@ class Client(metaclass=ClientMetaClass):
             logical_operator: Which logical operator to use [and, or]
             created: Use to filter by time of creation
             updated: Use the last updated date for filtering
-            workspace_id: Use the workspace id for filtering
-            user_id: Use the user id for filtering
-            model_id: Use the model id for filtering
             model_version_id: Use the model version id for filtering
             artifact_version_id: Use the artifact id for filtering
             artifact_name: Use the artifact name for filtering
@@ -5116,6 +6487,7 @@ class Client(metaclass=ClientMetaClass):
             only_model_artifacts: Use to filter by model artifacts
             only_deployment_artifacts: Use to filter by deployment artifacts
             has_custom_name: Filter artifacts with/without custom names.
+            user: Filter by user name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -5130,9 +6502,6 @@ class Client(metaclass=ClientMetaClass):
                 size=size,
                 created=created,
                 updated=updated,
-                workspace_id=workspace_id,
-                user_id=user_id,
-                model_id=model_id,
                 model_version_id=model_version_id,
                 artifact_version_id=artifact_version_id,
                 artifact_name=artifact_name,
@@ -5140,6 +6509,7 @@ class Client(metaclass=ClientMetaClass):
                 only_model_artifacts=only_model_artifacts,
                 only_deployment_artifacts=only_deployment_artifacts,
                 has_custom_name=has_custom_name,
+                user=user,
             ),
             hydrate=hydrate,
         )
@@ -5203,12 +6573,10 @@ class Client(metaclass=ClientMetaClass):
         logical_operator: LogicalOperators = LogicalOperators.AND,
         created: Optional[Union[datetime, str]] = None,
         updated: Optional[Union[datetime, str]] = None,
-        workspace_id: Optional[Union[UUID, str]] = None,
-        user_id: Optional[Union[UUID, str]] = None,
-        model_id: Optional[Union[UUID, str]] = None,
         model_version_id: Optional[Union[UUID, str]] = None,
         pipeline_run_id: Optional[Union[UUID, str]] = None,
         pipeline_run_name: Optional[str] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[ModelVersionPipelineRunResponse]:
         """Get all model version to pipeline run links by filter.
@@ -5220,12 +6588,10 @@ class Client(metaclass=ClientMetaClass):
             logical_operator: Which logical operator to use [and, or]
             created: Use to filter by time of creation
             updated: Use the last updated date for filtering
-            workspace_id: Use the workspace id for filtering
-            user_id: Use the user id for filtering
-            model_id: Use the model id for filtering
             model_version_id: Use the model version id for filtering
             pipeline_run_id: Use the pipeline run id for filtering
             pipeline_run_name: Use the pipeline run name for filtering
+            user: Filter by user name or ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response
 
@@ -5240,12 +6606,10 @@ class Client(metaclass=ClientMetaClass):
                 size=size,
                 created=created,
                 updated=updated,
-                workspace_id=workspace_id,
-                user_id=user_id,
-                model_id=model_id,
                 model_version_id=model_version_id,
                 pipeline_run_id=pipeline_run_id,
                 pipeline_run_name=pipeline_run_name,
+                user=user,
             ),
             hydrate=hydrate,
         )
@@ -5265,6 +6629,7 @@ class Client(metaclass=ClientMetaClass):
         client_id: Union[UUID, str, None] = None,
         status: Union[OAuthDeviceStatus, str, None] = None,
         trusted_device: Union[bool, str, None] = None,
+        user: Optional[Union[UUID, str]] = None,
         failed_auth_attempts: Union[int, str, None] = None,
         last_login: Optional[Union[datetime, str, None]] = None,
         hydrate: bool = False,
@@ -5282,6 +6647,7 @@ class Client(metaclass=ClientMetaClass):
             expires: Use the expiration date for filtering.
             client_id: Use the client id for filtering.
             status: Use the status for filtering.
+            user: Filter by user name/ID.
             trusted_device: Use the trusted device flag for filtering.
             failed_auth_attempts: Use the failed auth attempts for filtering.
             last_login: Use the last login date for filtering.
@@ -5301,6 +6667,7 @@ class Client(metaclass=ClientMetaClass):
             updated=updated,
             expires=expires,
             client_id=client_id,
+            user=user,
             status=status,
             trusted_device=trusted_device,
             failed_auth_attempts=failed_auth_attempts,
@@ -5392,10 +6759,79 @@ class Client(metaclass=ClientMetaClass):
         )
         self.zen_store.delete_authorized_device(device.id)
 
+    # --------------------------- Trigger Executions ---------------------------
+
+    def get_trigger_execution(
+        self,
+        trigger_execution_id: UUID,
+        hydrate: bool = True,
+    ) -> TriggerExecutionResponse:
+        """Get a trigger execution by ID.
+
+        Args:
+            trigger_execution_id: The ID of the trigger execution to get.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            The trigger execution.
+        """
+        return self.zen_store.get_trigger_execution(
+            trigger_execution_id=trigger_execution_id, hydrate=hydrate
+        )
+
+    def list_trigger_executions(
+        self,
+        sort_by: str = "created",
+        page: int = PAGINATION_STARTING_PAGE,
+        size: int = PAGE_SIZE_DEFAULT,
+        logical_operator: LogicalOperators = LogicalOperators.AND,
+        trigger_id: Optional[UUID] = None,
+        user: Optional[Union[UUID, str]] = None,
+        hydrate: bool = False,
+    ) -> Page[TriggerExecutionResponse]:
+        """List all trigger executions matching the given filter criteria.
+
+        Args:
+            sort_by: The column to sort by.
+            page: The page of items.
+            size: The maximum size of all pages.
+            logical_operator: Which logical operator to use [and, or].
+            trigger_id: ID of the trigger to filter by.
+            user: Filter by user name/ID.
+            hydrate: Flag deciding whether to hydrate the output model(s)
+                by including metadata fields in the response.
+
+        Returns:
+            A list of all trigger executions matching the filter criteria.
+        """
+        filter_model = TriggerExecutionFilter(
+            trigger_id=trigger_id,
+            sort_by=sort_by,
+            page=page,
+            size=size,
+            user=user,
+            logical_operator=logical_operator,
+        )
+        filter_model.set_scope_workspace(self.active_workspace.id)
+        return self.zen_store.list_trigger_executions(
+            trigger_execution_filter_model=filter_model, hydrate=hydrate
+        )
+
+    def delete_trigger_execution(self, trigger_execution_id: UUID) -> None:
+        """Delete a trigger execution.
+
+        Args:
+            trigger_execution_id: The ID of the trigger execution to delete.
+        """
+        self.zen_store.delete_trigger_execution(
+            trigger_execution_id=trigger_execution_id
+        )
+
     # ---- utility prefix matching get functions -----
 
-    @staticmethod
     def _get_entity_by_id_or_name_or_prefix(
+        self,
         get_method: Callable[..., AnyResponse],
         list_method: Callable[..., Page[AnyResponse]],
         name_id_or_prefix: Union[str, UUID],
@@ -5441,7 +6877,7 @@ class Client(metaclass=ClientMetaClass):
 
         # If still no match, try with prefix now
         if entity.total == 0:
-            return Client._get_entity_by_prefix(
+            return self._get_entity_by_prefix(
                 get_method=get_method,
                 list_method=list_method,
                 partial_id_or_name=name_id_or_prefix,
@@ -5465,8 +6901,8 @@ class Client(metaclass=ClientMetaClass):
             f"only one of the {entity_label}s."
         )
 
-    @staticmethod
     def _get_entity_version_by_id_or_name_or_prefix(
+        self,
         get_method: Callable[..., AnyResponse],
         list_method: Callable[..., Page[AnyResponse]],
         name_id_or_prefix: Union[str, UUID],
@@ -5530,8 +6966,8 @@ class Client(metaclass=ClientMetaClass):
                 f"only one of the {entity_label}s."
             )
 
-    @staticmethod
     def _get_entity_by_prefix(
+        self,
         get_method: Callable[..., AnyResponse],
         list_method: Callable[..., Page[AnyResponse]],
         partial_id_or_name: str,
@@ -5800,6 +7236,7 @@ class Client(metaclass=ClientMetaClass):
             NotImplementedError: If the client is not connected to a ZenML
                 server.
         """
+        from zenml.login.credentials_store import get_credentials_store
         from zenml.zen_stores.rest_zen_store import RestZenStore
 
         zen_store = self.zen_store
@@ -5808,8 +7245,15 @@ class Client(metaclass=ClientMetaClass):
                 "API key configuration is only supported if connected to a "
                 "ZenML server."
             )
+
+        credentials_store = get_credentials_store()
         assert isinstance(zen_store, RestZenStore)
-        zen_store.set_api_key(api_key=key)
+
+        credentials_store.set_api_key(server_url=zen_store.url, api_key=key)
+
+        # Force a re-authentication to start using the new API key
+        # right away.
+        zen_store.authenticate(force=True)
 
     def list_api_keys(
         self,